diff --git a/src/blas/librocblas.jl b/src/blas/librocblas.jl
index c9498b72a..b8b2a774a 100644
--- a/src/blas/librocblas.jl
+++ b/src/blas/librocblas.jl
@@ -1,4 +1,8 @@
-const rocblas_handle = Ptr{Cvoid}
+using CEnum
+
+mutable struct _rocblas_handle end
+
+const rocblas_handle = Ptr{_rocblas_handle}
 
 @cenum rocblas_status_::UInt32 begin
     rocblas_status_success = 0
@@ -15,18 +19,31 @@ const rocblas_handle = Ptr{Cvoid}
     rocblas_status_invalid_value = 11
     rocblas_status_continue = 12
     rocblas_status_check_numerics_fail = 13
+    rocblas_status_excluded_from_build = 14
+    rocblas_status_arch_mismatch = 15
 end
 
 const rocblas_status = rocblas_status_
 
 function rocblas_set_start_stop_events(handle, startEvent, stopEvent)
-    ccall((:rocblas_set_start_stop_events, librocblas), rocblas_status, (rocblas_handle, hipEvent_t, hipEvent_t), handle, startEvent, stopEvent)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_set_start_stop_events(handle::rocblas_handle,
+                                                    startEvent::hipEvent_t,
+                                                    stopEvent::hipEvent_t)::rocblas_status
 end
 
 struct rocblas_bfloat16
     data::UInt16
 end
 
+struct rocblas_f8
+    data::UInt8
+end
+
+struct rocblas_bf8
+    data::UInt8
+end
+
 mutable struct rocblas_device_malloc_base end
 
 const rocblas_int = Int32
@@ -39,13 +56,6 @@ const rocblas_double = Cdouble
 
 const rocblas_half = Float16
 
-struct rocblas_int8x4
-    a::Int8
-    b::Int8
-    c::Int8
-    d::Int8
-end
-
 const rocblas_float_complex = ComplexF32
 
 const rocblas_double_complex = ComplexF64
@@ -98,10 +108,24 @@ const rocblas_side = rocblas_side_
     rocblas_datatype_u32_c = 167
     rocblas_datatype_bf16_r = 168
     rocblas_datatype_bf16_c = 169
+    rocblas_datatype_f8_r = 170
+    rocblas_datatype_bf8_r = 171
+    rocblas_datatype_invalid = 255
 end
 
 const rocblas_datatype = rocblas_datatype_
 
+@cenum rocblas_computetype_::UInt32 begin
+    rocblas_compute_type_f32 = 300
+    rocblas_compute_type_f8_f8_f32 = 301
+    rocblas_compute_type_f8_bf8_f32 = 302
+    rocblas_compute_type_bf8_f8_f32 = 303
+    rocblas_compute_type_bf8_bf8_f32 = 304
+    rocblas_compute_type_invalid = 455
+end
+
+const rocblas_computetype = rocblas_computetype_
+
 @cenum rocblas_pointer_mode_::UInt32 begin
     rocblas_pointer_mode_host = 0
     rocblas_pointer_mode_device = 1
@@ -135,21 +159,31 @@ const rocblas_layer_mode = rocblas_layer_mode_
 
 @cenum rocblas_gemm_algo_::UInt32 begin
     rocblas_gemm_algo_standard = 0
+    rocblas_gemm_algo_solution_index = 1
 end
 
 const rocblas_gemm_algo = rocblas_gemm_algo_
 
+@cenum rocblas_geam_ex_operation_::UInt32 begin
+    rocblas_geam_ex_operation_min_plus = 0
+    rocblas_geam_ex_operation_plus_min = 1
+end
+
+const rocblas_geam_ex_operation = rocblas_geam_ex_operation_
+
 @cenum rocblas_gemm_flags_::UInt32 begin
     rocblas_gemm_flags_none = 0
-    rocblas_gemm_flags_pack_int8x4 = 1
     rocblas_gemm_flags_use_cu_efficiency = 2
     rocblas_gemm_flags_fp16_alt_impl = 4
+    rocblas_gemm_flags_check_solution_index = 8
+    rocblas_gemm_flags_fp16_alt_impl_rnz = 16
+    rocblas_gemm_flags_stochastic_rounding = 32
 end
 
 const rocblas_gemm_flags = rocblas_gemm_flags_
 
 struct rocblas_union_u
-    data::NTuple{16, UInt8}
+    data::NTuple{16,UInt8}
 end
 
 function Base.getproperty(x::Ptr{rocblas_union_u}, f::Symbol)
@@ -170,7 +204,7 @@ function Base.getproperty(x::rocblas_union_u, f::Symbol)
 end
 
 function Base.setproperty!(x::Ptr{rocblas_union_u}, f::Symbol, v)
-    unsafe_store!(getproperty(x, f), v)
+    return unsafe_store!(getproperty(x, f), v)
 end
 
 const rocblas_union_t = rocblas_union_u
@@ -184,3099 +218,7500 @@ end
 
 const rocblas_check_numerics_mode = rocblas_check_numerics_mode_
 
-@cenum rocblas_svect_::UInt32 begin
-    rocblas_svect_all = 191
-    rocblas_svect_singular = 192
-    rocblas_svect_overwrite = 193
-    rocblas_svect_none = 194
-end
-
-const rocblas_svect = rocblas_svect_
-
-@cenum rocblas_evect_::UInt32 begin
-    rocblas_evect_original = 211
-    rocblas_evect_tridiagonal = 212
-    rocblas_evect_none = 213
+@cenum rocblas_math_mode_::UInt32 begin
+    rocblas_default_math = 0
+    rocblas_xf32_xdl_math_op = 1
 end
 
-const rocblas_evect = rocblas_evect_
+const rocblas_math_mode = rocblas_math_mode_
 
 function rocblas_create_handle(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_create_handle, librocblas), rocblas_status, (Ptr{rocblas_handle},), handle)
+    @ccall librocblas.rocblas_create_handle(handle::Ptr{rocblas_handle})::rocblas_status
 end
 
 function rocblas_destroy_handle(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_destroy_handle, librocblas), rocblas_status, (rocblas_handle,), handle)
+    @ccall librocblas.rocblas_destroy_handle(handle::rocblas_handle)::rocblas_status
 end
 
 function rocblas_set_stream(handle, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_stream, librocblas), rocblas_status, (rocblas_handle, hipStream_t), handle, stream)
+    @ccall librocblas.rocblas_set_stream(handle::rocblas_handle,
+                                         stream::hipStream_t)::rocblas_status
 end
 
 function rocblas_get_stream(handle, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_stream, librocblas), rocblas_status, (rocblas_handle, Ptr{hipStream_t}), handle, stream)
+    @ccall librocblas.rocblas_get_stream(handle::rocblas_handle,
+                                         stream::Ptr{hipStream_t})::rocblas_status
 end
 
 function rocblas_set_pointer_mode(handle, pointer_mode)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_pointer_mode, librocblas), rocblas_status, (rocblas_handle, rocblas_pointer_mode), handle, pointer_mode)
+    @ccall librocblas.rocblas_set_pointer_mode(handle::rocblas_handle,
+                                               pointer_mode::rocblas_pointer_mode)::rocblas_status
 end
 
 function rocblas_get_pointer_mode(handle, pointer_mode)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_pointer_mode, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_pointer_mode}), handle, pointer_mode)
+    @ccall librocblas.rocblas_get_pointer_mode(handle::rocblas_handle,
+                                               pointer_mode::Ptr{rocblas_pointer_mode})::rocblas_status
 end
 
 function rocblas_set_atomics_mode(handle, atomics_mode)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_atomics_mode, librocblas), rocblas_status, (rocblas_handle, rocblas_atomics_mode), handle, atomics_mode)
+    @ccall librocblas.rocblas_set_atomics_mode(handle::rocblas_handle,
+                                               atomics_mode::rocblas_atomics_mode)::rocblas_status
 end
 
 function rocblas_get_atomics_mode(handle, atomics_mode)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_atomics_mode, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_atomics_mode}), handle, atomics_mode)
+    @ccall librocblas.rocblas_get_atomics_mode(handle::rocblas_handle,
+                                               atomics_mode::Ptr{rocblas_atomics_mode})::rocblas_status
+end
+
+function rocblas_set_math_mode(handle, math_mode)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_set_math_mode(handle::rocblas_handle,
+                                            math_mode::rocblas_math_mode)::rocblas_status
 end
 
-function rocblas_query_int8_layout_flag(handle, flag)
+function rocblas_get_math_mode(handle, math_mode)
     AMDGPU.prepare_state()
-    ccall((:rocblas_query_int8_layout_flag, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_gemm_flags}), handle, flag)
+    @ccall librocblas.rocblas_get_math_mode(handle::rocblas_handle,
+                                            math_mode::Ptr{rocblas_math_mode})::rocblas_status
 end
 
 function rocblas_pointer_to_mode(ptr)
     AMDGPU.prepare_state()
-    ccall((:rocblas_pointer_to_mode, librocblas), rocblas_pointer_mode, (Ptr{Cvoid},), ptr)
+    @ccall librocblas.rocblas_pointer_to_mode(ptr::Ptr{Cvoid})::rocblas_pointer_mode
 end
 
 function rocblas_set_vector(n, elem_size, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_vector, librocblas), rocblas_status, (rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int), n, elem_size, x, incx, y, incy)
+    @ccall librocblas.rocblas_set_vector(n::rocblas_int, elem_size::rocblas_int,
+                                         x::Ptr{Cvoid}, incx::rocblas_int, y::Ptr{Cvoid},
+                                         incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_get_vector(n, elem_size, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_vector, librocblas), rocblas_status, (rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int), n, elem_size, x, incx, y, incy)
+    @ccall librocblas.rocblas_get_vector(n::rocblas_int, elem_size::rocblas_int,
+                                         x::Ptr{Cvoid}, incx::rocblas_int, y::Ptr{Cvoid},
+                                         incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_set_matrix(rows, cols, elem_size, a, lda, b, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_matrix, librocblas), rocblas_status, (rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int), rows, cols, elem_size, a, lda, b, ldb)
+    @ccall librocblas.rocblas_set_matrix(rows::rocblas_int, cols::rocblas_int,
+                                         elem_size::rocblas_int, a::Ptr{Cvoid},
+                                         lda::rocblas_int, b::Ptr{Cvoid},
+                                         ldb::rocblas_int)::rocblas_status
 end
 
 function rocblas_get_matrix(rows, cols, elem_size, a, lda, b, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_matrix, librocblas), rocblas_status, (rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int), rows, cols, elem_size, a, lda, b, ldb)
+    @ccall librocblas.rocblas_get_matrix(rows::rocblas_int, cols::rocblas_int,
+                                         elem_size::rocblas_int, a::Ptr{Cvoid},
+                                         lda::rocblas_int, b::Ptr{Cvoid},
+                                         ldb::rocblas_int)::rocblas_status
 end
 
 function rocblas_set_vector_async(n, elem_size, x, incx, y, incy, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_vector_async, librocblas), rocblas_status, (rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int, hipStream_t), n, elem_size, x, incx, y, incy, stream)
+    @ccall librocblas.rocblas_set_vector_async(n::rocblas_int, elem_size::rocblas_int,
+                                               x::Ptr{Cvoid}, incx::rocblas_int,
+                                               y::Ptr{Cvoid}, incy::rocblas_int,
+                                               stream::hipStream_t)::rocblas_status
 end
 
 function rocblas_get_vector_async(n, elem_size, x, incx, y, incy, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_vector_async, librocblas), rocblas_status, (rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int, hipStream_t), n, elem_size, x, incx, y, incy, stream)
+    @ccall librocblas.rocblas_get_vector_async(n::rocblas_int, elem_size::rocblas_int,
+                                               x::Ptr{Cvoid}, incx::rocblas_int,
+                                               y::Ptr{Cvoid}, incy::rocblas_int,
+                                               stream::hipStream_t)::rocblas_status
 end
 
 function rocblas_set_matrix_async(rows, cols, elem_size, a, lda, b, ldb, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_matrix_async, librocblas), rocblas_status, (rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int, hipStream_t), rows, cols, elem_size, a, lda, b, ldb, stream)
+    @ccall librocblas.rocblas_set_matrix_async(rows::rocblas_int, cols::rocblas_int,
+                                               elem_size::rocblas_int, a::Ptr{Cvoid},
+                                               lda::rocblas_int, b::Ptr{Cvoid},
+                                               ldb::rocblas_int,
+                                               stream::hipStream_t)::rocblas_status
 end
 
 function rocblas_get_matrix_async(rows, cols, elem_size, a, lda, b, ldb, stream)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_matrix_async, librocblas), rocblas_status, (rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int, hipStream_t), rows, cols, elem_size, a, lda, b, ldb, stream)
+    @ccall librocblas.rocblas_get_matrix_async(rows::rocblas_int, cols::rocblas_int,
+                                               elem_size::rocblas_int, a::Ptr{Cvoid},
+                                               lda::rocblas_int, b::Ptr{Cvoid},
+                                               ldb::rocblas_int,
+                                               stream::hipStream_t)::rocblas_status
 end
 
 function rocblas_set_solution_fitness_query(handle, fitness)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_solution_fitness_query, librocblas), rocblas_status, (rocblas_handle, Ptr{Cdouble}), handle, fitness)
+    @ccall librocblas.rocblas_set_solution_fitness_query(handle::rocblas_handle,
+                                                         fitness::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_set_performance_metric(handle, metric)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_performance_metric, librocblas), rocblas_status, (rocblas_handle, rocblas_performance_metric), handle, metric)
+    @ccall librocblas.rocblas_set_performance_metric(handle::rocblas_handle,
+                                                     metric::rocblas_performance_metric)::rocblas_status
 end
 
 function rocblas_get_performance_metric(handle, metric)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_performance_metric, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_performance_metric}), handle, metric)
+    @ccall librocblas.rocblas_get_performance_metric(handle::rocblas_handle,
+                                                     metric::Ptr{rocblas_performance_metric})::rocblas_status
 end
 
 function rocblas_sscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_sscal(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                    incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_dscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_dscal(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                    incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_cscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_cscal(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_zscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_zscal(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_csscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_csscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_csscal(handle::rocblas_handle, n::rocblas_int,
+                                     alpha::Ptr{Cfloat}, x::Ptr{rocblas_float_complex},
+                                     incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdscal(handle, n, alpha, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdscal, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, n, alpha, x, incx)
+    @ccall librocblas.rocblas_zdscal(handle::rocblas_handle, n::rocblas_int,
+                                     alpha::Ptr{Cdouble}, x::Ptr{rocblas_double_complex},
+                                     incx::rocblas_int)::rocblas_status
 end
 
 function rocblas_sscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_sscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{Cfloat}, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_dscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_dscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{Cdouble}, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_cscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_cscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_zscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_csscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_csscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_csscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                             alpha::Ptr{Cfloat},
+                                             x::Ptr{Ptr{rocblas_float_complex}},
+                                             incx::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdscal_batched(handle, n, alpha, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdscal_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, batch_count)
+    @ccall librocblas.rocblas_zdscal_batched(handle::rocblas_handle, n::rocblas_int,
+                                             alpha::Ptr{Cdouble},
+                                             x::Ptr{Ptr{rocblas_double_complex}},
+                                             incx::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_sscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_dscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_cscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_cscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_csscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_csscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_csscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     alpha::Ptr{Cfloat},
+                                                     x::Ptr{rocblas_float_complex},
+                                                     incx::rocblas_int,
+                                                     stride_x::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdscal_strided_batched(handle, n, alpha, x, incx, stride_x, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdscal_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zdscal_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     alpha::Ptr{Cdouble},
+                                                     x::Ptr{rocblas_double_complex},
+                                                     incx::rocblas_int,
+                                                     stride_x::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_scopy(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scopy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_scopy(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_dcopy(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dcopy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_dcopy(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_ccopy(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ccopy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_ccopy(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_zcopy(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zcopy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_zcopy(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_scopy_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scopy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_scopy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_dcopy_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dcopy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_dcopy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_ccopy_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ccopy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_ccopy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zcopy_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zcopy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_zcopy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_scopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_scopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scopy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_scopy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dcopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_dcopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dcopy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_dcopy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ccopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_ccopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ccopy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_ccopy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zcopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_zcopy_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zcopy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_zcopy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sdot(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sdot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_sdot(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                   incx::rocblas_int, y::Ptr{Cfloat}, incy::rocblas_int,
+                                   result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_ddot(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ddot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_ddot(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                   incx::rocblas_int, y::Ptr{Cdouble}, incy::rocblas_int,
+                                   result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_hdot(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_hdot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_half}, rocblas_int, Ptr{rocblas_half}, rocblas_int, Ptr{rocblas_half}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_hdot(handle::rocblas_handle, n::rocblas_int,
+                                   x::Ptr{rocblas_half}, incx::rocblas_int,
+                                   y::Ptr{rocblas_half}, incy::rocblas_int,
+                                   result::Ptr{rocblas_half})::rocblas_status
 end
 
 function rocblas_bfdot(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_bfdot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_bfloat16}, rocblas_int, Ptr{rocblas_bfloat16}, rocblas_int, Ptr{rocblas_bfloat16}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_bfdot(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_bfloat16}, incx::rocblas_int,
+                                    y::Ptr{rocblas_bfloat16}, incy::rocblas_int,
+                                    result::Ptr{rocblas_bfloat16})::rocblas_status
 end
 
 function rocblas_cdotu(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdotu, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_cdotu(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    result::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_zdotu(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdotu, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_zdotu(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    result::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_cdotc(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdotc, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_cdotc(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    result::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_zdotc(handle, n, x, incx, y, incy, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdotc, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, y, incy, result)
+    @ccall librocblas.rocblas_zdotc(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    result::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_sdot_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sdot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_sdot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                           batch_count::rocblas_int,
+                                           result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_ddot_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ddot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_ddot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                           batch_count::rocblas_int,
+                                           result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_hdot_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_hdot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_half}}, rocblas_int, Ptr{Ptr{rocblas_half}}, rocblas_int, rocblas_int, Ptr{rocblas_half}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_hdot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{rocblas_half}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{rocblas_half}}, incy::rocblas_int,
+                                           batch_count::rocblas_int,
+                                           result::Ptr{rocblas_half})::rocblas_status
 end
 
 function rocblas_bfdot_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_bfdot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_bfloat16}}, rocblas_int, Ptr{Ptr{rocblas_bfloat16}}, rocblas_int, rocblas_int, Ptr{rocblas_bfloat16}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_bfdot_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_bfloat16}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_bfloat16}},
+                                            incy::rocblas_int, batch_count::rocblas_int,
+                                            result::Ptr{rocblas_bfloat16})::rocblas_status
 end
 
 function rocblas_cdotu_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdotu_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_cdotu_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int, batch_count::rocblas_int,
+                                            result::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_zdotu_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdotu_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_zdotu_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int, batch_count::rocblas_int,
+                                            result::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_cdotc_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdotc_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, y, incy, batch_count, result)
+    @ccall librocblas.rocblas_cdotc_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int, batch_count::rocblas_int,
+                                            result::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_zdotc_batched(handle, n, x, incx, y, incy, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdotc_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, y, incy, batch_count, result)
-end
-
-function rocblas_sdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sdot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_ddot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ddot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_hdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_hdot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_half}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_bfdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_bfdot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_bfloat16}, rocblas_int, rocblas_stride, Ptr{rocblas_bfloat16}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_bfloat16}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_cdotu_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cdotu_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_zdotu_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zdotu_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_cdotc_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cdotc_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_float_complex}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-end
-
-function rocblas_zdotc_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zdotc_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_double_complex}), handle, n, x, incx, stridex, y, incy, stridey, batch_count, result)
+    @ccall librocblas.rocblas_zdotc_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int, batch_count::rocblas_int,
+                                            result::Ptr{rocblas_double_complex})::rocblas_status
+end
+
+function rocblas_sdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                      batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sdot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{Cfloat}, incx::rocblas_int,
+                                                   stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                   incy::rocblas_int,
+                                                   stridey::rocblas_stride,
+                                                   batch_count::rocblas_int,
+                                                   result::Ptr{Cfloat})::rocblas_status
+end
+
+function rocblas_ddot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                      batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ddot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{Cdouble}, incx::rocblas_int,
+                                                   stridex::rocblas_stride, y::Ptr{Cdouble},
+                                                   incy::rocblas_int,
+                                                   stridey::rocblas_stride,
+                                                   batch_count::rocblas_int,
+                                                   result::Ptr{Cdouble})::rocblas_status
+end
+
+function rocblas_hdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                      batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hdot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{rocblas_half}, incx::rocblas_int,
+                                                   stridex::rocblas_stride,
+                                                   y::Ptr{rocblas_half}, incy::rocblas_int,
+                                                   stridey::rocblas_stride,
+                                                   batch_count::rocblas_int,
+                                                   result::Ptr{rocblas_half})::rocblas_status
+end
+
+function rocblas_bfdot_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_bfdot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_bfloat16},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_bfloat16},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    result::Ptr{rocblas_bfloat16})::rocblas_status
+end
+
+function rocblas_cdotu_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cdotu_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    result::Ptr{rocblas_float_complex})::rocblas_status
+end
+
+function rocblas_zdotu_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zdotu_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    result::Ptr{rocblas_double_complex})::rocblas_status
+end
+
+function rocblas_cdotc_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cdotc_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    result::Ptr{rocblas_float_complex})::rocblas_status
+end
+
+function rocblas_zdotc_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count, result)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zdotc_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    result::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_sswap(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sswap, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_sswap(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_dswap(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dswap, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_dswap(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_cswap(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cswap, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_cswap(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_zswap(handle, n, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zswap, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, n, x, incx, y, incy)
+    @ccall librocblas.rocblas_zswap(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_sswap_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sswap_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_sswap_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_dswap_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dswap_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_dswap_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_cswap_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cswap_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_cswap_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zswap_batched(handle, n, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zswap_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, n, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_zswap_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_sswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sswap_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_sswap_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_dswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dswap_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_dswap_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_cswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cswap_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_cswap_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_zswap_strided_batched(handle, n, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zswap_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_zswap_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_saxpy(handle, n, alpha, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_saxpy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, n, alpha, x, incx, y, incy)
+    @ccall librocblas.rocblas_saxpy(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat}, incx::rocblas_int,
+                                    y::Ptr{Cfloat}, incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_daxpy(handle, n, alpha, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_daxpy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, n, alpha, x, incx, y, incy)
+    @ccall librocblas.rocblas_daxpy(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble}, incx::rocblas_int,
+                                    y::Ptr{Cdouble}, incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_haxpy(handle, n, alpha, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_haxpy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, Ptr{rocblas_half}, rocblas_int), handle, n, alpha, x, incx, y, incy)
+    @ccall librocblas.rocblas_haxpy(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{rocblas_half}, x::Ptr{rocblas_half},
+                                    incx::rocblas_int, y::Ptr{rocblas_half},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_caxpy(handle, n, alpha, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_caxpy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, n, alpha, x, incx, y, incy)
+    @ccall librocblas.rocblas_caxpy(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_zaxpy(handle, n, alpha, x, incx, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zaxpy, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, n, alpha, x, incx, y, incy)
+    @ccall librocblas.rocblas_zaxpy(handle::rocblas_handle, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_haxpy_batched(handle, n, alpha, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_haxpy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_half}, Ptr{Ptr{rocblas_half}}, rocblas_int, Ptr{Ptr{rocblas_half}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_haxpy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{rocblas_half},
+                                            x::Ptr{Ptr{rocblas_half}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_half}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_saxpy_batched(handle, n, alpha, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_saxpy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_saxpy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{Cfloat}, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int, y::Ptr{Ptr{Cfloat}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_daxpy_batched(handle, n, alpha, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_daxpy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_daxpy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{Cdouble}, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int, y::Ptr{Ptr{Cdouble}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_caxpy_batched(handle, n, alpha, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_caxpy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_caxpy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zaxpy_batched(handle, n, alpha, x, incx, y, incy, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zaxpy_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, n, alpha, x, incx, y, incy, batch_count)
+    @ccall librocblas.rocblas_zaxpy_batched(handle::rocblas_handle, n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_haxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_haxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_haxpy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_haxpy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_half},
+                                                    x::Ptr{rocblas_half}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_half}, incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_saxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_saxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_saxpy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_saxpy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_daxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_daxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_daxpy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_daxpy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_caxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_caxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_caxpy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_caxpy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zaxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+function rocblas_zaxpy_strided_batched(handle, n, alpha, x, incx, stridex, y, incy, stridey,
+                                       batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zaxpy_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, n, alpha, x, incx, stridex, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_zaxpy_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sasum(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sasum, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_sasum(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dasum(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dasum, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_dasum(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scasum(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scasum, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_scasum(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                     result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dzasum(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dzasum, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_dzasum(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                     result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_sasum_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sasum_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_sasum_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            batch_count::rocblas_int,
+                                            results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dasum_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dasum_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_dasum_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            batch_count::rocblas_int,
+                                            results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scasum_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scasum_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_scasum_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_float_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dzasum_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dzasum_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_dzasum_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_double_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_sasum_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sasum_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_sasum_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dasum_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dasum_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_dasum_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scasum_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scasum_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_scasum_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_float_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dzasum_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dzasum_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_dzasum_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_double_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_snrm2(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_snrm2, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_snrm2(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dnrm2(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dnrm2, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_dnrm2(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scnrm2(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scnrm2, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_scnrm2(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                     result::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dznrm2(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dznrm2, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_dznrm2(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                     result::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_snrm2_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_snrm2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_snrm2_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            batch_count::rocblas_int,
+                                            results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dnrm2_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dnrm2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_dnrm2_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            batch_count::rocblas_int,
+                                            results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scnrm2_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scnrm2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_scnrm2_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_float_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dznrm2_batched(handle, n, x, incx, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dznrm2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, batch_count, results)
+    @ccall librocblas.rocblas_dznrm2_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_double_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_snrm2_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_snrm2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_snrm2_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dnrm2_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dnrm2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_dnrm2_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    batch_count::rocblas_int,
+                                                    results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_scnrm2_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scnrm2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_scnrm2_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_float_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     results::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_dznrm2_strided_batched(handle, n, x, incx, stridex, batch_count, results)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dznrm2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, stridex, batch_count, results)
+    @ccall librocblas.rocblas_dznrm2_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_double_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     results::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_isamax(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamax, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_isamax(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                     incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamax(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamax, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_idamax(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{Cdouble}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamax(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamax, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_icamax(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamax(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamax, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_izamax(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_isamax_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamax_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_isamax_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                             batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamax_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamax_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_idamax_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                             batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamax_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamax_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_icamax_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_float_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamax_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamax_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_izamax_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_double_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_isamax_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamax_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_isamax_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cfloat}, incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamax_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamax_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_idamax_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cdouble}, incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamax_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamax_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_icamax_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_float_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamax_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamax_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_izamax_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_double_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_isamin(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamin, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_isamin(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                     incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamin(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamin, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_idamin(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{Cdouble}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamin(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamin, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_icamin(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamin(handle, n, x, incx, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamin, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, result)
+    @ccall librocblas.rocblas_izamin(handle::rocblas_handle, n::rocblas_int,
+                                     x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_isamin_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamin_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_isamin_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                             batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamin_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamin_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_idamin_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                             batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamin_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamin_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_icamin_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_float_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamin_batched(handle, n, x, incx, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamin_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, batch_count, result)
+    @ccall librocblas.rocblas_izamin_batched(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Ptr{rocblas_double_complex}},
+                                             incx::rocblas_int, batch_count::rocblas_int,
+                                             result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_isamin_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_isamin_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_isamin_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cfloat}, incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_idamin_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_idamin_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_idamin_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cdouble}, incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_icamin_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_icamin_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_icamin_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_float_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_izamin_strided_batched(handle, n, x, incx, stridex, batch_count, result)
     AMDGPU.prepare_state()
-    ccall((:rocblas_izamin_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int, Ptr{rocblas_int}), handle, n, x, incx, stridex, batch_count, result)
+    @ccall librocblas.rocblas_izamin_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{rocblas_double_complex},
+                                                     incx::rocblas_int,
+                                                     stridex::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{rocblas_int})::rocblas_status
 end
 
 function rocblas_srot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_srot(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                   incx::rocblas_int, y::Ptr{Cfloat}, incy::rocblas_int,
+                                   c::Ptr{Cfloat}, s::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_drot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_drot(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                   incx::rocblas_int, y::Ptr{Cdouble}, incy::rocblas_int,
+                                   c::Ptr{Cdouble}, s::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_crot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_crot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_crot(handle::rocblas_handle, n::rocblas_int,
+                                   x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                   y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                   c::Ptr{Cfloat},
+                                   s::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_csrot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_csrot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_csrot(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    c::Ptr{Cfloat}, s::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_zrot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zrot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_zrot(handle::rocblas_handle, n::rocblas_int,
+                                   x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                   y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                   c::Ptr{Cdouble},
+                                   s::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_zdrot(handle, n, x, incx, y, incy, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdrot, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}), handle, n, x, incx, y, incy, c, s)
+    @ccall librocblas.rocblas_zdrot(handle::rocblas_handle, n::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    c::Ptr{Cdouble}, s::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_srot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
+    @ccall librocblas.rocblas_srot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                           c::Ptr{Cfloat}, s::Ptr{Cfloat},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_drot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
+    @ccall librocblas.rocblas_drot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                           c::Ptr{Cdouble}, s::Ptr{Cdouble},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_crot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_crot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
+    @ccall librocblas.rocblas_crot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{rocblas_float_complex}},
+                                           incx::rocblas_int,
+                                           y::Ptr{Ptr{rocblas_float_complex}},
+                                           incy::rocblas_int, c::Ptr{Cfloat},
+                                           s::Ptr{rocblas_float_complex},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_csrot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_csrot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
+    @ccall librocblas.rocblas_csrot_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int, c::Ptr{Cfloat},
+                                            s::Ptr{Cfloat},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zrot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zrot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
+    @ccall librocblas.rocblas_zrot_batched(handle::rocblas_handle, n::rocblas_int,
+                                           x::Ptr{Ptr{rocblas_double_complex}},
+                                           incx::rocblas_int,
+                                           y::Ptr{Ptr{rocblas_double_complex}},
+                                           incy::rocblas_int, c::Ptr{Cdouble},
+                                           s::Ptr{rocblas_double_complex},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdrot_batched(handle, n, x, incx, y, incy, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdrot_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, y, incy, c, s, batch_count)
-end
-
-function rocblas_srot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_srot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-end
-
-function rocblas_drot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_drot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-end
-
-function rocblas_crot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_crot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-end
-
-function rocblas_csrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csrot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-end
-
-function rocblas_zrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zrot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-end
-
-function rocblas_zdrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zdrot_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, c, s, batch_count)
+    @ccall librocblas.rocblas_zdrot_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int, c::Ptr{Cdouble},
+                                            s::Ptr{Cdouble},
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_srot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s,
+                                      batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_srot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{Cfloat}, incx::rocblas_int,
+                                                   stride_x::rocblas_stride, y::Ptr{Cfloat},
+                                                   incy::rocblas_int,
+                                                   stride_y::rocblas_stride, c::Ptr{Cfloat},
+                                                   s::Ptr{Cfloat},
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_drot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s,
+                                      batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_drot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{Cdouble}, incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   y::Ptr{Cdouble}, incy::rocblas_int,
+                                                   stride_y::rocblas_stride,
+                                                   c::Ptr{Cdouble}, s::Ptr{Cdouble},
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_crot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s,
+                                      batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_crot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{rocblas_float_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   y::Ptr{rocblas_float_complex},
+                                                   incy::rocblas_int,
+                                                   stride_y::rocblas_stride, c::Ptr{Cfloat},
+                                                   s::Ptr{rocblas_float_complex},
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c,
+                                       s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csrot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    c::Ptr{Cfloat}, s::Ptr{Cfloat},
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c, s,
+                                      batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zrot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                   x::Ptr{rocblas_double_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   y::Ptr{rocblas_double_complex},
+                                                   incy::rocblas_int,
+                                                   stride_y::rocblas_stride,
+                                                   c::Ptr{Cdouble},
+                                                   s::Ptr{rocblas_double_complex},
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zdrot_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, c,
+                                       s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zdrot_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    c::Ptr{Cdouble}, s::Ptr{Cdouble},
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_srotg(handle, a, b, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotg, librocblas), rocblas_status, (rocblas_handle, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}), handle, a, b, c, s)
+    @ccall librocblas.rocblas_srotg(handle::rocblas_handle, a::Ptr{Cfloat}, b::Ptr{Cfloat},
+                                    c::Ptr{Cfloat}, s::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_drotg(handle, a, b, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotg, librocblas), rocblas_status, (rocblas_handle, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), handle, a, b, c, s)
+    @ccall librocblas.rocblas_drotg(handle::rocblas_handle, a::Ptr{Cdouble},
+                                    b::Ptr{Cdouble}, c::Ptr{Cdouble},
+                                    s::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_crotg(handle, a, b, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_crotg, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, Ptr{Cfloat}, Ptr{rocblas_float_complex}), handle, a, b, c, s)
+    @ccall librocblas.rocblas_crotg(handle::rocblas_handle, a::Ptr{rocblas_float_complex},
+                                    b::Ptr{rocblas_float_complex}, c::Ptr{Cfloat},
+                                    s::Ptr{rocblas_float_complex})::rocblas_status
 end
 
 function rocblas_zrotg(handle, a, b, c, s)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zrotg, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, Ptr{Cdouble}, Ptr{rocblas_double_complex}), handle, a, b, c, s)
+    @ccall librocblas.rocblas_zrotg(handle::rocblas_handle, a::Ptr{rocblas_double_complex},
+                                    b::Ptr{rocblas_double_complex}, c::Ptr{Cdouble},
+                                    s::Ptr{rocblas_double_complex})::rocblas_status
 end
 
 function rocblas_srotg_batched(handle, a, b, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, rocblas_int), handle, a, b, c, s, batch_count)
+    @ccall librocblas.rocblas_srotg_batched(handle::rocblas_handle, a::Ptr{Ptr{Cfloat}},
+                                            b::Ptr{Ptr{Cfloat}}, c::Ptr{Ptr{Cfloat}},
+                                            s::Ptr{Ptr{Cfloat}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_drotg_batched(handle, a, b, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, rocblas_int), handle, a, b, c, s, batch_count)
+    @ccall librocblas.rocblas_drotg_batched(handle::rocblas_handle, a::Ptr{Ptr{Cdouble}},
+                                            b::Ptr{Ptr{Cdouble}}, c::Ptr{Ptr{Cdouble}},
+                                            s::Ptr{Ptr{Cdouble}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_crotg_batched(handle, a, b, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_crotg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{rocblas_float_complex}}, Ptr{Ptr{rocblas_float_complex}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int), handle, a, b, c, s, batch_count)
+    @ccall librocblas.rocblas_crotg_batched(handle::rocblas_handle,
+                                            a::Ptr{Ptr{rocblas_float_complex}},
+                                            b::Ptr{Ptr{rocblas_float_complex}},
+                                            c::Ptr{Ptr{Cfloat}},
+                                            s::Ptr{Ptr{rocblas_float_complex}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zrotg_batched(handle, a, b, c, s, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zrotg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{rocblas_double_complex}}, Ptr{Ptr{rocblas_double_complex}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int), handle, a, b, c, s, batch_count)
-end
-
-function rocblas_srotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_srotg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, rocblas_int), handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-end
-
-function rocblas_drotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_drotg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, rocblas_int), handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-end
-
-function rocblas_crotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_crotg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_float_complex}, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_stride, rocblas_int), handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-end
-
-function rocblas_zrotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zrotg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{rocblas_double_complex}, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_stride, rocblas_int), handle, a, stride_a, b, stride_b, c, stride_c, s, stride_s, batch_count)
+    @ccall librocblas.rocblas_zrotg_batched(handle::rocblas_handle,
+                                            a::Ptr{Ptr{rocblas_double_complex}},
+                                            b::Ptr{Ptr{rocblas_double_complex}},
+                                            c::Ptr{Ptr{Cdouble}},
+                                            s::Ptr{Ptr{rocblas_double_complex}},
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_srotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s,
+                                       stride_s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_srotg_strided_batched(handle::rocblas_handle, a::Ptr{Cfloat},
+                                                    stride_a::rocblas_stride,
+                                                    b::Ptr{Cfloat},
+                                                    stride_b::rocblas_stride,
+                                                    c::Ptr{Cfloat},
+                                                    stride_c::rocblas_stride,
+                                                    s::Ptr{Cfloat},
+                                                    stride_s::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_drotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s,
+                                       stride_s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_drotg_strided_batched(handle::rocblas_handle, a::Ptr{Cdouble},
+                                                    stride_a::rocblas_stride,
+                                                    b::Ptr{Cdouble},
+                                                    stride_b::rocblas_stride,
+                                                    c::Ptr{Cdouble},
+                                                    stride_c::rocblas_stride,
+                                                    s::Ptr{Cdouble},
+                                                    stride_s::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_crotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s,
+                                       stride_s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_crotg_strided_batched(handle::rocblas_handle,
+                                                    a::Ptr{rocblas_float_complex},
+                                                    stride_a::rocblas_stride,
+                                                    b::Ptr{rocblas_float_complex},
+                                                    stride_b::rocblas_stride,
+                                                    c::Ptr{Cfloat},
+                                                    stride_c::rocblas_stride,
+                                                    s::Ptr{rocblas_float_complex},
+                                                    stride_s::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zrotg_strided_batched(handle, a, stride_a, b, stride_b, c, stride_c, s,
+                                       stride_s, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zrotg_strided_batched(handle::rocblas_handle,
+                                                    a::Ptr{rocblas_double_complex},
+                                                    stride_a::rocblas_stride,
+                                                    b::Ptr{rocblas_double_complex},
+                                                    stride_b::rocblas_stride,
+                                                    c::Ptr{Cdouble},
+                                                    stride_c::rocblas_stride,
+                                                    s::Ptr{rocblas_double_complex},
+                                                    stride_s::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_srotm(handle, n, x, incx, y, incy, param)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotm, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, n, x, incx, y, incy, param)
+    @ccall librocblas.rocblas_srotm(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, y::Ptr{Cfloat}, incy::rocblas_int,
+                                    param::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_drotm(handle, n, x, incx, y, incy, param)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotm, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, n, x, incx, y, incy, param)
+    @ccall librocblas.rocblas_drotm(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, y::Ptr{Cdouble}, incy::rocblas_int,
+                                    param::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_srotm_batched(handle, n, x, incx, y, incy, param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int), handle, n, x, incx, y, incy, param, batch_count)
+    @ccall librocblas.rocblas_srotm_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            param::Ptr{Ptr{Cfloat}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_drotm_batched(handle, n, x, incx, y, incy, param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int), handle, n, x, incx, y, incy, param, batch_count)
+    @ccall librocblas.rocblas_drotm_batched(handle::rocblas_handle, n::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            param::Ptr{Ptr{Cdouble}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_srotm_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count)
+function rocblas_srotm_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y,
+                                       param, stride_param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_stride, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count)
+    @ccall librocblas.rocblas_srotm_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{Cfloat}, incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    param::Ptr{Cfloat},
+                                                    stride_param::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_drotm_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count)
+function rocblas_drotm_strided_batched(handle, n, x, incx, stride_x, y, incy, stride_y,
+                                       param, stride_param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_stride, rocblas_int), handle, n, x, incx, stride_x, y, incy, stride_y, param, stride_param, batch_count)
+    @ccall librocblas.rocblas_drotm_strided_batched(handle::rocblas_handle, n::rocblas_int,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    param::Ptr{Cdouble},
+                                                    stride_param::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_srotmg(handle, d1, d2, x1, y1, param)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotmg, librocblas), rocblas_status, (rocblas_handle, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}), handle, d1, d2, x1, y1, param)
+    @ccall librocblas.rocblas_srotmg(handle::rocblas_handle, d1::Ptr{Cfloat},
+                                     d2::Ptr{Cfloat}, x1::Ptr{Cfloat}, y1::Ptr{Cfloat},
+                                     param::Ptr{Cfloat})::rocblas_status
 end
 
 function rocblas_drotmg(handle, d1, d2, x1, y1, param)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotmg, librocblas), rocblas_status, (rocblas_handle, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}), handle, d1, d2, x1, y1, param)
+    @ccall librocblas.rocblas_drotmg(handle::rocblas_handle, d1::Ptr{Cdouble},
+                                     d2::Ptr{Cdouble}, x1::Ptr{Cdouble}, y1::Ptr{Cdouble},
+                                     param::Ptr{Cdouble})::rocblas_status
 end
 
 function rocblas_srotmg_batched(handle, d1, d2, x1, y1, param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_srotmg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, rocblas_int), handle, d1, d2, x1, y1, param, batch_count)
+    @ccall librocblas.rocblas_srotmg_batched(handle::rocblas_handle, d1::Ptr{Ptr{Cfloat}},
+                                             d2::Ptr{Ptr{Cfloat}}, x1::Ptr{Ptr{Cfloat}},
+                                             y1::Ptr{Ptr{Cfloat}}, param::Ptr{Ptr{Cfloat}},
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_drotmg_batched(handle, d1, d2, x1, y1, param, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_drotmg_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, rocblas_int), handle, d1, d2, x1, y1, param, batch_count)
-end
-
-function rocblas_srotmg_strided_batched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, param, stride_param, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_srotmg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_stride, rocblas_int), handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, param, stride_param, batch_count)
-end
-
-function rocblas_drotmg_strided_batched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, param, stride_param, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_drotmg_strided_batched, librocblas), rocblas_status, (rocblas_handle, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_stride, rocblas_int), handle, d1, stride_d1, d2, stride_d2, x1, stride_x1, y1, stride_y1, param, stride_param, batch_count)
+    @ccall librocblas.rocblas_drotmg_batched(handle::rocblas_handle, d1::Ptr{Ptr{Cdouble}},
+                                             d2::Ptr{Ptr{Cdouble}}, x1::Ptr{Ptr{Cdouble}},
+                                             y1::Ptr{Ptr{Cdouble}},
+                                             param::Ptr{Ptr{Cdouble}},
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_srotmg_strided_batched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1,
+                                        y1, stride_y1, param, stride_param, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_srotmg_strided_batched(handle::rocblas_handle,
+                                                     d1::Ptr{Cfloat},
+                                                     stride_d1::rocblas_stride,
+                                                     d2::Ptr{Cfloat},
+                                                     stride_d2::rocblas_stride,
+                                                     x1::Ptr{Cfloat},
+                                                     stride_x1::rocblas_stride,
+                                                     y1::Ptr{Cfloat},
+                                                     stride_y1::rocblas_stride,
+                                                     param::Ptr{Cfloat},
+                                                     stride_param::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_drotmg_strided_batched(handle, d1, stride_d1, d2, stride_d2, x1, stride_x1,
+                                        y1, stride_y1, param, stride_param, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_drotmg_strided_batched(handle::rocblas_handle,
+                                                     d1::Ptr{Cdouble},
+                                                     stride_d1::rocblas_stride,
+                                                     d2::Ptr{Cdouble},
+                                                     stride_d2::rocblas_stride,
+                                                     x1::Ptr{Cdouble},
+                                                     stride_x1::rocblas_stride,
+                                                     y1::Ptr{Cdouble},
+                                                     stride_y1::rocblas_stride,
+                                                     param::Ptr{Cdouble},
+                                                     stride_param::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_sgbmv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, kl::rocblas_int,
+                                    ku::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                    lda::rocblas_int, x::Ptr{Cfloat}, incx::rocblas_int,
+                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_dgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_dgbmv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, kl::rocblas_int,
+                                    ku::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                    lda::rocblas_int, x::Ptr{Cdouble}, incx::rocblas_int,
+                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_cgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_cgbmv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, kl::rocblas_int,
+                                    ku::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
 function rocblas_zgbmv(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_zgbmv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, kl::rocblas_int,
+                                    ku::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
+                               incy, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgbmv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, kl::rocblas_int,
+                                            ku::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            beta::Ptr{Cfloat}, y::Ptr{Ptr{Cfloat}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
+                               incy, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgbmv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, kl::rocblas_int,
+                                            ku::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            beta::Ptr{Cdouble}, y::Ptr{Ptr{Cdouble}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
+                               incy, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgbmv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, kl::rocblas_int,
+                                            ku::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y,
+                               incy, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgbmv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, kl::rocblas_int,
+                                            ku::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A,
+                                       x, incx, stride_x, beta, y, incy, stride_y,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgbmv_strided_batched(handle::rocblas_handle,
+                                                    trans::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    kl::rocblas_int, ku::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A,
+                                       x, incx, stride_x, beta, y, incy, stride_y,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgbmv_strided_batched(handle::rocblas_handle,
+                                                    trans::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    kl::rocblas_int, ku::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A,
+                                       x, incx, stride_x, beta, y, incy, stride_y,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgbmv_strided_batched(handle::rocblas_handle,
+                                                    trans::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    kl::rocblas_int, ku::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A,
+                                       x, incx, stride_x, beta, y, incy, stride_y,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgbmv_strided_batched(handle::rocblas_handle,
+                                                    trans::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    kl::rocblas_int, ku::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_sgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_sgemv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, alpha::Ptr{Cfloat},
+                                    A::Ptr{Cfloat}, lda::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_dgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_dgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_dgemv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int, alpha::Ptr{Cdouble},
+                                    A::Ptr{Cdouble}, lda::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_cgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_cgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_cgemv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_zgbmv_batched(handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_zgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_zgemv(handle::rocblas_handle, trans::rocblas_operation,
+                                    m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            beta::Ptr{Cfloat}, y::Ptr{Ptr{Cfloat}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            beta::Ptr{Cdouble}, y::Ptr{Ptr{Cdouble}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemv_batched(handle::rocblas_handle,
+                                            trans::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hshgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                                 batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hshgemv_batched(handle::rocblas_handle,
+                                              trans::rocblas_operation, m::rocblas_int,
+                                              n::rocblas_int, alpha::Ptr{Cfloat},
+                                              A::Ptr{Ptr{rocblas_half}}, lda::rocblas_int,
+                                              x::Ptr{Ptr{rocblas_half}}, incx::rocblas_int,
+                                              beta::Ptr{Cfloat}, y::Ptr{Ptr{rocblas_half}},
+                                              incy::rocblas_int,
+                                              batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hssgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                                 batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hssgemv_batched(handle::rocblas_handle,
+                                              trans::rocblas_operation, m::rocblas_int,
+                                              n::rocblas_int, alpha::Ptr{Cfloat},
+                                              A::Ptr{Ptr{rocblas_half}}, lda::rocblas_int,
+                                              x::Ptr{Ptr{rocblas_half}}, incx::rocblas_int,
+                                              beta::Ptr{Cfloat}, y::Ptr{Ptr{Cfloat}},
+                                              incy::rocblas_int,
+                                              batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_tstgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                                 batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_tstgemv_batched(handle::rocblas_handle,
+                                              trans::rocblas_operation, m::rocblas_int,
+                                              n::rocblas_int, alpha::Ptr{Cfloat},
+                                              A::Ptr{Ptr{rocblas_bfloat16}},
+                                              lda::rocblas_int,
+                                              x::Ptr{Ptr{rocblas_bfloat16}},
+                                              incx::rocblas_int, beta::Ptr{Cfloat},
+                                              y::Ptr{Ptr{rocblas_bfloat16}},
+                                              incy::rocblas_int,
+                                              batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_tssgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy,
+                                 batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_tssgemv_batched(handle::rocblas_handle,
+                                              trans::rocblas_operation, m::rocblas_int,
+                                              n::rocblas_int, alpha::Ptr{Cfloat},
+                                              A::Ptr{Ptr{rocblas_bfloat16}},
+                                              lda::rocblas_int,
+                                              x::Ptr{Ptr{rocblas_bfloat16}},
+                                              incx::rocblas_int, beta::Ptr{Cfloat},
+                                              y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                              batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                       incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemv_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                       incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemv_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                       incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemv_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                       incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemv_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hshgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                         incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hshgemv_strided_batched(handle::rocblas_handle,
+                                                      transA::rocblas_operation,
+                                                      m::rocblas_int, n::rocblas_int,
+                                                      alpha::Ptr{Cfloat},
+                                                      A::Ptr{rocblas_half},
+                                                      lda::rocblas_int,
+                                                      strideA::rocblas_stride,
+                                                      x::Ptr{rocblas_half},
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      beta::Ptr{Cfloat},
+                                                      y::Ptr{rocblas_half},
+                                                      incy::rocblas_int,
+                                                      stridey::rocblas_stride,
+                                                      batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hssgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                         incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hssgemv_strided_batched(handle::rocblas_handle,
+                                                      transA::rocblas_operation,
+                                                      m::rocblas_int, n::rocblas_int,
+                                                      alpha::Ptr{Cfloat},
+                                                      A::Ptr{rocblas_half},
+                                                      lda::rocblas_int,
+                                                      strideA::rocblas_stride,
+                                                      x::Ptr{rocblas_half},
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                      incy::rocblas_int,
+                                                      stridey::rocblas_stride,
+                                                      batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_tstgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                         incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_tstgemv_strided_batched(handle::rocblas_handle,
+                                                      transA::rocblas_operation,
+                                                      m::rocblas_int, n::rocblas_int,
+                                                      alpha::Ptr{Cfloat},
+                                                      A::Ptr{rocblas_bfloat16},
+                                                      lda::rocblas_int,
+                                                      strideA::rocblas_stride,
+                                                      x::Ptr{rocblas_bfloat16},
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      beta::Ptr{Cfloat},
+                                                      y::Ptr{rocblas_bfloat16},
+                                                      incy::rocblas_int,
+                                                      stridey::rocblas_stride,
+                                                      batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_tssgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x,
+                                         incx, stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_tssgemv_strided_batched(handle::rocblas_handle,
+                                                      transA::rocblas_operation,
+                                                      m::rocblas_int, n::rocblas_int,
+                                                      alpha::Ptr{Cfloat},
+                                                      A::Ptr{rocblas_bfloat16},
+                                                      lda::rocblas_int,
+                                                      strideA::rocblas_stride,
+                                                      x::Ptr{rocblas_bfloat16},
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                      incy::rocblas_int,
+                                                      stridey::rocblas_stride,
+                                                      batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_chbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_chbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, k::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_dgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_zhbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_zhbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, k::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_chbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_chbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_chemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_chemv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_zgbmv_strided_batched(handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_zhemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, trans, m, n, kl, ku, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_zhemv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_chemv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chemv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhemv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhemv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_chemv_strided_batched(handle, uplo, n, alpha, A, lda, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chemv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhemv_strided_batched(handle, uplo, n, alpha, A, lda, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhemv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_cher(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgemv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_cher(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cfloat},
+                                   x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                   A::Ptr{rocblas_float_complex},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_zher(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgemv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_zher(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cdouble},
+                                   x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                   A::Ptr{rocblas_double_complex},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_cgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_cher_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgemv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_cher_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cfloat},
+                                           x::Ptr{Ptr{rocblas_float_complex}},
+                                           incx::rocblas_int,
+                                           A::Ptr{Ptr{rocblas_float_complex}},
+                                           lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zgemv(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_zher_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgemv, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_zher_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cdouble},
+                                           x::Ptr{Ptr{rocblas_double_complex}},
+                                           incx::rocblas_int,
+                                           A::Ptr{Ptr{rocblas_double_complex}},
+                                           lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cher_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, A, lda,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cher_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cfloat},
+                                                   x::Ptr{rocblas_float_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   A::Ptr{rocblas_float_complex},
+                                                   lda::rocblas_int,
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zher_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, A, lda,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zher_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cdouble},
+                                                   x::Ptr{rocblas_double_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   A::Ptr{rocblas_double_complex},
+                                                   lda::rocblas_int,
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_cher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_cher2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_zher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_zher2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int)::rocblas_status
+end
+
+function rocblas_cher2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cher2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zher2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zher2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cher2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, A, lda, stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cher2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zher2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, A, lda, stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zher2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_chpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_chpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    AP::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_zgemv_batched(handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_zhpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, trans, m, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_zhpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    AP::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_chpmv_batched(handle, uplo, n, alpha, AP, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            AP::Ptr{Ptr{rocblas_float_complex}},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhpmv_batched(handle, uplo, n, alpha, AP, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            AP::Ptr{Ptr{rocblas_double_complex}},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_chpmv_strided_batched(handle, uplo, n, alpha, AP, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    AP::Ptr{rocblas_float_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhpmv_strided_batched(handle, uplo, n, alpha, AP, stride_A, x, incx,
+                                       stride_x, beta, y, incy, stride_y, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    AP::Ptr{rocblas_double_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_sgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+function rocblas_chpr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_chpr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cfloat},
+                                   x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                   AP::Ptr{rocblas_float_complex})::rocblas_status
 end
 
-function rocblas_dgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+function rocblas_zhpr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_zhpr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cdouble},
+                                   x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                   AP::Ptr{rocblas_double_complex})::rocblas_status
 end
 
-function rocblas_cgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+function rocblas_chpr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_chpr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cfloat},
+                                           x::Ptr{Ptr{rocblas_float_complex}},
+                                           incx::rocblas_int,
+                                           AP::Ptr{Ptr{rocblas_float_complex}},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zgemv_strided_batched(handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+function rocblas_zhpr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, m, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
+    @ccall librocblas.rocblas_zhpr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cdouble},
+                                           x::Ptr{Ptr{rocblas_double_complex}},
+                                           incx::rocblas_int,
+                                           AP::Ptr{Ptr{rocblas_double_complex}},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_chpr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_chpr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cfloat},
+                                                   x::Ptr{rocblas_float_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{rocblas_float_complex},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_zhpr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_zhpr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cdouble},
+                                                   x::Ptr{rocblas_double_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{rocblas_double_complex},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_chpr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_chpr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    AP::Ptr{rocblas_float_complex})::rocblas_status
 end
 
-function rocblas_zhbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_zhpr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_zhpr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    AP::Ptr{rocblas_double_complex})::rocblas_status
 end
 
-function rocblas_chbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_chpr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, k, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_chpr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            AP::Ptr{Ptr{rocblas_float_complex}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_zhpr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, k, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_zhpr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            AP::Ptr{Ptr{rocblas_double_complex}},
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_chpr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, AP, stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chpr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    AP::Ptr{rocblas_float_complex},
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhpr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, AP, stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhpr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    AP::Ptr{rocblas_double_complex},
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_strmv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chemv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_strmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cfloat}, lda::rocblas_int,
+                                    x::Ptr{Cfloat}, incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhemv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
+function rocblas_dtrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhemv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_dtrmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cdouble}, lda::rocblas_int,
+                                    x::Ptr{Cdouble}, incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chemv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_ctrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_ctrmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int, x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhemv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+function rocblas_ztrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhemv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_ztrmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int, x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chemv_strided_batched(handle, uplo, n, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_strmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_strmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhemv_strided_batched(handle, uplo, n, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_dtrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhemv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_dtrmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher(handle, uplo, n, alpha, x, incx, A, lda)
+function rocblas_ctrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
+    @ccall librocblas.rocblas_ctrmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher(handle, uplo, n, alpha, x, incx, A, lda)
+function rocblas_ztrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
+    @ccall librocblas.rocblas_ztrmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
+function rocblas_stpmv(handle, uplo, transA, diag, m, A, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
+    @ccall librocblas.rocblas_stpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
+function rocblas_dtpmv(handle, uplo, transA, diag, m, A, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
+    @ccall librocblas.rocblas_dtpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, A, lda, stride_A, batch_count)
+function rocblas_ctpmv(handle, uplo, transA, diag, m, A, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, A, lda, stride_A, batch_count)
+    @ccall librocblas.rocblas_ctpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, A, lda, stride_A, batch_count)
+function rocblas_ztpmv(handle, uplo, transA, diag, m, A, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, A, lda, stride_A, batch_count)
+    @ccall librocblas.rocblas_ztpmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
+function rocblas_stpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
+    @ccall librocblas.rocblas_stpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cfloat}}, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
+function rocblas_dtpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
+    @ccall librocblas.rocblas_dtpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cdouble}}, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
+function rocblas_ctpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
+    @ccall librocblas.rocblas_ctpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
+function rocblas_ztpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
+    @ccall librocblas.rocblas_ztpmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_stpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cfloat},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cdouble},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztpmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_cher2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count)
+function rocblas_stbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cher2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count)
+    @ccall librocblas.rocblas_stbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    trans::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, k::rocblas_int, A::Ptr{Cfloat},
+                                    lda::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zher2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count)
+function rocblas_dtbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zher2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, A, lda, stride_A, batch_count)
+    @ccall librocblas.rocblas_dtbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    trans::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, k::rocblas_int, A::Ptr{Cdouble},
+                                    lda::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
+function rocblas_ctbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_ctbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    trans::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, k::rocblas_int,
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpmv(handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
+function rocblas_ztbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, AP, x, incx, beta, y, incy)
+    @ccall librocblas.rocblas_ztbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    trans::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, k::rocblas_int,
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
+end
+
+function rocblas_stbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            trans::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            k::rocblas_int, A::Ptr{Ptr{Cfloat}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            trans::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            k::rocblas_int, A::Ptr{Ptr{Cdouble}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            trans::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            k::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            trans::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            k::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_stbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    trans::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    k::rocblas_int, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    trans::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    k::rocblas_int, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    trans::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    k::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    trans::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    k::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpmv_batched(handle, uplo, n, alpha, AP, x, incx, beta, y, incy, batch_count)
+function rocblas_stbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, AP, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_stbsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, k::rocblas_int, A::Ptr{Cfloat},
+                                    lda::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpmv_batched(handle, uplo, n, alpha, AP, x, incx, beta, y, incy, batch_count)
+function rocblas_dtbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, AP, x, incx, beta, y, incy, batch_count)
+    @ccall librocblas.rocblas_dtbsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, k::rocblas_int, A::Ptr{Cdouble},
+                                    lda::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpmv_strided_batched(handle, uplo, n, alpha, AP, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_ctbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, AP, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_ctbsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, k::rocblas_int,
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpmv_strided_batched(handle, uplo, n, alpha, AP, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+function rocblas_ztbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, AP, stride_A, x, incx, stride_x, beta, y, incy, stride_y, batch_count)
+    @ccall librocblas.rocblas_ztbsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, k::rocblas_int,
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
+end
+
+function rocblas_stbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stbsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            k::rocblas_int, A::Ptr{Ptr{Cfloat}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtbsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            k::rocblas_int, A::Ptr{Ptr{Cdouble}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctbsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            k::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztbsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            k::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_stbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A,
+                                       x, incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stbsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    k::rocblas_int, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A,
+                                       x, incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtbsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    k::rocblas_int, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A,
+                                       x, incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctbsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A,
+                                       x, incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztbsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr(handle, uplo, n, alpha, x, incx, AP)
+function rocblas_strsv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}), handle, uplo, n, alpha, x, incx, AP)
+    @ccall librocblas.rocblas_strsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cfloat}, lda::rocblas_int,
+                                    x::Ptr{Cfloat}, incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr(handle, uplo, n, alpha, x, incx, AP)
+function rocblas_dtrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}), handle, uplo, n, alpha, x, incx, AP)
+    @ccall librocblas.rocblas_dtrsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{Cdouble}, lda::rocblas_int,
+                                    x::Ptr{Cdouble}, incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
+function rocblas_ctrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
+    @ccall librocblas.rocblas_ctrsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int, x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
+function rocblas_ztrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
+    @ccall librocblas.rocblas_ztrsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    m::rocblas_int, A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int, x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
+function rocblas_strsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
+    @ccall librocblas.rocblas_strsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
+function rocblas_dtrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
+    @ccall librocblas.rocblas_dtrsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
+function rocblas_ctrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}), handle, uplo, n, alpha, x, incx, y, incy, AP)
+    @ccall librocblas.rocblas_ctrsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
+function rocblas_ztrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}), handle, uplo, n, alpha, x, incx, y, incy, AP)
+    @ccall librocblas.rocblas_ztrsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x,
+                                       incx, stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
+function rocblas_stpsv(handle, uplo, transA, diag, n, AP, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
+    @ccall librocblas.rocblas_stpsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, AP::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
+function rocblas_dtpsv(handle, uplo, transA, diag, n, AP, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
+    @ccall librocblas.rocblas_dtpsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, AP::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_chpr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
+function rocblas_ctpsv(handle, uplo, transA, diag, n, AP, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_chpr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
+    @ccall librocblas.rocblas_ctpsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, AP::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_zhpr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
+function rocblas_ztpsv(handle, uplo, transA, diag, n, AP, x, incx)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zhpr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
+    @ccall librocblas.rocblas_ztpsv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, diag::rocblas_diagonal,
+                                    n::rocblas_int, AP::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex},
+                                    incx::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_stpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_stpsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            AP::Ptr{Ptr{Cfloat}}, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_dtpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_dtpsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            AP::Ptr{Ptr{Cdouble}}, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_ctpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_ctpsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            AP::Ptr{Ptr{rocblas_float_complex}},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_ztpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_ztpsv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation,
+                                            diag::rocblas_diagonal, n::rocblas_int,
+                                            AP::Ptr{Ptr{rocblas_double_complex}},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_stpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_stpsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    AP::Ptr{Cfloat},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtpsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    AP::Ptr{Cdouble},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctpsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    AP::Ptr{rocblas_float_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx,
+                                       stride_x, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztpsv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, n::rocblas_int,
+                                                    AP::Ptr{rocblas_double_complex},
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_ssymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_ssymv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                    lda::rocblas_int, x::Ptr{Cfloat}, incx::rocblas_int,
+                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_dsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_dsymv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                    lda::rocblas_int, x::Ptr{Cdouble}, incx::rocblas_int,
+                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_csymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_csymv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    y::Ptr{rocblas_float_complex},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_zsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_zsymv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    y::Ptr{rocblas_double_complex},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssymv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            beta::Ptr{Cfloat}, y::Ptr{Ptr{Cfloat}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsymv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            beta::Ptr{Cdouble}, y::Ptr{Ptr{Cdouble}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csymv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsymv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssymv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsymv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csymv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsymv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_sspmv(handle, uplo, n, alpha, A, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_sspmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                    x::Ptr{Cfloat}, incx::rocblas_int, beta::Ptr{Cfloat},
+                                    y::Ptr{Cfloat}, incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_dspmv(handle, uplo, n, alpha, A, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dspmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                    x::Ptr{Cdouble}, incx::rocblas_int, beta::Ptr{Cdouble},
+                                    y::Ptr{Cdouble}, incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_sspmv_batched(handle, uplo, n, alpha, A, x, incx, beta, y, incy,
+                               batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_sspmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int, beta::Ptr{Cfloat},
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_dspmv_batched(handle, uplo, n, alpha, A, x, incx, beta, y, incy,
+                               batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dspmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int, beta::Ptr{Cdouble},
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stpmv(handle, uplo, transA, diag, m, A, x, incx)
+function rocblas_sspmv_strided_batched(handle, uplo, n, alpha, A, strideA, x, incx, stridex,
+                                       beta, y, incy, stridey, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, diag, m, A, x, incx)
+    @ccall librocblas.rocblas_sspmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    strideA::rocblas_stride, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtpmv(handle, uplo, transA, diag, m, A, x, incx)
+function rocblas_dspmv_strided_batched(handle, uplo, n, alpha, A, strideA, x, incx, stridex,
+                                       beta, y, incy, stridey, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, diag, m, A, x, incx)
+    @ccall librocblas.rocblas_dspmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctpmv(handle, uplo, transA, diag, m, A, x, incx)
+function rocblas_ssbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, diag, m, A, x, incx)
+    @ccall librocblas.rocblas_ssbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, k::rocblas_int, alpha::Ptr{Cfloat},
+                                    A::Ptr{Cfloat}, lda::rocblas_int, x::Ptr{Cfloat},
+                                    incx::rocblas_int, beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                    incy::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztpmv(handle, uplo, transA, diag, m, A, x, incx)
+function rocblas_dsbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztpmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, diag, m, A, x, incx)
+    @ccall librocblas.rocblas_dsbmv(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, k::rocblas_int, alpha::Ptr{Cdouble},
+                                    A::Ptr{Cdouble}, lda::rocblas_int, x::Ptr{Cdouble},
+                                    incx::rocblas_int, beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                    incy::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{Cdouble}, A::Ptr{Ptr{Cdouble}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cdouble}},
+                                            incx::rocblas_int, beta::Ptr{Cdouble},
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssbmv_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{Cfloat}, A::Ptr{Ptr{Cfloat}},
+                                            lda::rocblas_int, x::Ptr{Ptr{Cfloat}},
+                                            incx::rocblas_int, beta::Ptr{Cfloat},
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    k::rocblas_int, alpha::Ptr{Cfloat},
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    strideA::rocblas_stride, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, strideA, x, incx,
+                                       stridex, beta, y, incy, stridey, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsbmv_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    k::rocblas_int, alpha::Ptr{Cdouble},
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, y::Ptr{Cdouble},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
+function rocblas_sger(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, x, incx, batch_count)
+    @ccall librocblas.rocblas_sger(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                   alpha::Ptr{Cfloat}, x::Ptr{Cfloat}, incx::rocblas_int,
+                                   y::Ptr{Cfloat}, incy::rocblas_int, A::Ptr{Cfloat},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
+function rocblas_dger(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, x, incx, batch_count)
+    @ccall librocblas.rocblas_dger(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                   alpha::Ptr{Cdouble}, x::Ptr{Cdouble}, incx::rocblas_int,
+                                   y::Ptr{Cdouble}, incy::rocblas_int, A::Ptr{Cdouble},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
+function rocblas_cgeru(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, x, incx, batch_count)
+    @ccall librocblas.rocblas_cgeru(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztpmv_batched(handle, uplo, transA, diag, m, A, x, incx, batch_count)
+function rocblas_zgeru(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztpmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, x, incx, batch_count)
+    @ccall librocblas.rocblas_zgeru(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_stpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+function rocblas_cgerc(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_cgerc(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+function rocblas_zgerc(handle, m, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zgerc(handle::rocblas_handle, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+function rocblas_sger_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_sger_batched(handle::rocblas_handle, m::rocblas_int,
+                                           n::rocblas_int, alpha::Ptr{Cfloat},
+                                           x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                           A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztpmv_strided_batched(handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+function rocblas_dger_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztpmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dger_batched(handle::rocblas_handle, m::rocblas_int,
+                                           n::rocblas_int, alpha::Ptr{Cdouble},
+                                           x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                           y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                           A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
+function rocblas_cgeru_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_cgeru_batched(handle::rocblas_handle, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
+function rocblas_zgeru_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_zgeru_batched(handle::rocblas_handle, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
+function rocblas_cgerc_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_cgerc_batched(handle::rocblas_handle, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztbmv(handle, uplo, trans, diag, m, k, A, lda, x, incx)
+function rocblas_zgerc_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_zgerc_batched(handle::rocblas_handle, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sger_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                      stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sger_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                   n::rocblas_int, alpha::Ptr{Cfloat},
+                                                   x::Ptr{Cfloat}, incx::rocblas_int,
+                                                   stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                   incy::rocblas_int,
+                                                   stridey::rocblas_stride, A::Ptr{Cfloat},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dger_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                      stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dger_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                   n::rocblas_int, alpha::Ptr{Cdouble},
+                                                   x::Ptr{Cdouble}, incx::rocblas_int,
+                                                   stridex::rocblas_stride, y::Ptr{Cdouble},
+                                                   incy::rocblas_int,
+                                                   stridey::rocblas_stride, A::Ptr{Cdouble},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgeru_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgeru_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgeru_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgeru_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgerc_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgerc_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgerc_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgerc_strided_batched(handle::rocblas_handle, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+function rocblas_sspr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_sspr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                   incx::rocblas_int, AP::Ptr{Cfloat})::rocblas_status
 end
 
-function rocblas_dtbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+function rocblas_dspr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_dspr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                   incx::rocblas_int, AP::Ptr{Cdouble})::rocblas_status
 end
 
-function rocblas_ctbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+function rocblas_cspr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_cspr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                   x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                   AP::Ptr{rocblas_float_complex})::rocblas_status
 end
 
-function rocblas_ztbmv_batched(handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+function rocblas_zspr(handle, uplo, n, alpha, x, incx, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_zspr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                   x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                   AP::Ptr{rocblas_double_complex})::rocblas_status
 end
 
-function rocblas_stbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_sspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_sspr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cfloat},
+                                           x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                           AP::Ptr{Ptr{Cfloat}},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_dspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dspr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cdouble},
+                                           x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                           AP::Ptr{Ptr{Cdouble}},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_cspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_cspr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int,
+                                           alpha::Ptr{rocblas_float_complex},
+                                           x::Ptr{Ptr{rocblas_float_complex}},
+                                           incx::rocblas_int,
+                                           AP::Ptr{Ptr{rocblas_float_complex}},
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztbmv_strided_batched(handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_zspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, diag, m, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zspr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int,
+                                           alpha::Ptr{rocblas_double_complex},
+                                           x::Ptr{Ptr{rocblas_double_complex}},
+                                           incx::rocblas_int,
+                                           AP::Ptr{Ptr{rocblas_double_complex}},
+                                           batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sspr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{Cfloat},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dspr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{Cdouble},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cspr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{rocblas_float_complex},
+                                                   x::Ptr{rocblas_float_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{rocblas_float_complex},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP,
+                                      stride_A, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zspr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{rocblas_double_complex},
+                                                   x::Ptr{rocblas_double_complex},
+                                                   incx::rocblas_int,
+                                                   stride_x::rocblas_stride,
+                                                   AP::Ptr{rocblas_double_complex},
+                                                   stride_A::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
+function rocblas_sspr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_sspr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                    incx::rocblas_int, y::Ptr{Cfloat}, incy::rocblas_int,
+                                    AP::Ptr{Cfloat})::rocblas_status
 end
 
-function rocblas_dtbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
+function rocblas_dspr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_dspr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                    incx::rocblas_int, y::Ptr{Cdouble}, incy::rocblas_int,
+                                    AP::Ptr{Cdouble})::rocblas_status
 end
 
-function rocblas_ctbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
+function rocblas_sspr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_sspr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            AP::Ptr{Ptr{Cfloat}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztbsv(handle, uplo, transA, diag, n, k, A, lda, x, incx)
+function rocblas_dspr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx)
+    @ccall librocblas.rocblas_dspr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            AP::Ptr{Ptr{Cdouble}},
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+function rocblas_sspr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, AP, stride_A, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_sspr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{Cfloat}, incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    AP::Ptr{Cfloat},
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+function rocblas_dspr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy,
+                                       stride_y, AP, stride_A, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_dspr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stride_y::rocblas_stride,
+                                                    AP::Ptr{Cdouble},
+                                                    stride_A::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+function rocblas_ssyr(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_ssyr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                   incx::rocblas_int, A::Ptr{Cfloat},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztbsv_batched(handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+function rocblas_dsyr(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_dsyr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                   incx::rocblas_int, A::Ptr{Cdouble},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_stbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_csyr(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stbsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_csyr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                   x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                   A::Ptr{rocblas_float_complex},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_zsyr(handle, uplo, n, alpha, x, incx, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtbsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zsyr(handle::rocblas_handle, uplo::rocblas_fill,
+                                   n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                   x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                   A::Ptr{rocblas_double_complex},
+                                   lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_ssyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctbsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_ssyr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cfloat},
+                                           x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                           A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztbsv_strided_batched(handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_dsyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztbsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, k, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_dsyr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int, alpha::Ptr{Cdouble},
+                                           x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                           A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strsv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_csyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_csyr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int,
+                                           alpha::Ptr{rocblas_float_complex},
+                                           x::Ptr{Ptr{rocblas_float_complex}},
+                                           incx::rocblas_int,
+                                           A::Ptr{Ptr{rocblas_float_complex}},
+                                           lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_zsyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_zsyr_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                           n::rocblas_int,
+                                           alpha::Ptr{rocblas_double_complex},
+                                           x::Ptr{Ptr{rocblas_double_complex}},
+                                           incx::rocblas_int,
+                                           A::Ptr{Ptr{rocblas_double_complex}},
+                                           lda::rocblas_int,
+                                           batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda,
+                                      strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                   incx::rocblas_int,
+                                                   stridex::rocblas_stride, A::Ptr{Cfloat},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda,
+                                      strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                   incx::rocblas_int,
+                                                   stridex::rocblas_stride, A::Ptr{Cdouble},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda,
+                                      strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{rocblas_float_complex},
+                                                   x::Ptr{rocblas_float_complex},
+                                                   incx::rocblas_int,
+                                                   stridex::rocblas_stride,
+                                                   A::Ptr{rocblas_float_complex},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda,
+                                      strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyr_strided_batched(handle::rocblas_handle,
+                                                   uplo::rocblas_fill, n::rocblas_int,
+                                                   alpha::Ptr{rocblas_double_complex},
+                                                   x::Ptr{rocblas_double_complex},
+                                                   incx::rocblas_int,
+                                                   stridex::rocblas_stride,
+                                                   A::Ptr{rocblas_double_complex},
+                                                   lda::rocblas_int,
+                                                   strideA::rocblas_stride,
+                                                   batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_ssyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_ssyr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                    incx::rocblas_int, y::Ptr{Cfloat}, incy::rocblas_int,
+                                    A::Ptr{Cfloat}, lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrsv(handle, uplo, transA, diag, m, A, lda, x, incx)
+function rocblas_dsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx)
+    @ccall librocblas.rocblas_dsyr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                    incx::rocblas_int, y::Ptr{Cdouble}, incy::rocblas_int,
+                                    A::Ptr{Cdouble}, lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_strsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_csyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_csyr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_float_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_float_complex},
+                                    lda::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_zsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_zsyr2(handle::rocblas_handle, uplo::rocblas_fill,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    y::Ptr{rocblas_double_complex}, incy::rocblas_int,
+                                    A::Ptr{rocblas_double_complex},
+                                    lda::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cfloat}}, incy::rocblas_int,
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            y::Ptr{Ptr{Cdouble}}, incy::rocblas_int,
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_float_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyr2_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            y::Ptr{Ptr{rocblas_double_complex}},
+                                            incy::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, x::Ptr{Cfloat},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride, y::Ptr{Cfloat},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, x::Ptr{Cdouble},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{Cdouble}, incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_float_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy,
+                                       stridey, A, lda, strideA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyr2_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stridex::rocblas_stride,
+                                                    y::Ptr{rocblas_double_complex},
+                                                    incy::rocblas_int,
+                                                    stridey::rocblas_stride,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    strideA::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_chemm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_chemm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrsv_batched(handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+function rocblas_zhemm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, m, A, lda, x, incx, batch_count)
+    @ccall librocblas.rocblas_zhemm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_chemm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chemm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhemm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhemm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_chemm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_chemm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zhemm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zhemm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_cherk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_cherk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{Cfloat},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    beta::Ptr{Cfloat}, C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_zherk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zherk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{Cdouble},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    beta::Ptr{Cdouble}, C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_cherk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cherk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int, beta::Ptr{Cfloat},
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zherk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zherk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int, beta::Ptr{Cdouble},
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cherk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cherk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{Cfloat},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cfloat},
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zherk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zherk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{Cdouble},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cdouble},
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_cher2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_cher2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                     beta::Ptr{Cfloat}, C::Ptr{rocblas_float_complex},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrsv_strided_batched(handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+function rocblas_zher2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, m, A, lda, stride_A, x, incx, stride_x, batch_count)
+    @ccall librocblas.rocblas_zher2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                     beta::Ptr{Cdouble}, C::Ptr{rocblas_double_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_cher2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cher2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_float_complex},
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_float_complex}},
+                                             ldb::rocblas_int, beta::Ptr{Cfloat},
+                                             C::Ptr{Ptr{rocblas_float_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zher2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zher2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_double_complex},
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_double_complex}},
+                                             ldb::rocblas_int, beta::Ptr{Cdouble},
+                                             C::Ptr{Ptr{rocblas_double_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cher2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cher2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_float_complex},
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_float_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cfloat},
+                                                     C::Ptr{rocblas_float_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zher2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zher2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_double_complex},
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_double_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cdouble},
+                                                     C::Ptr{rocblas_double_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_stpsv(handle, uplo, transA, diag, n, AP, x, incx)
+function rocblas_cherkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stpsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx)
+    @ccall librocblas.rocblas_cherkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                     beta::Ptr{Cfloat}, C::Ptr{rocblas_float_complex},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtpsv(handle, uplo, transA, diag, n, AP, x, incx)
+function rocblas_zherkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtpsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx)
+    @ccall librocblas.rocblas_zherkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                     beta::Ptr{Cdouble}, C::Ptr{rocblas_double_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_cherkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cherkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_float_complex},
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_float_complex}},
+                                             ldb::rocblas_int, beta::Ptr{Cfloat},
+                                             C::Ptr{Ptr{rocblas_float_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zherkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zherkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_double_complex},
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_double_complex}},
+                                             ldb::rocblas_int, beta::Ptr{Cdouble},
+                                             C::Ptr{Ptr{rocblas_double_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cherkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cherkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_float_complex},
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_float_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cfloat},
+                                                     C::Ptr{rocblas_float_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zherkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zherkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_double_complex},
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_double_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cdouble},
+                                                     C::Ptr{rocblas_double_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctpsv(handle, uplo, transA, diag, n, AP, x, incx)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctpsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx)
-end
-
-function rocblas_ztpsv(handle, uplo, transA, diag, n, AP, x, incx)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztpsv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx)
-end
-
-function rocblas_stpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_stpsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-end
-
-function rocblas_dtpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtpsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-end
-
-function rocblas_ctpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctpsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-end
-
-function rocblas_ztpsv_batched(handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztpsv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, diag, n, AP, x, incx, batch_count)
-end
-
-function rocblas_stpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_stpsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-end
-
-function rocblas_dtpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtpsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-end
-
-function rocblas_ctpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctpsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-end
-
-function rocblas_ztpsv_strided_batched(handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztpsv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, diag, n, AP, stride_A, x, incx, stride_x, batch_count)
-end
-
-function rocblas_ssymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_dsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_csymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_zsymv(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_ssymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_dsymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_csymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_zsymv_batched(handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_ssymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_dsymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_csymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_zsymv_strided_batched(handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_sspmv(handle, uplo, n, alpha, A, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, n, alpha, A, x, incx, beta, y, incy)
-end
-
-function rocblas_dspmv(handle, uplo, n, alpha, A, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, n, alpha, A, x, incx, beta, y, incy)
-end
-
-function rocblas_sspmv_batched(handle, uplo, n, alpha, A, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_dspmv_batched(handle, uplo, n, alpha, A, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, A, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_sspmv_strided_batched(handle, uplo, n, alpha, A, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_dspmv_strided_batched(handle, uplo, n, alpha, A, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, A, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_ssbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_dsbmv(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsbmv, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy)
-end
-
-function rocblas_dsbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_ssbmv_batched(handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssbmv_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, n, k, alpha, A, lda, x, incx, beta, y, incy, batch_count)
-end
-
-function rocblas_ssbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, k, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_dsbmv_strided_batched(handle, uplo, n, k, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsbmv_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, k, alpha, A, lda, strideA, x, incx, stridex, beta, y, incy, stridey, batch_count)
-end
-
-function rocblas_sger(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sger, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_dger(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dger, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_cgeru(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgeru, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_zgeru(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgeru, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_cgerc(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgerc, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_zgerc(handle, m, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgerc, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_sger_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sger_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_dger_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dger_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_cgeru_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgeru_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_zgeru_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgeru_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_cgerc_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgerc_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_zgerc_batched(handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgerc_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, m, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_sger_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sger_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_dger_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dger_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_cgeru_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgeru_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_zgeru_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgeru_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_cgerc_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgerc_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_zgerc_strided_batched(handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgerc_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, m, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_sspr(handle, uplo, n, alpha, x, incx, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, uplo, n, alpha, x, incx, AP)
-end
-
-function rocblas_dspr(handle, uplo, n, alpha, x, incx, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, uplo, n, alpha, x, incx, AP)
-end
-
-function rocblas_cspr(handle, uplo, n, alpha, x, incx, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cspr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}), handle, uplo, n, alpha, x, incx, AP)
-end
-
-function rocblas_zspr(handle, uplo, n, alpha, x, incx, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zspr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}), handle, uplo, n, alpha, x, incx, AP)
-end
-
-function rocblas_sspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
-end
-
-function rocblas_dspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
-end
-
-function rocblas_cspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cspr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
-end
-
-function rocblas_zspr_batched(handle, uplo, n, alpha, x, incx, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zspr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int), handle, uplo, n, alpha, x, incx, AP, batch_count)
-end
-
-function rocblas_sspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-end
-
-function rocblas_dspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-end
-
-function rocblas_cspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cspr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-end
-
-function rocblas_zspr_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zspr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, AP, stride_A, batch_count)
-end
-
-function rocblas_sspr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}), handle, uplo, n, alpha, x, incx, y, incy, AP)
-end
-
-function rocblas_dspr2(handle, uplo, n, alpha, x, incx, y, incy, AP)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}), handle, uplo, n, alpha, x, incx, y, incy, AP)
-end
-
-function rocblas_sspr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
-end
-
-function rocblas_dspr2_batched(handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, AP, batch_count)
-end
-
-function rocblas_sspr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sspr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
-end
-
-function rocblas_dspr2_strided_batched(handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dspr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stride_x, y, incy, stride_y, AP, stride_A, batch_count)
-end
-
-function rocblas_ssyr(handle, uplo, n, alpha, x, incx, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
-end
-
-function rocblas_dsyr(handle, uplo, n, alpha, x, incx, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
-end
-
-function rocblas_csyr(handle, uplo, n, alpha, x, incx, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
-end
-
-function rocblas_zsyr(handle, uplo, n, alpha, x, incx, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda)
-end
-
-function rocblas_ssyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-end
-
-function rocblas_dsyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-end
-
-function rocblas_csyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-end
-
-function rocblas_zsyr_batched(handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, A, lda, batch_count)
-end
-
-function rocblas_ssyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-end
-
-function rocblas_dsyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-end
-
-function rocblas_csyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-end
-
-function rocblas_zsyr_strided_batched(handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, A, lda, strideA, batch_count)
-end
-
-function rocblas_ssyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_dsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_csyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_zsyr2(handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda)
-end
-
-function rocblas_ssyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_dsyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_csyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_zsyr2_batched(handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, n, alpha, x, incx, y, incy, A, lda, batch_count)
-end
-
-function rocblas_ssyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_dsyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_csyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_zsyr2_strided_batched(handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, n, alpha, x, incx, stridex, y, incy, stridey, A, lda, strideA, batch_count)
-end
-
-function rocblas_chemm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_chemm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zhemm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zhemm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_chemm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_chemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zhemm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zhemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_chemm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_chemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zhemm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zhemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_cherk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_zherk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_cherk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_zherk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_cherk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zherk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_cher2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cher2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zher2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zher2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_cher2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cher2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zher2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zher2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_cher2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cher2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zher2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zher2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_cherkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zherkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_cherkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zherkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_cherkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cherkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zherkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zherkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_ssymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_dsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_csymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_ssymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_dsymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_csymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zsymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_ssymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssymm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_dsymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsymm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_csymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csymm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zsymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsymm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_ssyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_dsyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_csyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_zsyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrk, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
-end
-
-function rocblas_ssyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_dsyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_csyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_zsyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrk_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc, batch_count)
-end
-
-function rocblas_ssyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_dsyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_csyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zsyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrk_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, transA, n, k, alpha, A, lda, stride_A, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_ssyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_dsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_csyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2k, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_ssyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_dsyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_csyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zsyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2k_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_ssyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyr2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_dsyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyr2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_csyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyr2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zsyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyr2k_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_ssyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_dsyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_csyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_zsyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrkx, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_ssyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_dsyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_csyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zsyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrkx_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_ssyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ssyrkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_dsyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dsyrkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_csyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_csyrkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zsyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zsyrkx_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, trans, n, k, alpha, A, lda, stride_A, B, ldb, stride_B, beta, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_strmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_strmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-end
-
-function rocblas_dtrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-end
-
-function rocblas_ctrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-end
-
-function rocblas_ztrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
-end
-
-function rocblas_strmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_strmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_dtrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_ctrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_ztrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_strmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+function rocblas_ssymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+    @ccall librocblas.rocblas_ssymm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat}, lda::rocblas_int,
+                                    B::Ptr{Cfloat}, ldb::rocblas_int, beta::Ptr{Cfloat},
+                                    C::Ptr{Cfloat}, ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+function rocblas_dsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+    @ccall librocblas.rocblas_dsymm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble}, lda::rocblas_int,
+                                    B::Ptr{Cdouble}, ldb::rocblas_int, beta::Ptr{Cdouble},
+                                    C::Ptr{Cdouble}, ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+function rocblas_csymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+    @ccall librocblas.rocblas_csymm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+function rocblas_zsymm(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count)
+    @ccall librocblas.rocblas_zsymm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssymm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                            beta::Ptr{Cfloat}, C::Ptr{Ptr{Cfloat}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsymm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                            beta::Ptr{Cdouble}, C::Ptr{Ptr{Cdouble}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csymm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsymm_batched(handle, side, uplo, m, n, alpha, A, lda, B, ldb, beta, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsymm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssymm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsymm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csymm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsymm_strided_batched(handle, side, uplo, m, n, alpha, A, lda, stride_A, B,
+                                       ldb, stride_B, beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsymm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmm_outofplace(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+function rocblas_ssyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmm_outofplace, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_ssyrk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                    lda::rocblas_int, beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmm_outofplace(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+function rocblas_dsyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm_outofplace, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_dsyrk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                    lda::rocblas_int, beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmm_outofplace(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+function rocblas_csyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm_outofplace, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_csyrk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmm_outofplace(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+function rocblas_zsyrk(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm_outofplace, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_zsyrk(handle::rocblas_handle, uplo::rocblas_fill,
+                                    transA::rocblas_operation, n::rocblas_int,
+                                    k::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyrk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            beta::Ptr{Cfloat}, C::Ptr{Ptr{Cfloat}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyrk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            beta::Ptr{Cdouble}, C::Ptr{Ptr{Cdouble}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyrk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyrk_batched(handle, uplo, transA, n, k, alpha, A, lda, beta, C, ldc,
+                               batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyrk_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                            transA::rocblas_operation, n::rocblas_int,
+                                            k::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyrk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyrk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyrk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyrk_strided_batched(handle, uplo, transA, n, k, alpha, A, lda, stride_A,
+                                       beta, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyrk_strided_batched(handle::rocblas_handle,
+                                                    uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    n::rocblas_int, k::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmm_outofplace_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+function rocblas_ssyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmm_outofplace_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+    @ccall librocblas.rocblas_ssyr2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                     lda::rocblas_int, B::Ptr{Cfloat}, ldb::rocblas_int,
+                                     beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmm_outofplace_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+function rocblas_dsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm_outofplace_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+    @ccall librocblas.rocblas_dsyr2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                     lda::rocblas_int, B::Ptr{Cdouble}, ldb::rocblas_int,
+                                     beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmm_outofplace_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+function rocblas_csyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm_outofplace_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+    @ccall librocblas.rocblas_csyr2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_float_complex},
+                                     C::Ptr{rocblas_float_complex},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmm_outofplace_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+function rocblas_zsyr2k(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm_outofplace_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C, ldc, batch_count)
+    @ccall librocblas.rocblas_zsyr2k(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_double_complex},
+                                     C::Ptr{rocblas_double_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyr2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cfloat},
+                                             A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                             beta::Ptr{Cfloat}, C::Ptr{Ptr{Cfloat}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyr2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cdouble},
+                                             A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                             beta::Ptr{Cdouble}, C::Ptr{Ptr{Cdouble}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyr2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_float_complex},
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_float_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_float_complex},
+                                             C::Ptr{Ptr{rocblas_float_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyr2k_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyr2k_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_double_complex},
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_double_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_double_complex},
+                                             C::Ptr{Ptr{rocblas_double_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyr2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyr2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyr2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_float_complex},
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_float_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{rocblas_float_complex},
+                                                     C::Ptr{rocblas_float_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyr2k_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyr2k_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_double_complex},
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_double_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{rocblas_double_complex},
+                                                     C::Ptr{rocblas_double_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
-function rocblas_strmm_outofplace_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+function rocblas_ssyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strmm_outofplace_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+    @ccall librocblas.rocblas_ssyrkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                     lda::rocblas_int, B::Ptr{Cfloat}, ldb::rocblas_int,
+                                     beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_dtrmm_outofplace_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+function rocblas_dsyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrmm_outofplace_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+    @ccall librocblas.rocblas_dsyrkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                     lda::rocblas_int, B::Ptr{Cdouble}, ldb::rocblas_int,
+                                     beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ctrmm_outofplace_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+function rocblas_csyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrmm_outofplace_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+    @ccall librocblas.rocblas_csyrkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_float_complex},
+                                     C::Ptr{rocblas_float_complex},
+                                     ldc::rocblas_int)::rocblas_status
 end
 
-function rocblas_ztrmm_outofplace_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+function rocblas_zsyrkx(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrmm_outofplace_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, C, ldc, stride_C, batch_count)
+    @ccall librocblas.rocblas_zsyrkx(handle::rocblas_handle, uplo::rocblas_fill,
+                                     trans::rocblas_operation, n::rocblas_int,
+                                     k::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_double_complex},
+                                     C::Ptr{rocblas_double_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyrkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cfloat},
+                                             A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                             beta::Ptr{Cfloat}, C::Ptr{Ptr{Cfloat}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyrkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cdouble},
+                                             A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                             beta::Ptr{Cdouble}, C::Ptr{Ptr{Cdouble}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyrkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_float_complex},
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_float_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_float_complex},
+                                             C::Ptr{Ptr{rocblas_float_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyrkx_batched(handle, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C,
+                                ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyrkx_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             trans::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_double_complex},
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_double_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_double_complex},
+                                             C::Ptr{Ptr{rocblas_double_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ssyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ssyrkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dsyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dsyrkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_csyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_csyrkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_float_complex},
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_float_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{rocblas_float_complex},
+                                                     C::Ptr{rocblas_float_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zsyrkx_strided_batched(handle, uplo, trans, n, k, alpha, A, lda, stride_A,
+                                        B, ldb, stride_B, beta, C, ldc, stride_C,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zsyrkx_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     trans::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_double_complex},
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_A::rocblas_stride,
+                                                     B::Ptr{rocblas_double_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_B::rocblas_stride,
+                                                     beta::Ptr{rocblas_double_complex},
+                                                     C::Ptr{rocblas_double_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_C::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C,
+                       ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strmm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat}, lda::rocblas_int,
+                                    B::Ptr{Cfloat}, ldb::rocblas_int, C::Ptr{Cfloat},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C,
+                       ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrmm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble}, lda::rocblas_int,
+                                    B::Ptr{Cdouble}, ldb::rocblas_int, C::Ptr{Cdouble},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C,
+                       ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrmm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrmm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, C,
+                       ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrmm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_strmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                            C::Ptr{Ptr{Cfloat}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                            C::Ptr{Ptr{Cdouble}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrmm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_A, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int, alpha::Ptr{Cfloat},
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{Cfloat}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_A, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int, alpha::Ptr{Cdouble},
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{Cdouble}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_A, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrmm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_A, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_strtri(handle, uplo, diag, n, A, lda, invA, ldinvA)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strtri, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA)
+    @ccall librocblas.rocblas_strtri(handle::rocblas_handle, uplo::rocblas_fill,
+                                     diag::rocblas_diagonal, n::rocblas_int, A::Ptr{Cfloat},
+                                     lda::rocblas_int, invA::Ptr{Cfloat},
+                                     ldinvA::rocblas_int)::rocblas_status
 end
 
 function rocblas_dtrtri(handle, uplo, diag, n, A, lda, invA, ldinvA)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrtri, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA)
+    @ccall librocblas.rocblas_dtrtri(handle::rocblas_handle, uplo::rocblas_fill,
+                                     diag::rocblas_diagonal, n::rocblas_int,
+                                     A::Ptr{Cdouble}, lda::rocblas_int, invA::Ptr{Cdouble},
+                                     ldinvA::rocblas_int)::rocblas_status
 end
 
 function rocblas_ctrtri(handle, uplo, diag, n, A, lda, invA, ldinvA)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrtri, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA)
+    @ccall librocblas.rocblas_ctrtri(handle::rocblas_handle, uplo::rocblas_fill,
+                                     diag::rocblas_diagonal, n::rocblas_int,
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     invA::Ptr{rocblas_float_complex},
+                                     ldinvA::rocblas_int)::rocblas_status
 end
 
 function rocblas_ztrtri(handle, uplo, diag, n, A, lda, invA, ldinvA)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrtri, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA)
+    @ccall librocblas.rocblas_ztrtri(handle::rocblas_handle, uplo::rocblas_fill,
+                                     diag::rocblas_diagonal, n::rocblas_int,
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     invA::Ptr{rocblas_double_complex},
+                                     ldinvA::rocblas_int)::rocblas_status
 end
 
 function rocblas_strtri_batched(handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strtri_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
+    @ccall librocblas.rocblas_strtri_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             diag::rocblas_diagonal, n::rocblas_int,
+                                             A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                             invA::Ptr{Ptr{Cfloat}}, ldinvA::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_dtrtri_batched(handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrtri_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
+    @ccall librocblas.rocblas_dtrtri_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             diag::rocblas_diagonal, n::rocblas_int,
+                                             A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                             invA::Ptr{Ptr{Cdouble}}, ldinvA::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_ctrtri_batched(handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrtri_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
+    @ccall librocblas.rocblas_ctrtri_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             diag::rocblas_diagonal, n::rocblas_int,
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             invA::Ptr{Ptr{rocblas_float_complex}},
+                                             ldinvA::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_ztrtri_batched(handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrtri_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, uplo, diag, n, A, lda, invA, ldinvA, batch_count)
-end
-
-function rocblas_strtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_strtri_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-end
-
-function rocblas_dtrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtrtri_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-end
-
-function rocblas_ctrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctrtri_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-end
-
-function rocblas_ztrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztrtri_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_fill, rocblas_diagonal, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, uplo, diag, n, A, lda, stride_a, invA, ldinvA, stride_invA, batch_count)
+    @ccall librocblas.rocblas_ztrtri_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             diag::rocblas_diagonal, n::rocblas_int,
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             invA::Ptr{Ptr{rocblas_double_complex}},
+                                             ldinvA::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA,
+                                        ldinvA, stride_invA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strtri_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     diag::rocblas_diagonal, n::rocblas_int,
+                                                     A::Ptr{Cfloat}, lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     invA::Ptr{Cfloat}, ldinvA::rocblas_int,
+                                                     stride_invA::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA,
+                                        ldinvA, stride_invA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrtri_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     diag::rocblas_diagonal, n::rocblas_int,
+                                                     A::Ptr{Cdouble}, lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     invA::Ptr{Cdouble},
+                                                     ldinvA::rocblas_int,
+                                                     stride_invA::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA,
+                                        ldinvA, stride_invA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrtri_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     diag::rocblas_diagonal, n::rocblas_int,
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     invA::Ptr{rocblas_float_complex},
+                                                     ldinvA::rocblas_int,
+                                                     stride_invA::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrtri_strided_batched(handle, uplo, diag, n, A, lda, stride_a, invA,
+                                        ldinvA, stride_invA, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrtri_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     diag::rocblas_diagonal, n::rocblas_int,
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     invA::Ptr{rocblas_double_complex},
+                                                     ldinvA::rocblas_int,
+                                                     stride_invA::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_strsm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_strsm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
+    @ccall librocblas.rocblas_strsm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat}, lda::rocblas_int,
+                                    B::Ptr{Cfloat}, ldb::rocblas_int)::rocblas_status
 end
 
 function rocblas_dtrsm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
+    @ccall librocblas.rocblas_dtrsm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble}, lda::rocblas_int,
+                                    B::Ptr{Cdouble}, ldb::rocblas_int)::rocblas_status
 end
 
 function rocblas_ctrsm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
+    @ccall librocblas.rocblas_ctrsm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_float_complex},
+                                    ldb::rocblas_int)::rocblas_status
 end
 
 function rocblas_ztrsm(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb)
-end
-
-function rocblas_strsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_strsm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_dtrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_ctrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_ztrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count)
-end
-
-function rocblas_strsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_strsm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-end
-
-function rocblas_dtrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dtrsm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-end
-
-function rocblas_ctrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ctrsm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-end
-
-function rocblas_ztrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ztrsm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_a, B, ldb, stride_b, batch_count)
+    @ccall librocblas.rocblas_ztrsm(handle::rocblas_handle, side::rocblas_side,
+                                    uplo::rocblas_fill, transA::rocblas_operation,
+                                    diag::rocblas_diagonal, m::rocblas_int, n::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_double_complex},
+                                    ldb::rocblas_int)::rocblas_status
+end
+
+function rocblas_strsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strsm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrsm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrsm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrsm_batched(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                               ldb, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrsm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            uplo::rocblas_fill, transA::rocblas_operation,
+                                            diag::rocblas_diagonal, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_strsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_a, B, ldb, stride_b, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_strsm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int, alpha::Ptr{Cfloat},
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dtrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_a, B, ldb, stride_b, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dtrsm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int, alpha::Ptr{Cdouble},
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ctrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_a, B, ldb, stride_b, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ctrsm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ztrsm_strided_batched(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                       lda, stride_a, B, ldb, stride_b, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ztrsm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, uplo::rocblas_fill,
+                                                    transA::rocblas_operation,
+                                                    diag::rocblas_diagonal, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sgemm(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgemm, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
+    @ccall librocblas.rocblas_sgemm(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, k::rocblas_int, alpha::Ptr{Cfloat},
+                                    A::Ptr{Cfloat}, lda::rocblas_int, B::Ptr{Cfloat},
+                                    ldb::rocblas_int, beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_dgemm(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgemm, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
+    @ccall librocblas.rocblas_dgemm(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, k::rocblas_int, alpha::Ptr{Cdouble},
+                                    A::Ptr{Cdouble}, lda::rocblas_int, B::Ptr{Cdouble},
+                                    ldb::rocblas_int, beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_hgemm(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_hgemm, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, Ptr{rocblas_half}, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
+    @ccall librocblas.rocblas_hgemm(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, k::rocblas_int,
+                                    alpha::Ptr{rocblas_half}, A::Ptr{rocblas_half},
+                                    lda::rocblas_int, B::Ptr{rocblas_half},
+                                    ldb::rocblas_int, beta::Ptr{rocblas_half},
+                                    C::Ptr{rocblas_half}, ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_cgemm(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgemm, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
+    @ccall librocblas.rocblas_cgemm(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, k::rocblas_int,
+                                    alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_zgemm(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgemm, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc)
-end
-
-function rocblas_sgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sgemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_dgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dgemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_hgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_hgemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_half}, Ptr{Ptr{rocblas_half}}, rocblas_int, Ptr{Ptr{rocblas_half}}, rocblas_int, Ptr{rocblas_half}, Ptr{Ptr{rocblas_half}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_cgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_zgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgemm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc, batch_count)
-end
-
-function rocblas_sgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sgemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_dgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dgemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_hgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_hgemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_hgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_hgemm_kernel_name, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, rocblas_int, rocblas_stride, Ptr{rocblas_half}, Ptr{rocblas_half}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_sgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sgemm_kernel_name, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_dgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dgemm_kernel_name, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_cgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-end
-
-function rocblas_zgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgemm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, k, alpha, A, lda, stride_a, B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
+    @ccall librocblas.rocblas_zgemm(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, k::rocblas_int,
+                                    alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta,
+                               C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemm_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{Cfloat}, A::Ptr{Ptr{Cfloat}},
+                                            lda::rocblas_int, B::Ptr{Ptr{Cfloat}},
+                                            ldb::rocblas_int, beta::Ptr{Cfloat},
+                                            C::Ptr{Ptr{Cfloat}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta,
+                               C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemm_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{Cdouble}, A::Ptr{Ptr{Cdouble}},
+                                            lda::rocblas_int, B::Ptr{Ptr{Cdouble}},
+                                            ldb::rocblas_int, beta::Ptr{Cdouble},
+                                            C::Ptr{Ptr{Cdouble}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta,
+                               C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hgemm_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{rocblas_half},
+                                            A::Ptr{Ptr{rocblas_half}}, lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_half}}, ldb::rocblas_int,
+                                            beta::Ptr{rocblas_half},
+                                            C::Ptr{Ptr{rocblas_half}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta,
+                               C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemm_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemm_batched(handle, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta,
+                               C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemm_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, k::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda,
+                                       stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemm_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    k::rocblas_int, alpha::Ptr{Cfloat},
+                                                    A::Ptr{Cfloat}, lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                    ldc::rocblas_int,
+                                                    stride_c::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda,
+                                       stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemm_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    k::rocblas_int, alpha::Ptr{Cdouble},
+                                                    A::Ptr{Cdouble}, lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                    ldc::rocblas_int,
+                                                    stride_c::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda,
+                                       stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hgemm_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    alpha::Ptr{rocblas_half},
+                                                    A::Ptr{rocblas_half}, lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{rocblas_half}, ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    beta::Ptr{rocblas_half},
+                                                    C::Ptr{rocblas_half}, ldc::rocblas_int,
+                                                    stride_c::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_hgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a,
+                                   B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_hgemm_kernel_name(handle::rocblas_handle,
+                                                transA::rocblas_operation,
+                                                transB::rocblas_operation, m::rocblas_int,
+                                                n::rocblas_int, k::rocblas_int,
+                                                alpha::Ptr{rocblas_half},
+                                                A::Ptr{rocblas_half}, lda::rocblas_int,
+                                                stride_a::rocblas_stride,
+                                                B::Ptr{rocblas_half}, ldb::rocblas_int,
+                                                stride_b::rocblas_stride,
+                                                beta::Ptr{rocblas_half},
+                                                C::Ptr{rocblas_half}, ldc::rocblas_int,
+                                                stride_c::rocblas_stride,
+                                                batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a,
+                                   B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemm_kernel_name(handle::rocblas_handle,
+                                                transA::rocblas_operation,
+                                                transB::rocblas_operation, m::rocblas_int,
+                                                n::rocblas_int, k::rocblas_int,
+                                                alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                lda::rocblas_int, stride_a::rocblas_stride,
+                                                B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                stride_b::rocblas_stride, beta::Ptr{Cfloat},
+                                                C::Ptr{Cfloat}, ldc::rocblas_int,
+                                                stride_c::rocblas_stride,
+                                                batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemm_kernel_name(handle, transA, transB, m, n, k, alpha, A, lda, stride_a,
+                                   B, ldb, stride_b, beta, C, ldc, stride_c, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemm_kernel_name(handle::rocblas_handle,
+                                                transA::rocblas_operation,
+                                                transB::rocblas_operation, m::rocblas_int,
+                                                n::rocblas_int, k::rocblas_int,
+                                                alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                lda::rocblas_int, stride_a::rocblas_stride,
+                                                B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                stride_b::rocblas_stride,
+                                                beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                ldc::rocblas_int, stride_c::rocblas_stride,
+                                                batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda,
+                                       stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemm_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_c::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemm_strided_batched(handle, transA, transB, m, n, k, alpha, A, lda,
+                                       stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemm_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    k::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_a::rocblas_stride,
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_b::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_c::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sdgmm(handle, side, m, n, A, lda, x, incx, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sdgmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc)
+    @ccall librocblas.rocblas_sdgmm(handle::rocblas_handle, side::rocblas_side,
+                                    m::rocblas_int, n::rocblas_int, A::Ptr{Cfloat},
+                                    lda::rocblas_int, x::Ptr{Cfloat}, incx::rocblas_int,
+                                    C::Ptr{Cfloat}, ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_ddgmm(handle, side, m, n, A, lda, x, incx, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ddgmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc)
+    @ccall librocblas.rocblas_ddgmm(handle::rocblas_handle, side::rocblas_side,
+                                    m::rocblas_int, n::rocblas_int, A::Ptr{Cdouble},
+                                    lda::rocblas_int, x::Ptr{Cdouble}, incx::rocblas_int,
+                                    C::Ptr{Cdouble}, ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_cdgmm(handle, side, m, n, A, lda, x, incx, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdgmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc)
+    @ccall librocblas.rocblas_cdgmm(handle::rocblas_handle, side::rocblas_side,
+                                    m::rocblas_int, n::rocblas_int,
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_float_complex}, incx::rocblas_int,
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdgmm(handle, side, m, n, A, lda, x, incx, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdgmm, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc)
+    @ccall librocblas.rocblas_zdgmm(handle::rocblas_handle, side::rocblas_side,
+                                    m::rocblas_int, n::rocblas_int,
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    x::Ptr{rocblas_double_complex}, incx::rocblas_int,
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_sdgmm_batched(handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sdgmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
+    @ccall librocblas.rocblas_sdgmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            m::rocblas_int, n::rocblas_int,
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cfloat}}, incx::rocblas_int,
+                                            C::Ptr{Ptr{Cfloat}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_ddgmm_batched(handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_ddgmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
+    @ccall librocblas.rocblas_ddgmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            m::rocblas_int, n::rocblas_int,
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            x::Ptr{Ptr{Cdouble}}, incx::rocblas_int,
+                                            C::Ptr{Ptr{Cdouble}}, ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_cdgmm_batched(handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cdgmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
+    @ccall librocblas.rocblas_cdgmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            m::rocblas_int, n::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_float_complex}},
+                                            incx::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_zdgmm_batched(handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zdgmm_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, side, m, n, A, lda, x, incx, C, ldc, batch_count)
-end
-
-function rocblas_sdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sdgmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_ddgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_ddgmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_cdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cdgmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zdgmm_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, side, m, n, A, lda, stride_A, x, incx, stride_x, C, ldc, stride_C, batch_count)
+    @ccall librocblas.rocblas_zdgmm_batched(handle::rocblas_handle, side::rocblas_side,
+                                            m::rocblas_int, n::rocblas_int,
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            x::Ptr{Ptr{rocblas_double_complex}},
+                                            incx::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx,
+                                       stride_x, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sdgmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, m::rocblas_int,
+                                                    n::rocblas_int, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cfloat}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    C::Ptr{Cfloat}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_ddgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx,
+                                       stride_x, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_ddgmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, m::rocblas_int,
+                                                    n::rocblas_int, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{Cdouble}, incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    C::Ptr{Cdouble}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx,
+                                       stride_x, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cdgmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_float_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zdgmm_strided_batched(handle, side, m, n, A, lda, stride_A, x, incx,
+                                       stride_x, C, ldc, stride_C, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zdgmm_strided_batched(handle::rocblas_handle,
+                                                    side::rocblas_side, m::rocblas_int,
+                                                    n::rocblas_int,
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    x::Ptr{rocblas_double_complex},
+                                                    incx::rocblas_int,
+                                                    stride_x::rocblas_stride,
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
 end
 
 function rocblas_sgeam(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_sgeam, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, Ptr{Cfloat}, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_sgeam(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                    lda::rocblas_int, beta::Ptr{Cfloat}, B::Ptr{Cfloat},
+                                    ldb::rocblas_int, C::Ptr{Cfloat},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_dgeam(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_dgeam, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, Ptr{Cdouble}, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_dgeam(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                    lda::rocblas_int, beta::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                    ldb::rocblas_int, C::Ptr{Cdouble},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_cgeam(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_cgeam, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, Ptr{rocblas_float_complex}, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
+    @ccall librocblas.rocblas_cgeam(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, alpha::Ptr{rocblas_float_complex},
+                                    A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                    beta::Ptr{rocblas_float_complex},
+                                    B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                    C::Ptr{rocblas_float_complex},
+                                    ldc::rocblas_int)::rocblas_status
 end
 
 function rocblas_zgeam(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
     AMDGPU.prepare_state()
-    ccall((:rocblas_zgeam, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, Ptr{rocblas_double_complex}, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc)
-end
-
-function rocblas_sgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sgeam_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Cfloat}, Ptr{Ptr{Cfloat}}, rocblas_int, Ptr{Ptr{Cfloat}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-end
-
-function rocblas_dgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dgeam_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Cdouble}, Ptr{Ptr{Cdouble}}, rocblas_int, Ptr{Ptr{Cdouble}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-end
-
-function rocblas_cgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgeam_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{rocblas_float_complex}, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, Ptr{Ptr{rocblas_float_complex}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-end
-
-function rocblas_zgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgeam_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{rocblas_double_complex}, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, Ptr{Ptr{rocblas_double_complex}}, rocblas_int, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C, ldc, batch_count)
-end
-
-function rocblas_sgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_sgeam_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, Ptr{Cfloat}, rocblas_int, rocblas_stride, Ptr{Cfloat}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_dgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dgeam_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, Ptr{Cdouble}, rocblas_int, rocblas_stride, Ptr{Cdouble}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_cgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_cgeam_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_float_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_zgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_zgeam_strided_batched, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, Ptr{rocblas_double_complex}, rocblas_int, rocblas_stride, rocblas_int), handle, transA, transB, m, n, alpha, A, lda, stride_A, beta, B, ldb, stride_B, C, ldc, stride_C, batch_count)
-end
-
-function rocblas_gemm_batched_ex(handle, transA, transB, m, n, k, alpha, a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc, d, d_type, ldd, batch_count, compute_type, algo, solution_index, flags)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_gemm_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_operation, rocblas_operation, rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, rocblas_datatype, rocblas_gemm_algo, Int32, UInt32), handle, transA, transB, m, n, k, alpha, a, a_type, lda, b, b_type, ldb, beta, c, c_type, ldc, d, d_type, ldd, batch_count, compute_type, algo, solution_index, flags)
-end
-
-function rocblas_gemm_ext2(handle, m, n, k, alpha, a, a_type, row_stride_a, col_stride_a, b, b_type, row_stride_b, col_stride_b, beta, c, c_type, row_stride_c, col_stride_c, d, d_type, row_stride_d, col_stride_d, compute_type, algo, solution_index, flags)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_gemm_ext2, librocblas), rocblas_status, (rocblas_handle, rocblas_int, rocblas_int, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_stride, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_stride, rocblas_stride, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_stride, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_stride, rocblas_stride, rocblas_datatype, rocblas_gemm_algo, Int32, UInt32), handle, m, n, k, alpha, a, a_type, row_stride_a, col_stride_a, b, b_type, row_stride_b, col_stride_b, beta, c, c_type, row_stride_c, col_stride_c, d, d_type, row_stride_d, col_stride_d, compute_type, algo, solution_index, flags)
-end
-
-function rocblas_trsm_batched_ex(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count, invA, invA_size, compute_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_trsm_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_int, Ptr{Cvoid}, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_int, rocblas_datatype), handle, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb, batch_count, invA, invA_size, compute_type)
-end
-
-function rocblas_trsm_strided_batched_ex(handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_trsm_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_side, rocblas_fill, rocblas_operation, rocblas_diagonal, rocblas_int, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_int, rocblas_stride, Ptr{Cvoid}, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cvoid}, rocblas_int, rocblas_stride, rocblas_datatype), handle, side, uplo, transA, diag, m, n, alpha, A, lda, stride_A, B, ldb, stride_B, batch_count, invA, invA_size, stride_invA, compute_type)
-end
-
-function rocblas_axpy_ex(handle, n, alpha, alpha_type, x, x_type, incx, y, y_type, incy, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_axpy_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, y, y_type, incy, execution_type)
-end
-
-function rocblas_axpy_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, y, y_type, incy, batch_count, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_axpy_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, y, y_type, incy, batch_count, execution_type)
-end
-
-function rocblas_axpy_strided_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, stridex, y, y_type, incy, stridey, batch_count, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_axpy_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, stridex, y, y_type, incy, stridey, batch_count, execution_type)
-end
-
-function rocblas_dot_ex(handle, n, x, x_type, incx, y, y_type, incy, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dot_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, result, result_type, execution_type)
-end
-
-function rocblas_dotc_ex(handle, n, x, x_type, incx, y, y_type, incy, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dotc_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, result, result_type, execution_type)
-end
-
-function rocblas_dot_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, batch_count, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dot_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, batch_count, result, result_type, execution_type)
-end
-
-function rocblas_dotc_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, batch_count, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dotc_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, batch_count, result, result_type, execution_type)
-end
-
-function rocblas_dot_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, batch_count, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dot_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, batch_count, result, result_type, execution_type)
-end
-
-function rocblas_dotc_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, batch_count, result, result_type, execution_type)
-    AMDGPU.prepare_state()
-    ccall((:rocblas_dotc_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, batch_count, result, result_type, execution_type)
+    @ccall librocblas.rocblas_zgeam(handle::rocblas_handle, transA::rocblas_operation,
+                                    transB::rocblas_operation, m::rocblas_int,
+                                    n::rocblas_int, alpha::Ptr{rocblas_double_complex},
+                                    A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                    beta::Ptr{rocblas_double_complex},
+                                    B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                    C::Ptr{rocblas_double_complex},
+                                    ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgeam_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cfloat},
+                                            A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                            beta::Ptr{Cfloat}, B::Ptr{Ptr{Cfloat}},
+                                            ldb::rocblas_int, C::Ptr{Ptr{Cfloat}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgeam_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int, alpha::Ptr{Cdouble},
+                                            A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                            beta::Ptr{Cdouble}, B::Ptr{Ptr{Cdouble}},
+                                            ldb::rocblas_int, C::Ptr{Ptr{Cdouble}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgeam_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_float_complex},
+                                            A::Ptr{Ptr{rocblas_float_complex}},
+                                            lda::rocblas_int,
+                                            beta::Ptr{rocblas_float_complex},
+                                            B::Ptr{Ptr{rocblas_float_complex}},
+                                            ldb::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_float_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgeam_batched(handle, transA, transB, m, n, alpha, A, lda, beta, B, ldb, C,
+                               ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgeam_batched(handle::rocblas_handle,
+                                            transA::rocblas_operation,
+                                            transB::rocblas_operation, m::rocblas_int,
+                                            n::rocblas_int,
+                                            alpha::Ptr{rocblas_double_complex},
+                                            A::Ptr{Ptr{rocblas_double_complex}},
+                                            lda::rocblas_int,
+                                            beta::Ptr{rocblas_double_complex},
+                                            B::Ptr{Ptr{rocblas_double_complex}},
+                                            ldb::rocblas_int,
+                                            C::Ptr{Ptr{rocblas_double_complex}},
+                                            ldc::rocblas_int,
+                                            batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda,
+                                       stride_A, beta, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgeam_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cfloat}, B::Ptr{Cfloat},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{Cfloat}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda,
+                                       stride_A, beta, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgeam_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{Cdouble}, ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda,
+                                       stride_A, beta, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgeam_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_float_complex},
+                                                    A::Ptr{rocblas_float_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{rocblas_float_complex},
+                                                    B::Ptr{rocblas_float_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{rocblas_float_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgeam_strided_batched(handle, transA, transB, m, n, alpha, A, lda,
+                                       stride_A, beta, B, ldb, stride_B, C, ldc, stride_C,
+                                       batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgeam_strided_batched(handle::rocblas_handle,
+                                                    transA::rocblas_operation,
+                                                    transB::rocblas_operation,
+                                                    m::rocblas_int, n::rocblas_int,
+                                                    alpha::Ptr{rocblas_double_complex},
+                                                    A::Ptr{rocblas_double_complex},
+                                                    lda::rocblas_int,
+                                                    stride_A::rocblas_stride,
+                                                    beta::Ptr{rocblas_double_complex},
+                                                    B::Ptr{rocblas_double_complex},
+                                                    ldb::rocblas_int,
+                                                    stride_B::rocblas_stride,
+                                                    C::Ptr{rocblas_double_complex},
+                                                    ldc::rocblas_int,
+                                                    stride_C::rocblas_stride,
+                                                    batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_gemm_batched_ex(handle, transA, transB, m, n, k, alpha, a, a_type, lda, b,
+                                 b_type, ldb, beta, c, c_type, ldc, d, d_type, ldd,
+                                 batch_count, compute_type, algo, solution_index, flags)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_gemm_batched_ex(handle::rocblas_handle,
+                                              transA::rocblas_operation,
+                                              transB::rocblas_operation, m::rocblas_int,
+                                              n::rocblas_int, k::rocblas_int,
+                                              alpha::Ptr{Cvoid}, a::Ptr{Cvoid},
+                                              a_type::rocblas_datatype, lda::rocblas_int,
+                                              b::Ptr{Cvoid}, b_type::rocblas_datatype,
+                                              ldb::rocblas_int, beta::Ptr{Cvoid},
+                                              c::Ptr{Cvoid}, c_type::rocblas_datatype,
+                                              ldc::rocblas_int, d::Ptr{Cvoid},
+                                              d_type::rocblas_datatype, ldd::rocblas_int,
+                                              batch_count::rocblas_int,
+                                              compute_type::rocblas_datatype,
+                                              algo::rocblas_gemm_algo,
+                                              solution_index::Int32,
+                                              flags::UInt32)::rocblas_status
+end
+
+function rocblas_sgemmt(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb, beta, C,
+                        ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemmt(handle::rocblas_handle, uplo::rocblas_fill,
+                                     transA::rocblas_operation, transB::rocblas_operation,
+                                     n::rocblas_int, k::rocblas_int, alpha::Ptr{Cfloat},
+                                     A::Ptr{Cfloat}, lda::rocblas_int, B::Ptr{Cfloat},
+                                     ldb::rocblas_int, beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemmt(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb, beta, C,
+                        ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemmt(handle::rocblas_handle, uplo::rocblas_fill,
+                                     transA::rocblas_operation, transB::rocblas_operation,
+                                     n::rocblas_int, k::rocblas_int, alpha::Ptr{Cdouble},
+                                     A::Ptr{Cdouble}, lda::rocblas_int, B::Ptr{Cdouble},
+                                     ldb::rocblas_int, beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemmt(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb, beta, C,
+                        ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemmt(handle::rocblas_handle, uplo::rocblas_fill,
+                                     transA::rocblas_operation, transB::rocblas_operation,
+                                     n::rocblas_int, k::rocblas_int,
+                                     alpha::Ptr{rocblas_float_complex},
+                                     A::Ptr{rocblas_float_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_float_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_float_complex},
+                                     C::Ptr{rocblas_float_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemmt(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb, beta, C,
+                        ldc)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemmt(handle::rocblas_handle, uplo::rocblas_fill,
+                                     transA::rocblas_operation, transB::rocblas_operation,
+                                     n::rocblas_int, k::rocblas_int,
+                                     alpha::Ptr{rocblas_double_complex},
+                                     A::Ptr{rocblas_double_complex}, lda::rocblas_int,
+                                     B::Ptr{rocblas_double_complex}, ldb::rocblas_int,
+                                     beta::Ptr{rocblas_double_complex},
+                                     C::Ptr{rocblas_double_complex},
+                                     ldc::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemmt_batched(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb,
+                                beta, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemmt_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             transA::rocblas_operation,
+                                             transB::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cfloat},
+                                             A::Ptr{Ptr{Cfloat}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cfloat}}, ldb::rocblas_int,
+                                             beta::Ptr{Cfloat}, C::Ptr{Ptr{Cfloat}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemmt_batched(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb,
+                                beta, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemmt_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             transA::rocblas_operation,
+                                             transB::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int, alpha::Ptr{Cdouble},
+                                             A::Ptr{Ptr{Cdouble}}, lda::rocblas_int,
+                                             B::Ptr{Ptr{Cdouble}}, ldb::rocblas_int,
+                                             beta::Ptr{Cdouble}, C::Ptr{Ptr{Cdouble}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemmt_batched(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb,
+                                beta, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemmt_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             transA::rocblas_operation,
+                                             transB::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_float_complex},
+                                             A::Ptr{Ptr{rocblas_float_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_float_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_float_complex},
+                                             C::Ptr{Ptr{rocblas_float_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemmt_batched(handle, uplo, transA, transB, n, k, alpha, A, lda, B, ldb,
+                                beta, C, ldc, batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemmt_batched(handle::rocblas_handle, uplo::rocblas_fill,
+                                             transA::rocblas_operation,
+                                             transB::rocblas_operation, n::rocblas_int,
+                                             k::rocblas_int,
+                                             alpha::Ptr{rocblas_double_complex},
+                                             A::Ptr{Ptr{rocblas_double_complex}},
+                                             lda::rocblas_int,
+                                             B::Ptr{Ptr{rocblas_double_complex}},
+                                             ldb::rocblas_int,
+                                             beta::Ptr{rocblas_double_complex},
+                                             C::Ptr{Ptr{rocblas_double_complex}},
+                                             ldc::rocblas_int,
+                                             batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_sgemmt_strided_batched(handle, uplo, transA, transB, n, k, alpha, A, lda,
+                                        stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_sgemmt_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     transA::rocblas_operation,
+                                                     transB::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cfloat}, A::Ptr{Cfloat},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     B::Ptr{Cfloat}, ldb::rocblas_int,
+                                                     stride_b::rocblas_stride,
+                                                     beta::Ptr{Cfloat}, C::Ptr{Cfloat},
+                                                     ldc::rocblas_int,
+                                                     stride_c::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_dgemmt_strided_batched(handle, uplo, transA, transB, n, k, alpha, A, lda,
+                                        stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dgemmt_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     transA::rocblas_operation,
+                                                     transB::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{Cdouble}, A::Ptr{Cdouble},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     B::Ptr{Cdouble}, ldb::rocblas_int,
+                                                     stride_b::rocblas_stride,
+                                                     beta::Ptr{Cdouble}, C::Ptr{Cdouble},
+                                                     ldc::rocblas_int,
+                                                     stride_c::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_cgemmt_strided_batched(handle, uplo, transA, transB, n, k, alpha, A, lda,
+                                        stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_cgemmt_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     transA::rocblas_operation,
+                                                     transB::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_float_complex},
+                                                     A::Ptr{rocblas_float_complex},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     B::Ptr{rocblas_float_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_b::rocblas_stride,
+                                                     beta::Ptr{rocblas_float_complex},
+                                                     C::Ptr{rocblas_float_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_c::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_zgemmt_strided_batched(handle, uplo, transA, transB, n, k, alpha, A, lda,
+                                        stride_a, B, ldb, stride_b, beta, C, ldc, stride_c,
+                                        batch_count)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_zgemmt_strided_batched(handle::rocblas_handle,
+                                                     uplo::rocblas_fill,
+                                                     transA::rocblas_operation,
+                                                     transB::rocblas_operation,
+                                                     n::rocblas_int, k::rocblas_int,
+                                                     alpha::Ptr{rocblas_double_complex},
+                                                     A::Ptr{rocblas_double_complex},
+                                                     lda::rocblas_int,
+                                                     stride_a::rocblas_stride,
+                                                     B::Ptr{rocblas_double_complex},
+                                                     ldb::rocblas_int,
+                                                     stride_b::rocblas_stride,
+                                                     beta::Ptr{rocblas_double_complex},
+                                                     C::Ptr{rocblas_double_complex},
+                                                     ldc::rocblas_int,
+                                                     stride_c::rocblas_stride,
+                                                     batch_count::rocblas_int)::rocblas_status
+end
+
+function rocblas_geam_ex(handle, transA, transB, m, n, k, alpha, A, a_type, lda, B, b_type,
+                         ldb, beta, C, c_type, ldc, D, d_type, ldd, compute_type,
+                         geam_ex_op)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_geam_ex(handle::rocblas_handle, transA::rocblas_operation,
+                                      transB::rocblas_operation, m::rocblas_int,
+                                      n::rocblas_int, k::rocblas_int, alpha::Ptr{Cvoid},
+                                      A::Ptr{Cvoid}, a_type::rocblas_datatype,
+                                      lda::rocblas_int, B::Ptr{Cvoid},
+                                      b_type::rocblas_datatype, ldb::rocblas_int,
+                                      beta::Ptr{Cvoid}, C::Ptr{Cvoid},
+                                      c_type::rocblas_datatype, ldc::rocblas_int,
+                                      D::Ptr{Cvoid}, d_type::rocblas_datatype,
+                                      ldd::rocblas_int, compute_type::rocblas_datatype,
+                                      geam_ex_op::rocblas_geam_ex_operation)::rocblas_status
+end
+
+function rocblas_trsm_batched_ex(handle, side, uplo, transA, diag, m, n, alpha, A, lda, B,
+                                 ldb, batch_count, invA, invA_size, compute_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_trsm_batched_ex(handle::rocblas_handle, side::rocblas_side,
+                                              uplo::rocblas_fill, transA::rocblas_operation,
+                                              diag::rocblas_diagonal, m::rocblas_int,
+                                              n::rocblas_int, alpha::Ptr{Cvoid},
+                                              A::Ptr{Cvoid}, lda::rocblas_int,
+                                              B::Ptr{Cvoid}, ldb::rocblas_int,
+                                              batch_count::rocblas_int, invA::Ptr{Cvoid},
+                                              invA_size::rocblas_int,
+                                              compute_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_trsm_strided_batched_ex(handle, side, uplo, transA, diag, m, n, alpha, A,
+                                         lda, stride_A, B, ldb, stride_B, batch_count, invA,
+                                         invA_size, stride_invA, compute_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_trsm_strided_batched_ex(handle::rocblas_handle,
+                                                      side::rocblas_side,
+                                                      uplo::rocblas_fill,
+                                                      transA::rocblas_operation,
+                                                      diag::rocblas_diagonal,
+                                                      m::rocblas_int, n::rocblas_int,
+                                                      alpha::Ptr{Cvoid}, A::Ptr{Cvoid},
+                                                      lda::rocblas_int,
+                                                      stride_A::rocblas_stride,
+                                                      B::Ptr{Cvoid}, ldb::rocblas_int,
+                                                      stride_B::rocblas_stride,
+                                                      batch_count::rocblas_int,
+                                                      invA::Ptr{Cvoid},
+                                                      invA_size::rocblas_int,
+                                                      stride_invA::rocblas_stride,
+                                                      compute_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_axpy_ex(handle, n, alpha, alpha_type, x, x_type, incx, y, y_type, incy,
+                         execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_axpy_ex(handle::rocblas_handle, n::rocblas_int,
+                                      alpha::Ptr{Cvoid}, alpha_type::rocblas_datatype,
+                                      x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                      incx::rocblas_int, y::Ptr{Cvoid},
+                                      y_type::rocblas_datatype, incy::rocblas_int,
+                                      execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_axpy_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, y, y_type,
+                                 incy, batch_count, execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_axpy_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                              alpha::Ptr{Cvoid},
+                                              alpha_type::rocblas_datatype, x::Ptr{Cvoid},
+                                              x_type::rocblas_datatype, incx::rocblas_int,
+                                              y::Ptr{Cvoid}, y_type::rocblas_datatype,
+                                              incy::rocblas_int, batch_count::rocblas_int,
+                                              execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_axpy_strided_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx,
+                                         stridex, y, y_type, incy, stridey, batch_count,
+                                         execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_axpy_strided_batched_ex(handle::rocblas_handle,
+                                                      n::rocblas_int, alpha::Ptr{Cvoid},
+                                                      alpha_type::rocblas_datatype,
+                                                      x::Ptr{Cvoid},
+                                                      x_type::rocblas_datatype,
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      y::Ptr{Cvoid},
+                                                      y_type::rocblas_datatype,
+                                                      incy::rocblas_int,
+                                                      stridey::rocblas_stride,
+                                                      batch_count::rocblas_int,
+                                                      execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dot_ex(handle, n, x, x_type, incx, y, y_type, incy, result, result_type,
+                        execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dot_ex(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cvoid},
+                                     x_type::rocblas_datatype, incx::rocblas_int,
+                                     y::Ptr{Cvoid}, y_type::rocblas_datatype,
+                                     incy::rocblas_int, result::Ptr{Cvoid},
+                                     result_type::rocblas_datatype,
+                                     execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dotc_ex(handle, n, x, x_type, incx, y, y_type, incy, result, result_type,
+                         execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dotc_ex(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cvoid},
+                                      x_type::rocblas_datatype, incx::rocblas_int,
+                                      y::Ptr{Cvoid}, y_type::rocblas_datatype,
+                                      incy::rocblas_int, result::Ptr{Cvoid},
+                                      result_type::rocblas_datatype,
+                                      execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dot_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, batch_count,
+                                result, result_type, execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dot_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                             incx::rocblas_int, y::Ptr{Cvoid},
+                                             y_type::rocblas_datatype, incy::rocblas_int,
+                                             batch_count::rocblas_int, result::Ptr{Cvoid},
+                                             result_type::rocblas_datatype,
+                                             execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dotc_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, batch_count,
+                                 result, result_type, execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dotc_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                              x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                              incx::rocblas_int, y::Ptr{Cvoid},
+                                              y_type::rocblas_datatype, incy::rocblas_int,
+                                              batch_count::rocblas_int, result::Ptr{Cvoid},
+                                              result_type::rocblas_datatype,
+                                              execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dot_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type,
+                                        incy, stride_y, batch_count, result, result_type,
+                                        execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dot_strided_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cvoid},
+                                                     x_type::rocblas_datatype,
+                                                     incx::rocblas_int,
+                                                     stride_x::rocblas_stride,
+                                                     y::Ptr{Cvoid},
+                                                     y_type::rocblas_datatype,
+                                                     incy::rocblas_int,
+                                                     stride_y::rocblas_stride,
+                                                     batch_count::rocblas_int,
+                                                     result::Ptr{Cvoid},
+                                                     result_type::rocblas_datatype,
+                                                     execution_type::rocblas_datatype)::rocblas_status
+end
+
+function rocblas_dotc_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type,
+                                         incy, stride_y, batch_count, result, result_type,
+                                         execution_type)
+    AMDGPU.prepare_state()
+    @ccall librocblas.rocblas_dotc_strided_batched_ex(handle::rocblas_handle,
+                                                      n::rocblas_int, x::Ptr{Cvoid},
+                                                      x_type::rocblas_datatype,
+                                                      incx::rocblas_int,
+                                                      stride_x::rocblas_stride,
+                                                      y::Ptr{Cvoid},
+                                                      y_type::rocblas_datatype,
+                                                      incy::rocblas_int,
+                                                      stride_y::rocblas_stride,
+                                                      batch_count::rocblas_int,
+                                                      result::Ptr{Cvoid},
+                                                      result_type::rocblas_datatype,
+                                                      execution_type::rocblas_datatype)::rocblas_status
 end
 
 function rocblas_nrm2_ex(handle, n, x, x_type, incx, results, result_type, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_nrm2_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, results, result_type, execution_type)
+    @ccall librocblas.rocblas_nrm2_ex(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cvoid},
+                                      x_type::rocblas_datatype, incx::rocblas_int,
+                                      results::Ptr{Cvoid}, result_type::rocblas_datatype,
+                                      execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_nrm2_batched_ex(handle, n, x, x_type, incx, batch_count, results, result_type, execution_type)
+function rocblas_nrm2_batched_ex(handle, n, x, x_type, incx, batch_count, results,
+                                 result_type, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_nrm2_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, batch_count, results, result_type, execution_type)
+    @ccall librocblas.rocblas_nrm2_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                              x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                              incx::rocblas_int, batch_count::rocblas_int,
+                                              results::Ptr{Cvoid},
+                                              result_type::rocblas_datatype,
+                                              execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_nrm2_strided_batched_ex(handle, n, x, x_type, incx, stride_x, batch_count, results, result_type, execution_type)
+function rocblas_nrm2_strided_batched_ex(handle, n, x, x_type, incx, stride_x, batch_count,
+                                         results, result_type, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_nrm2_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, stride_x, batch_count, results, result_type, execution_type)
+    @ccall librocblas.rocblas_nrm2_strided_batched_ex(handle::rocblas_handle,
+                                                      n::rocblas_int, x::Ptr{Cvoid},
+                                                      x_type::rocblas_datatype,
+                                                      incx::rocblas_int,
+                                                      stride_x::rocblas_stride,
+                                                      batch_count::rocblas_int,
+                                                      results::Ptr{Cvoid},
+                                                      result_type::rocblas_datatype,
+                                                      execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_rot_ex(handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type, execution_type)
+function rocblas_rot_ex(handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type,
+                        execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_rot_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type, execution_type)
+    @ccall librocblas.rocblas_rot_ex(handle::rocblas_handle, n::rocblas_int, x::Ptr{Cvoid},
+                                     x_type::rocblas_datatype, incx::rocblas_int,
+                                     y::Ptr{Cvoid}, y_type::rocblas_datatype,
+                                     incy::rocblas_int, c::Ptr{Cvoid}, s::Ptr{Cvoid},
+                                     cs_type::rocblas_datatype,
+                                     execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_rot_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type, batch_count, execution_type)
+function rocblas_rot_batched_ex(handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type,
+                                batch_count, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_rot_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_datatype), handle, n, x, x_type, incx, y, y_type, incy, c, s, cs_type, batch_count, execution_type)
+    @ccall librocblas.rocblas_rot_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                             x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                             incx::rocblas_int, y::Ptr{Cvoid},
+                                             y_type::rocblas_datatype, incy::rocblas_int,
+                                             c::Ptr{Cvoid}, s::Ptr{Cvoid},
+                                             cs_type::rocblas_datatype,
+                                             batch_count::rocblas_int,
+                                             execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_rot_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, c, s, cs_type, batch_count, execution_type)
+function rocblas_rot_strided_batched_ex(handle, n, x, x_type, incx, stride_x, y, y_type,
+                                        incy, stride_y, c, s, cs_type, batch_count,
+                                        execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_rot_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, Ptr{Cvoid}, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_datatype), handle, n, x, x_type, incx, stride_x, y, y_type, incy, stride_y, c, s, cs_type, batch_count, execution_type)
+    @ccall librocblas.rocblas_rot_strided_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                                     x::Ptr{Cvoid},
+                                                     x_type::rocblas_datatype,
+                                                     incx::rocblas_int,
+                                                     stride_x::rocblas_stride,
+                                                     y::Ptr{Cvoid},
+                                                     y_type::rocblas_datatype,
+                                                     incy::rocblas_int,
+                                                     stride_y::rocblas_stride,
+                                                     c::Ptr{Cvoid}, s::Ptr{Cvoid},
+                                                     cs_type::rocblas_datatype,
+                                                     batch_count::rocblas_int,
+                                                     execution_type::rocblas_datatype)::rocblas_status
 end
 
 function rocblas_scal_ex(handle, n, alpha, alpha_type, x, x_type, incx, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scal_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, execution_type)
+    @ccall librocblas.rocblas_scal_ex(handle::rocblas_handle, n::rocblas_int,
+                                      alpha::Ptr{Cvoid}, alpha_type::rocblas_datatype,
+                                      x::Ptr{Cvoid}, x_type::rocblas_datatype,
+                                      incx::rocblas_int,
+                                      execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_scal_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, batch_count, execution_type)
+function rocblas_scal_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, batch_count,
+                                 execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scal_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, batch_count, execution_type)
+    @ccall librocblas.rocblas_scal_batched_ex(handle::rocblas_handle, n::rocblas_int,
+                                              alpha::Ptr{Cvoid},
+                                              alpha_type::rocblas_datatype, x::Ptr{Cvoid},
+                                              x_type::rocblas_datatype, incx::rocblas_int,
+                                              batch_count::rocblas_int,
+                                              execution_type::rocblas_datatype)::rocblas_status
 end
 
-function rocblas_scal_strided_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx, stridex, batch_count, execution_type)
+function rocblas_scal_strided_batched_ex(handle, n, alpha, alpha_type, x, x_type, incx,
+                                         stridex, batch_count, execution_type)
     AMDGPU.prepare_state()
-    ccall((:rocblas_scal_strided_batched_ex, librocblas), rocblas_status, (rocblas_handle, rocblas_int, Ptr{Cvoid}, rocblas_datatype, Ptr{Cvoid}, rocblas_datatype, rocblas_int, rocblas_stride, rocblas_int, rocblas_datatype), handle, n, alpha, alpha_type, x, x_type, incx, stridex, batch_count, execution_type)
+    @ccall librocblas.rocblas_scal_strided_batched_ex(handle::rocblas_handle,
+                                                      n::rocblas_int, alpha::Ptr{Cvoid},
+                                                      alpha_type::rocblas_datatype,
+                                                      x::Ptr{Cvoid},
+                                                      x_type::rocblas_datatype,
+                                                      incx::rocblas_int,
+                                                      stridex::rocblas_stride,
+                                                      batch_count::rocblas_int,
+                                                      execution_type::rocblas_datatype)::rocblas_status
 end
 
 function rocblas_status_to_string(status)
     AMDGPU.prepare_state()
-    ccall((:rocblas_status_to_string, librocblas), Ptr{Cchar}, (rocblas_status,), status)
+    @ccall librocblas.rocblas_status_to_string(status::rocblas_status)::Ptr{Cchar}
 end
 
 function rocblas_initialize()
     AMDGPU.prepare_state()
-    ccall((:rocblas_initialize, librocblas), Cvoid, ())
+    @ccall librocblas.rocblas_initialize()::Cvoid
 end
 
 function rocblas_get_version_string(buf, len)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_version_string, librocblas), rocblas_status, (Ptr{Cchar}, Csize_t), buf, len)
+    @ccall librocblas.rocblas_get_version_string(buf::Ptr{Cchar},
+                                                 len::Csize_t)::rocblas_status
 end
 
 function rocblas_get_version_string_size(len)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_version_string_size, librocblas), rocblas_status, (Ptr{Csize_t},), len)
+    @ccall librocblas.rocblas_get_version_string_size(len::Ptr{Csize_t})::rocblas_status
 end
 
 function rocblas_start_device_memory_size_query(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_start_device_memory_size_query, librocblas), rocblas_status, (rocblas_handle,), handle)
+    @ccall librocblas.rocblas_start_device_memory_size_query(handle::rocblas_handle)::rocblas_status
 end
 
 function rocblas_stop_device_memory_size_query(handle, size)
     AMDGPU.prepare_state()
-    ccall((:rocblas_stop_device_memory_size_query, librocblas), rocblas_status, (rocblas_handle, Ptr{Csize_t}), handle, size)
+    @ccall librocblas.rocblas_stop_device_memory_size_query(handle::rocblas_handle,
+                                                            size::Ptr{Csize_t})::rocblas_status
 end
 
 function rocblas_is_device_memory_size_query(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_is_device_memory_size_query, librocblas), Bool, (rocblas_handle,), handle)
+    @ccall librocblas.rocblas_is_device_memory_size_query(handle::rocblas_handle)::Bool
 end
 
 function rocblas_device_malloc_success(ptr)
     AMDGPU.prepare_state()
-    ccall((:rocblas_device_malloc_success, librocblas), Bool, (Ptr{rocblas_device_malloc_base},), ptr)
+    @ccall librocblas.rocblas_device_malloc_success(ptr::Ptr{rocblas_device_malloc_base})::Bool
 end
 
 function rocblas_device_malloc_ptr(ptr, res)
     AMDGPU.prepare_state()
-    ccall((:rocblas_device_malloc_ptr, librocblas), rocblas_status, (Ptr{rocblas_device_malloc_base}, Ptr{Ptr{Cvoid}}), ptr, res)
+    @ccall librocblas.rocblas_device_malloc_ptr(ptr::Ptr{rocblas_device_malloc_base},
+                                                res::Ptr{Ptr{Cvoid}})::rocblas_status
 end
 
 function rocblas_device_malloc_get(ptr, index, res)
     AMDGPU.prepare_state()
-    ccall((:rocblas_device_malloc_get, librocblas), rocblas_status, (Ptr{rocblas_device_malloc_base}, Csize_t, Ptr{Ptr{Cvoid}}), ptr, index, res)
+    @ccall librocblas.rocblas_device_malloc_get(ptr::Ptr{rocblas_device_malloc_base},
+                                                index::Csize_t,
+                                                res::Ptr{Ptr{Cvoid}})::rocblas_status
 end
 
 function rocblas_device_malloc_free(ptr)
     AMDGPU.prepare_state()
-    ccall((:rocblas_device_malloc_free, librocblas), rocblas_status, (Ptr{rocblas_device_malloc_base},), ptr)
+    @ccall librocblas.rocblas_device_malloc_free(ptr::Ptr{rocblas_device_malloc_base})::rocblas_status
 end
 
 function rocblas_device_malloc_set_default_memory_size(size)
     AMDGPU.prepare_state()
-    ccall((:rocblas_device_malloc_set_default_memory_size, librocblas), Cvoid, (Csize_t,), size)
+    @ccall librocblas.rocblas_device_malloc_set_default_memory_size(size::Csize_t)::Cvoid
 end
 
 function rocblas_get_device_memory_size(handle, size)
     AMDGPU.prepare_state()
-    ccall((:rocblas_get_device_memory_size, librocblas), rocblas_status, (rocblas_handle, Ptr{Csize_t}), handle, size)
+    @ccall librocblas.rocblas_get_device_memory_size(handle::rocblas_handle,
+                                                     size::Ptr{Csize_t})::rocblas_status
 end
 
 function rocblas_set_device_memory_size(handle, size)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_device_memory_size, librocblas), rocblas_status, (rocblas_handle, Csize_t), handle, size)
+    @ccall librocblas.rocblas_set_device_memory_size(handle::rocblas_handle,
+                                                     size::Csize_t)::rocblas_status
 end
 
 function rocblas_set_workspace(handle, addr, size)
     AMDGPU.prepare_state()
-    ccall((:rocblas_set_workspace, librocblas), rocblas_status, (rocblas_handle, Ptr{Cvoid}, Csize_t), handle, addr, size)
+    @ccall librocblas.rocblas_set_workspace(handle::rocblas_handle, addr::Ptr{Cvoid},
+                                            size::Csize_t)::rocblas_status
 end
 
 function rocblas_is_managing_device_memory(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_is_managing_device_memory, librocblas), Bool, (rocblas_handle,), handle)
+    @ccall librocblas.rocblas_is_managing_device_memory(handle::rocblas_handle)::Bool
 end
 
 function rocblas_is_user_managing_device_memory(handle)
     AMDGPU.prepare_state()
-    ccall((:rocblas_is_user_managing_device_memory, librocblas), Bool, (rocblas_handle,), handle)
+    @ccall librocblas.rocblas_is_user_managing_device_memory(handle::rocblas_handle)::Bool
 end
 
 function rocblas_abort()
     AMDGPU.prepare_state()
-    ccall((:rocblas_abort, librocblas), Cvoid, ())
+    @ccall librocblas.rocblas_abort()::Cvoid
 end
diff --git a/src/solver/rocSOLVER.jl b/src/solver/rocSOLVER.jl
index 1de5f85fc..089d8d224 100644
--- a/src/solver/rocSOLVER.jl
+++ b/src/solver/rocSOLVER.jl
@@ -10,7 +10,10 @@ import AMDGPU: librocsolver
 import AMDGPU: HIP, rocBLAS
 import AMDGPU: HandleCache, library_state, check
 import .HIP: HIPContext, HIPStream, hipContext_t, hipStream_t, hipEvent_t
-import .rocBLAS: device_batch, rocblas_status, rocblas_handle, rocblas_side, rocblas_operation, rocblas_fill, rocblas_stride, rocblas_svect, rocblas_evect
+import .rocBLAS: device_batch, rocblas_status, rocblas_handle, rocblas_side
+import .rocBLAS: rocblas_half, rocblas_operation, rocblas_fill, rocblas_stride
+import .rocBLAS: rocblas_int, rocblas_float_complex, rocblas_double_complex
+import .rocBLAS: rocblas_float, rocblas_diagonal, rocblas_layer_mode
 
 include("librocsolver.jl")
 include("highlevel.jl")