diff --git a/src/blas.jl b/src/blas.jl index 71e28e01..e77a5c78 100644 --- a/src/blas.jl +++ b/src/blas.jl @@ -86,6 +86,7 @@ export using ..LinearAlgebra: libblastrampoline, BlasReal, BlasComplex, BlasFloat, BlasInt, DimensionMismatch, checksquare, chkstride1 +include("libblas.jl") include("lbt.jl") # Legacy bindings that some packages (such as NNlib.jl) use. @@ -207,16 +208,14 @@ Copy `n` elements of array `X` with stride `incx` to array `Y` with stride `incy """ function blascopy! end -for (fname, elty) in ((:dcopy_,:Float64), - (:scopy_,:Float32), - (:zcopy_,:ComplexF64), - (:ccopy_,:ComplexF32)) +for (fname, elty) in ((:dcopy,:Float64), + (:scopy,:Float32), + (:zcopy,:ComplexF64), + (:ccopy,:ComplexF32)) @eval begin # SUBROUTINE DCOPY(N,DX,INCX,DY,INCY) function blascopy!(n::Integer, DX::Union{Ptr{$elty},AbstractArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},AbstractArray{$elty}}, incy::Integer) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - n, DX, incx, DY, incy) + $fname(n, DX, incx, DY, incy) DY end end @@ -236,18 +235,16 @@ first `n` elements of array `Y` with stride `incy`. Returns `X` and `Y`. """ function rot! end -for (fname, elty, cty, sty, lib) in ((:drot_, :Float64, :Float64, :Float64, libblastrampoline), - (:srot_, :Float32, :Float32, :Float32, libblastrampoline), - (:zdrot_, :ComplexF64, :Float64, :Float64, libblastrampoline), - (:csrot_, :ComplexF32, :Float32, :Float32, libblastrampoline), - (:zrot_, :ComplexF64, :Float64, :ComplexF64, libblastrampoline), - (:crot_, :ComplexF32, :Float32, :ComplexF32, libblastrampoline)) +for (fname, elty, cty, sty) in ((:drot, :Float64, :Float64, :Float64), + (:srot, :Float32, :Float32, :Float32), + (:zdrot, :ComplexF64, :Float64, :Float64), + (:csrot, :ComplexF32, :Float32, :Float32), + (:zrot, :ComplexF64, :Float64, :ComplexF64), + (:crot, :ComplexF32, :Float32, :ComplexF32)) @eval begin # SUBROUTINE DROT(N,DX,INCX,DY,INCY,C,S) function rot!(n::Integer, DX::Union{Ptr{$elty},AbstractArray{$elty}}, incx::Integer, DY::Union{Ptr{$elty},AbstractArray{$elty}}, incy::Integer, C::$cty, S::$sty) - ccall((@blasfunc($fname), $lib), Cvoid, - (Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ref{$cty}, Ref{$sty}), - n, DX, incx, DY, incy, C, S) + $fname(n, DX, incx, DY, incy, C, S) DX, DY end end @@ -275,16 +272,14 @@ If `n` and `incx` are not provided, `length(X)` and `stride(X,1)` are used. """ function scal end -for (fname, elty) in ((:dscal_,:Float64), - (:sscal_,:Float32), - (:zscal_,:ComplexF64), - (:cscal_,:ComplexF32)) +for (fname, elty) in ((:dscal,:Float64), + (:sscal,:Float32), + (:zscal,:ComplexF64), + (:cscal,:ComplexF32)) @eval begin # SUBROUTINE DSCAL(N,DA,DX,INCX) function scal!(n::Integer, DA::$elty, DX::Union{Ptr{$elty},AbstractArray{$elty}}, incx::Integer) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}), - n, DA, DX, incx) + $fname(n, DA, DX, incx) DX end @@ -396,14 +391,17 @@ for (fname, elty) in ((:cblas_zdotu_sub,:ComplexF64), end end -for (elty, f) in ((Float32, :dot), (Float64, :dot), - (ComplexF32, :dotc), (ComplexF64, :dotc), - (ComplexF32, :dotu), (ComplexF64, :dotu)) +for (elty, fname) in ((Float32, :dot), + (Float64, :dot), + (ComplexF32, :dotc), + (ComplexF64, :dotc), + (ComplexF32, :dotu), + (ComplexF64, :dotu)) @eval begin - function $f(x::AbstractArray{$elty}, y::AbstractArray{$elty}) + function $fname(x::AbstractArray{$elty}, y::AbstractArray{$elty}) n, m = length(x), length(y) n == m || throw(DimensionMismatch(lazy"dot product arguments have lengths $n and $m")) - GC.@preserve x y $f(n, vec_pointer_stride(x)..., vec_pointer_stride(y)...) + GC.@preserve x y $fname(n, vec_pointer_stride(x)..., vec_pointer_stride(y)...) end end end @@ -426,16 +424,14 @@ julia> BLAS.nrm2(1, fill(1.0, 8), 2) """ function nrm2 end -for (fname, elty, ret_type) in ((:dnrm2_,:Float64,:Float64), - (:snrm2_,:Float32,:Float32), - (:dznrm2_,:ComplexF64,:Float64), - (:scnrm2_,:ComplexF32,:Float32)) +for (fname, elty, ret_type) in ((:dnrm2,:Float64,:Float64), + (:snrm2,:Float32,:Float32), + (:dznrm2,:ComplexF64,:Float64), + (:scnrm2,:ComplexF32,:Float32)) @eval begin # SUBROUTINE DNRM2(N,X,INCX) function nrm2(n::Integer, X::Union{Ptr{$elty},AbstractArray{$elty}}, incx::Integer) - ccall((@blasfunc($fname), libblastrampoline), $ret_type, - (Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - n, X, incx) + $fname(n, X, incx) end end end @@ -467,16 +463,14 @@ julia> BLAS.asum(2, fill(1.0im, 10), 5) """ function asum end -for (fname, elty, ret_type) in ((:dasum_,:Float64,:Float64), - (:sasum_,:Float32,:Float32), - (:dzasum_,:ComplexF64,:Float64), - (:scasum_,:ComplexF32,:Float32)) +for (fname, elty, ret_type) in ((:dasum,:Float64,:Float64), + (:sasum,:Float32,:Float32), + (:dzasum,:ComplexF64,:Float64), + (:scasum,:ComplexF32,:Float32)) @eval begin # SUBROUTINE ASUM(N, X, INCX) function asum(n::Integer, X::Union{Ptr{$elty},AbstractArray{$elty}}, incx::Integer) - ccall((@blasfunc($fname), libblastrampoline), $ret_type, - (Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - n, X, incx) + $fname(n, X, incx) end end end @@ -505,10 +499,10 @@ julia> BLAS.axpy!(2, x, y) """ function axpy! end -for (fname, elty) in ((:daxpy_,:Float64), - (:saxpy_,:Float32), - (:zaxpy_,:ComplexF64), - (:caxpy_,:ComplexF32)) +for (fname, elty) in ((:daxpy,:Float64), + (:saxpy,:Float32), + (:zaxpy,:ComplexF64), + (:caxpy,:ComplexF32)) @eval begin # SUBROUTINE DAXPY(N,DA,DX,INCX,DY,INCY) # DY <- DA*DX + DY @@ -518,9 +512,7 @@ for (fname, elty) in ((:daxpy_,:Float64), #* .. Array Arguments .. # DOUBLE PRECISION DX(*),DY(*) function axpy!(n::Integer, alpha::($elty), dx::Union{Ptr{$elty}, AbstractArray{$elty}}, incx::Integer, dy::Union{Ptr{$elty}, AbstractArray{$elty}}, incy::Integer) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - n, alpha, dx, incx, dy, incy) + $fname(n, alpha, dx, incx, dy, incy) dy end end @@ -577,8 +569,10 @@ julia> BLAS.axpby!(2., x, 3., y) """ function axpby! end -for (fname, elty) in ((:daxpby_,:Float64), (:saxpby_,:Float32), - (:zaxpby_,:ComplexF64), (:caxpby_,:ComplexF32)) +for (fname, elty) in ((:daxpby,:Float64), + (:saxpby,:Float32), + (:zaxpby,:ComplexF64), + (:caxpby,:ComplexF32)) @eval begin # SUBROUTINE DAXPBY(N,DA,DX,INCX,DB,DY,INCY) # DY <- DA*DX + DB*DY @@ -590,9 +584,7 @@ for (fname, elty) in ((:daxpby_,:Float64), (:saxpby_,:Float32), function axpby!(n::Integer, alpha::($elty), dx::Union{Ptr{$elty}, AbstractArray{$elty}}, incx::Integer, beta::($elty), dy::Union{Ptr{$elty}, AbstractArray{$elty}}, incy::Integer) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, (Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}), - n, alpha, dx, incx, beta, dy, incy) + $fname(n, alpha, dx, incx, beta, dy, incy) dy end end @@ -609,15 +601,13 @@ function axpby!(alpha::Number, x::AbstractArray{T}, beta::Number, y::AbstractArr end ## iamax -for (fname, elty) in ((:idamax_,:Float64), - (:isamax_,:Float32), - (:izamax_,:ComplexF64), - (:icamax_,:ComplexF32)) +for (fname, elty) in ((:idamax,:Float64), + (:isamax,:Float32), + (:izamax,:ComplexF64), + (:icamax,:ComplexF32)) @eval begin function iamax(n::Integer, dx::Union{Ptr{$elty}, AbstractArray{$elty}}, incx::Integer) - ccall((@blasfunc($fname), libblastrampoline),BlasInt, - (Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - n, dx, incx) + $fname(n, dx, incx) end end end @@ -639,10 +629,10 @@ iamax # Level 2 ## mv ### gemv -for (fname, elty) in ((:dgemv_,:Float64), - (:sgemv_,:Float32), - (:zgemv_,:ComplexF64), - (:cgemv_,:ComplexF32)) +for (fname, elty) in ((:dgemv,:Float64), + (:sgemv,:Float32), + (:zgemv,:ComplexF64), + (:cgemv,:ComplexF32)) @eval begin #SUBROUTINE DGEMV(TRANS,M,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY) #* .. Scalar Arguments .. @@ -675,13 +665,7 @@ for (fname, elty) in ((:dgemv_,:Float64), end lda >= size(A,1) || size(A,2) <= 1 || error("when `size(A,2) > 1`, `abs(stride(A,2))` must be at least `size(A,1)`") lda = max(1, size(A,1), lda) - GC.@preserve A X Y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Clong), - trans, size(A,1), size(A,2), alpha, - pA, lda, pX, sX, - beta, pY, sY, 1) + GC.@preserve A X Y $fname(trans, size(A,1), size(A,2), alpha, pA, lda, pX, sX, beta, pY, sY) Y end function gemv(trans::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, X::AbstractVector{$elty}) @@ -737,10 +721,10 @@ super-diagonals, and `alpha` is a scalar. """ function gbmv end -for (fname, elty) in ((:dgbmv_,:Float64), - (:sgbmv_,:Float32), - (:zgbmv_,:ComplexF64), - (:cgbmv_,:ComplexF32)) +for (fname, elty) in ((:dgbmv,:Float64), + (:sgbmv,:Float32), + (:zgbmv,:ComplexF64), + (:cgbmv,:ComplexF32)) @eval begin # SUBROUTINE DGBMV(TRANS,M,N,KL,KU,ALPHA,A,LDA,X,INCX,BETA,Y,INCY) # * .. Scalar Arguments .. @@ -757,14 +741,7 @@ for (fname, elty) in ((:dgbmv_,:Float64), chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("dest vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, - Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Clong), - trans, m, size(A,2), kl, - ku, alpha, A, max(1,stride(A,2)), - px, stx, beta, py, sty, 1) + GC.@preserve x y $fname(trans, m, size(A,2), kl, ku, alpha, A, max(1,stride(A,2)), px, stx, beta, py, sty) y end function gbmv(trans::AbstractChar, m::Integer, kl::Integer, ku::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -789,10 +766,10 @@ Only the [`ul`](@ref stdlib-blas-uplo) triangle of `A` is used. """ function symv! end -for (fname, elty, lib) in ((:dsymv_,:Float64,libblastrampoline), - (:ssymv_,:Float32,libblastrampoline), - (:zsymv_,:ComplexF64,libblastrampoline), - (:csymv_,:ComplexF32,libblastrampoline)) +for (fname, elty) in ((:dsymv,:Float64), + (:ssymv,:Float32), + (:zsymv,:ComplexF64), + (:csymv,:ComplexF32)) # Note that the complex symv are not BLAS but auiliary functions in LAPACK @eval begin # SUBROUTINE DSYMV(UPLO,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY) @@ -820,13 +797,7 @@ for (fname, elty, lib) in ((:dsymv_,:Float64,libblastrampoline), chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("dest vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), $lib), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Clong), - uplo, n, alpha, A, - max(1,stride(A,2)), px, stx, beta, - py, sty, 1) + GC.@preserve x y $fname(uplo, n, alpha, A, max(1,stride(A,2)), px, stx, beta, py, sty) y end function symv(uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -865,8 +836,8 @@ Only the [`ul`](@ref stdlib-blas-uplo) triangle of `A` is used. """ function hemv! end -for (fname, elty) in ((:zhemv_,:ComplexF64), - (:chemv_,:ComplexF32)) +for (fname, elty) in ((:zhemv,:ComplexF64), + (:chemv,:ComplexF32)) @eval begin function hemv!(uplo::AbstractChar, α::Union{$elty, Bool}, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, β::Union{$elty, Bool}, y::AbstractVector{$elty}) chkuplo(uplo) @@ -885,13 +856,7 @@ for (fname, elty) in ((:zhemv_,:ComplexF64), lda = max(1, stride(A, 2)) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("dest vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Clong), - uplo, n, α, A, - lda, px, stx, β, - py, sty, 1) + GC.@preserve x y $fname(uplo, n, α, A, lda, px, stx, β, py, sty) y end function hemv(uplo::AbstractChar, α::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -921,8 +886,8 @@ Only the [`ul`](@ref stdlib-blas-uplo) triangle of `A` is used. hemv(ul, A, x) ### hpmv!, (HP) Hermitian packed matrix-vector operation defined as y := alpha*A*x + beta*y. -for (fname, elty) in ((:zhpmv_, :ComplexF64), - (:chpmv_, :ComplexF32)) +for (fname, elty) in ((:zhpmv, :ComplexF64), + (:chpmv, :ComplexF32)) @eval begin # SUBROUTINE ZHPMV(UPLO,N,ALPHA,AP,X,INCX,BETA,Y,INCY) # Y <- ALPHA*AP*X + BETA*Y @@ -942,27 +907,7 @@ for (fname, elty) in ((:zhpmv_, :ComplexF64), y::Union{Ptr{$elty}, AbstractArray{$elty}}, incy::Integer) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, # uplo, - Ref{BlasInt}, # n, - Ref{$elty}, # α, - Ptr{$elty}, # AP, - Ptr{$elty}, # x, - Ref{BlasInt}, # incx, - Ref{$elty}, # β, - Ptr{$elty}, # y, output - Ref{BlasInt}, # incy - Clong), # length of uplo - uplo, - n, - α, - AP, - x, - incx, - β, - y, - incy, - 1) + $fname(uplo, n, α, AP, x, incx, β, y, incy) return y end end @@ -1014,8 +959,8 @@ Return the updated `y`. hpmv! ### sbmv, (SB) symmetric banded matrix-vector multiplication -for (fname, elty) in ((:dsbmv_,:Float64), - (:ssbmv_,:Float32)) +for (fname, elty) in ((:dsbmv,:Float64), + (:ssbmv,:Float32)) @eval begin # SUBROUTINE DSBMV(UPLO,N,K,ALPHA,A,LDA,X,INCX,BETA,Y,INCY) # * .. Scalar Arguments .. @@ -1030,13 +975,9 @@ for (fname, elty) in ((:dsbmv_,:Float64), chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("dest vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Clong), - uplo, size(A,2), k, alpha, - A, max(1,stride(A,2)), px, stx, - beta, py, sty, 1) + GC.@preserve x y $fname(uplo, size(A,2), k, alpha, + A, max(1,stride(A,2)), px, stx, + beta, py, sty) y end function sbmv(uplo::AbstractChar, k::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -1081,8 +1022,8 @@ Return the updated `y`. sbmv! ### spmv!, (SP) symmetric packed matrix-vector operation defined as y := alpha*A*x + beta*y. -for (fname, elty) in ((:dspmv_, :Float64), - (:sspmv_, :Float32)) +for (fname, elty) in ((:dspmv, :Float64), + (:sspmv, :Float32)) @eval begin # SUBROUTINE DSPMV(UPLO,N,ALPHA,AP,X,INCX,BETA,Y,INCY) # Y <- ALPHA*AP*X + BETA*Y @@ -1101,28 +1042,7 @@ for (fname, elty) in ((:dspmv_, :Float64), β::$elty, y::Union{Ptr{$elty}, AbstractArray{$elty}}, incy::Integer) - - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, # uplo, - Ref{BlasInt}, # n, - Ref{$elty}, # α, - Ptr{$elty}, # AP, - Ptr{$elty}, # x, - Ref{BlasInt}, # incx, - Ref{$elty}, # β, - Ptr{$elty}, # y, out - Ref{BlasInt}, # incy - Clong), # length of uplo - uplo, - n, - α, - AP, - x, - incx, - β, - y, - incy, - 1) + $fname(uplo, n, α, AP, x, incx, β, y, incy) return y end end @@ -1174,8 +1094,8 @@ Return the updated `y`. spmv! ### spr!, (SP) symmetric packed matrix-vector operation defined as A := alpha*x*x' + A -for (fname, elty) in ((:dspr_, :Float64), - (:sspr_, :Float32)) +for (fname, elty) in ((:dspr, :Float64), + (:sspr, :Float32)) @eval begin function spr!(uplo::AbstractChar, n::Integer, @@ -1183,22 +1103,7 @@ for (fname, elty) in ((:dspr_, :Float64), x::Union{Ptr{$elty}, AbstractArray{$elty}}, incx::Integer, AP::Union{Ptr{$elty}, AbstractArray{$elty}}) - - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, # uplo, - Ref{BlasInt}, # n, - Ref{$elty}, # α, - Ptr{$elty}, # x, - Ref{BlasInt}, # incx, - Ptr{$elty}, # AP, - Clong), # length of uplo - uplo, - n, - α, - x, - incx, - AP, - 1) + $fname(uplo, n, α, x, incx, AP) return AP end end @@ -1245,8 +1150,8 @@ Return the updated `AP`. spr! ### hbmv, (HB) Hermitian banded matrix-vector multiplication -for (fname, elty) in ((:zhbmv_,:ComplexF64), - (:chbmv_,:ComplexF32)) +for (fname, elty) in ((:zhbmv,:ComplexF64), + (:chbmv,:ComplexF32)) @eval begin # SUBROUTINE ZHBMV(UPLO,N,K,ALPHA,A,LDA,X,INCX,BETA,Y,INCY) # * .. Scalar Arguments .. @@ -1261,13 +1166,9 @@ for (fname, elty) in ((:zhbmv_,:ComplexF64), chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("dest vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Clong), - uplo, size(A,2), k, alpha, - A, max(1,stride(A,2)), px, stx, - beta, py, sty, 1) + $fname(uplo, size(A,2), k, alpha, + A, max(1,stride(A,2)), px, stx, + beta, py, sty) y end function hbmv(uplo::AbstractChar, k::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -1303,10 +1204,10 @@ The multiplication occurs in-place on `b`. """ function trmv! end -for (fname, elty) in ((:dtrmv_,:Float64), - (:strmv_,:Float32), - (:ztrmv_,:ComplexF64), - (:ctrmv_,:ComplexF32)) +for (fname, elty) in ((:dtrmv,:Float64), + (:strmv,:Float32), + (:ztrmv,:ComplexF64), + (:ctrmv,:ComplexF32)) @eval begin # SUBROUTINE DTRMV(UPLO,TRANS,DIAG,N,A,LDA,X,INCX) # * .. Scalar Arguments .. @@ -1323,12 +1224,7 @@ for (fname, elty) in ((:dtrmv_,:Float64), end chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, - Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong, Clong), - uplo, trans, diag, n, - A, max(1,stride(A,2)), px, stx, 1, 1, 1) + GC.@preserve x $fname(uplo, trans, diag, n, A, max(1,stride(A,2)), px, stx) x end function trmv(uplo::AbstractChar, trans::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -1360,10 +1256,10 @@ are assumed to be all ones. """ function trsv end -for (fname, elty) in ((:dtrsv_,:Float64), - (:strsv_,:Float32), - (:ztrsv_,:ComplexF64), - (:ctrsv_,:ComplexF32)) +for (fname, elty) in ((:dtrsv,:Float64), + (:strsv,:Float32), + (:ztrsv,:ComplexF64), + (:ctrsv,:ComplexF32)) @eval begin # SUBROUTINE DTRSV(UPLO,TRANS,DIAG,N,A,LDA,X,INCX) # .. Scalar Arguments .. @@ -1380,12 +1276,7 @@ for (fname, elty) in ((:dtrsv_,:Float64), end chkstride1(A) px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, - Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong, Clong), - uplo, trans, diag, n, - A, max(1,stride(A,2)), px, stx, 1, 1, 1) + $fname(uplo, trans, diag, n, A, max(1,stride(A,2)), px, stx) x end function trsv(uplo::AbstractChar, trans::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}) @@ -1403,10 +1294,10 @@ Rank-1 update of the matrix `A` with vectors `x` and `y` as `alpha*x*y' + A`. """ function ger! end -for (fname, elty) in ((:dger_,:Float64), - (:sger_,:Float32), - (:zgerc_,:ComplexF64), - (:cgerc_,:ComplexF32)) +for (fname, elty) in ((:dger,:Float64), + (:sger,:Float32), + (:zgerc,:ComplexF64), + (:cgerc,:ComplexF32)) @eval begin function ger!(α::$elty, x::AbstractVector{$elty}, y::AbstractVector{$elty}, A::AbstractMatrix{$elty}) require_one_based_indexing(A, x, y) @@ -1416,11 +1307,7 @@ for (fname, elty) in ((:dger_,:Float64), end px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, - Ref{BlasInt}), - m, n, α, px, stx, py, sty, A, max(1,stride(A,2))) + GC.@preserve x y $fname(m, n, α, px, stx, py, sty, A, max(1,stride(A,2))) A end end @@ -1435,7 +1322,8 @@ Rank-1 update of the matrix `A` with vectors `x` and `y` as `alpha*x*transpose(y """ function geru! end -for (fname, elty) in ((:zgeru_,:ComplexF64), (:cgeru_,:ComplexF32)) +for (fname, elty) in ((:zgeru,:ComplexF64), + (:cgeru,:ComplexF32)) @eval begin function geru!(α::$elty, x::AbstractVector{$elty}, y::AbstractVector{$elty}, A::AbstractMatrix{$elty}) require_one_based_indexing(A, x, y) @@ -1445,11 +1333,7 @@ for (fname, elty) in ((:zgeru_,:ComplexF64), (:cgeru_,:ComplexF32)) end px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) py, sty = vec_pointer_stride(y, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x y ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, - Ref{BlasInt}), - m, n, α, px, stx, py, sty, A, max(1,stride(A,2))) + GC.@preserve x y $fname(m, n, α, px, stx, py, sty, A, max(1,stride(A,2))) A end end @@ -1471,10 +1355,10 @@ Rank-1 update of the symmetric matrix `A` with vector `x` as `alpha*x*transpose( """ function syr! end -for (fname, elty, lib) in ((:dsyr_,:Float64,libblastrampoline), - (:ssyr_,:Float32,libblastrampoline), - (:zsyr_,:ComplexF64,libblastrampoline), - (:csyr_,:ComplexF32,libblastrampoline)) +for (fname, elty) in ((:dsyr,:Float64), + (:ssyr,:Float32), + (:zsyr,:ComplexF64), + (:csyr,:ComplexF32)) @eval begin function syr!(uplo::AbstractChar, α::$elty, x::AbstractVector{$elty}, A::AbstractMatrix{$elty}) chkuplo(uplo) @@ -1484,10 +1368,7 @@ for (fname, elty, lib) in ((:dsyr_,:Float64,libblastrampoline), throw(DimensionMismatch(lazy"A has size ($n,$n), x has length $(length(x))")) end px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x ccall((@blasfunc($fname), $lib), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}), - uplo, n, α, px, stx, A, max(1,stride(A, 2))) + GC.@preserve x $fname(uplo, n, α, px, stx, A, max(1,stride(A, 2))) A end end @@ -1504,8 +1385,8 @@ as `alpha*x*x' + A`. """ function her! end -for (fname, elty, relty) in ((:zher_,:ComplexF64, :Float64), - (:cher_,:ComplexF32, :Float32)) +for (fname, elty, relty) in ((:zher,:ComplexF64, :Float64), + (:cher,:ComplexF32, :Float32)) @eval begin function her!(uplo::AbstractChar, α::$relty, x::AbstractVector{$elty}, A::AbstractMatrix{$elty}) chkuplo(uplo) @@ -1515,10 +1396,7 @@ for (fname, elty, relty) in ((:zher_,:ComplexF64, :Float64), throw(DimensionMismatch(lazy"A has size ($n,$n), x has length $(length(x))")) end px, stx = vec_pointer_stride(x, ArgumentError("input vector with 0 stride is not allowed")) - GC.@preserve x ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{BlasInt}, Ref{$relty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Clong), - uplo, n, α, px, stx, A, max(1,stride(A,2)), 1) + GC.@preserve x $fname(uplo, n, α, px, stx, A, max(1,stride(A,2))) A end end @@ -1539,11 +1417,11 @@ Return the updated `C`. """ function gemmt! end -for (gemmt, elty) in - ((:dgemmt_,:Float64), - (:sgemmt_,:Float32), - (:zgemmt_,:ComplexF64), - (:cgemmt_,:ComplexF32)) +for (fname, elty) in + ((:dgemmt,:Float64), + (:sgemmt,:Float32), + (:zgemmt,:ComplexF64), + (:cgemmt,:ComplexF32)) @eval begin # SUBROUTINE DGEMMT(UPLO,TRANSA,TRANSB,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # * .. Scalar Arguments .. @@ -1569,15 +1447,8 @@ for (gemmt, elty) in chkstride1(A) chkstride1(B) chkstride1(C) - ccall((@blasfunc($gemmt), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, - Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Clong, Clong, Clong), - uplo, transA, transB, n, - ka, alpha, A, max(1,stride(A,2)), - B, max(1,stride(B,2)), beta, C, - max(1,stride(C,2)), 1, 1, 1) + $fname(uplo, transA, transB, n, ka, alpha, A, max(1,stride(A,2)), + B, max(1,stride(B,2)), beta, C, max(1,stride(C,2))) C end function gemmt(uplo::AbstractChar, transA::AbstractChar, transB::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}) @@ -1618,10 +1489,10 @@ Update `C` as `alpha*A*B + beta*C` or the other three variants according to function gemm! end for (gemm, elty) in - ((:dgemm_,:Float64), - (:sgemm_,:Float32), - (:zgemm_,:ComplexF64), - (:cgemm_,:ComplexF32)) + ((:dgemm,:Float64), + (:sgemm,:Float32), + (:zgemm,:ComplexF64), + (:cgemm,:ComplexF32)) @eval begin # SUBROUTINE DGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # * .. Scalar Arguments .. @@ -1649,15 +1520,10 @@ for (gemm, elty) in chkstride1(A) chkstride1(B) chkstride1(C) - ccall((@blasfunc($gemm), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, - Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Clong, Clong), - transA, transB, m, n, - ka, alpha, A, max(1,stride(A,2)), - B, max(1,stride(B,2)), beta, C, - max(1,stride(C,2)), 1, 1) + $fname(transA, transB, m, n, + ka, alpha, A, max(1,stride(A,2)), + B, max(1,stride(B,2)), beta, C, + max(1,stride(C,2))) C end function gemm(transA::AbstractChar, transB::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}) @@ -1685,10 +1551,10 @@ gemm(tA, tB, A, B) ## (SY) symmetric matrix-matrix and matrix-vector multiplication -for (mfname, elty) in ((:dsymm_,:Float64), - (:ssymm_,:Float32), - (:zsymm_,:ComplexF64), - (:csymm_,:ComplexF32)) +for (fname, elty) in ((:dsymm,:Float64), + (:ssymm,:Float32), + (:zsymm,:ComplexF64), + (:csymm,:ComplexF32)) @eval begin # SUBROUTINE DSYMM(SIDE,UPLO,M,N,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # .. Scalar Arguments .. @@ -1729,15 +1595,9 @@ for (mfname, elty) in ((:dsymm_,:Float64), chkstride1(A) chkstride1(B) chkstride1(C) - ccall((@blasfunc($mfname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong), - side, uplo, m, n, - alpha, A, max(1,stride(A,2)), B, - max(1,stride(B,2)), beta, C, max(1,stride(C,2)), - 1, 1) + $fname(side, uplo, m, n, + alpha, A, max(1,stride(A,2)), B, + max(1,stride(B,2)), beta, C, max(1,stride(C,2))) C end function symm(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}) @@ -1777,8 +1637,8 @@ Update `C` as `alpha*A*B + beta*C` or `alpha*B*A + beta*C` according to [`side`] symm! ## (HE) Hermitian matrix-matrix and matrix-vector multiplication -for (mfname, elty) in ((:zhemm_,:ComplexF64), - (:chemm_,:ComplexF32)) +for (mfname, elty) in ((:zhemm,:ComplexF64), + (:chemm,:ComplexF32)) @eval begin # SUBROUTINE DHEMM(SIDE,UPLO,M,N,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # .. Scalar Arguments .. @@ -1819,15 +1679,9 @@ for (mfname, elty) in ((:zhemm_,:ComplexF64), chkstride1(A) chkstride1(B) chkstride1(C) - ccall((@blasfunc($mfname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, - Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong), - side, uplo, m, n, - alpha, A, max(1,stride(A,2)), B, - max(1,stride(B,2)), beta, C, max(1,stride(C,2)), - 1, 1) + $mfname(side, uplo, m, n, + alpha, A, max(1,stride(A,2)), B, + max(1,stride(B,2)), beta, C, max(1,stride(C,2))) C end function hemm(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}) @@ -1886,10 +1740,10 @@ according to [`trans`](@ref stdlib-blas-trans). """ function syrk end -for (fname, elty) in ((:dsyrk_,:Float64), - (:ssyrk_,:Float32), - (:zsyrk_,:ComplexF64), - (:csyrk_,:ComplexF32)) +for (fname, elty) in ((:dsyrk,:Float64), + (:ssyrk,:Float32), + (:zsyrk,:ComplexF64), + (:csyrk,:ComplexF32)) @eval begin # SUBROUTINE DSYRK(UPLO,TRANS,N,K,ALPHA,A,LDA,BETA,C,LDC) # * .. Scalar Arguments .. @@ -1908,14 +1762,9 @@ for (fname, elty) in ((:dsyrk_,:Float64), if nn != n throw(DimensionMismatch(lazy"C has size ($n,$n), corresponding dimension of A is $nn")) end k = size(A, trans == 'N' ? 2 : 1) chkstride1(A) - chkstride1(C) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Clong, Clong), - uplo, trans, n, k, - alpha, A, max(1,stride(A,2)), beta, - C, max(1,stride(C,2)), 1, 1) + $fname(uplo, trans, n, k, + alpha, A, max(1,stride(A,2)), beta, + C, max(1,stride(C,2))) C end end @@ -1944,8 +1793,8 @@ triangle of `alpha*A*A'` or `alpha*A'*A`, according to [`trans`](@ref stdlib-bla """ function herk end -for (fname, elty, relty) in ((:zherk_, :ComplexF64, :Float64), - (:cherk_, :ComplexF32, :Float32)) +for (fname, elty, relty) in ((:zherk, :ComplexF64, :Float64), + (:cherk, :ComplexF32, :Float32)) @eval begin # SUBROUTINE CHERK(UPLO,TRANS,N,K,ALPHA,A,LDA,BETA,C,LDC) # * .. Scalar Arguments .. @@ -1968,13 +1817,9 @@ for (fname, elty, relty) in ((:zherk_, :ComplexF64, :Float64), chkstride1(A) chkstride1(C) k = size(A, trans == 'N' ? 2 : 1) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$relty}, Ptr{$elty}, Ref{BlasInt}, Ref{$relty}, - Ptr{$elty}, Ref{BlasInt}, Clong, Clong), - uplo, trans, n, k, - α, A, max(1,stride(A,2)), β, - C, max(1,stride(C,2)), 1, 1) + $fname(uplo, trans, n, k, + α, A, max(1,stride(A,2)), β, + C, max(1,stride(C,2))) C end function herk(uplo::AbstractChar, trans::AbstractChar, α::$relty, A::AbstractVecOrMat{$elty}) @@ -1986,10 +1831,10 @@ for (fname, elty, relty) in ((:zherk_, :ComplexF64, :Float64), end ## syr2k -for (fname, elty) in ((:dsyr2k_,:Float64), - (:ssyr2k_,:Float32), - (:zsyr2k_,:ComplexF64), - (:csyr2k_,:ComplexF32)) +for (fname, elty) in ((:dsyr2k,:Float64), + (:ssyr2k,:Float32), + (:zsyr2k,:ComplexF64), + (:csyr2k,:ComplexF32)) @eval begin # SUBROUTINE DSYR2K(UPLO,TRANS,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # @@ -2012,13 +1857,9 @@ for (fname, elty) in ((:dsyr2k_,:Float64), chkstride1(A) chkstride1(B) chkstride1(C) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ref{$elty}, - Ptr{$elty}, Ref{BlasInt}, Clong, Clong), - uplo, trans, n, k, - alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2)), beta, - C, max(1,stride(C,2)), 1, 1) + $fname(uplo, trans, n, k, + alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2)), beta, + C, max(1,stride(C,2))) C end end @@ -2056,7 +1897,8 @@ or `transpose(A)*B + transpose(B)*A`, according to [`trans`](@ref stdlib-blas-tr """ syr2k(uplo::AbstractChar, trans::AbstractChar, A::AbstractVecOrMat, B::AbstractVecOrMat) = syr2k(uplo, trans, one(eltype(A)), A, B) -for (fname, elty1, elty2) in ((:zher2k_,:ComplexF64,:Float64), (:cher2k_,:ComplexF32,:Float32)) +for (fname, elty1, elty2) in ((:zher2k,:ComplexF64,:Float64), + (:cher2k,:ComplexF32,:Float32)) @eval begin # SUBROUTINE CHER2K(UPLO,TRANS,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC) # @@ -2080,13 +1922,9 @@ for (fname, elty1, elty2) in ((:zher2k_,:ComplexF64,:Float64), (:cher2k_,:Comple chkstride1(B) chkstride1(C) k = size(A, trans == 'N' ? 2 : 1) - ccall((@blasfunc($fname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty1}, Ptr{$elty1}, Ref{BlasInt}, Ptr{$elty1}, Ref{BlasInt}, - Ref{$elty2}, Ptr{$elty1}, Ref{BlasInt}, Clong, Clong), - uplo, trans, n, k, - alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2)), - beta, C, max(1,stride(C,2)), 1, 1) + $fname(uplo, trans, n, k, + alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2)), + beta, C, max(1,stride(C,2))) C end function her2k(uplo::AbstractChar, trans::AbstractChar, alpha::($elty1), A::AbstractVecOrMat{$elty1}, B::AbstractVecOrMat{$elty1}) @@ -2173,10 +2011,10 @@ are assumed to be all ones. function trsm end for (mmname, smname, elty) in - ((:dtrmm_,:dtrsm_,:Float64), - (:strmm_,:strsm_,:Float32), - (:ztrmm_,:ztrsm_,:ComplexF64), - (:ctrmm_,:ctrsm_,:ComplexF32)) + ((:dtrmm,:dtrsm,:Float64), + (:strmm,:strsm,:Float32), + (:ztrmm,:ztrsm,:ComplexF64), + (:ctrmm,:ctrsm,:ComplexF32)) @eval begin # SUBROUTINE DTRMM(SIDE,UPLO,TRANSA,DIAG,M,N,ALPHA,A,LDA,B,LDB) # * .. Scalar Arguments .. @@ -2196,13 +2034,8 @@ for (mmname, smname, elty) in end chkstride1(A) chkstride1(B) - ccall((@blasfunc($mmname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, - Ref{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong, Clong, Clong), - side, uplo, transa, diag, m, n, - alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2)), - 1, 1, 1, 1) + $mmname(side, uplo, transa, diag, m, n, + alpha, A, max(1,stride(A,2)), B, max(1,stride(B,2))) B end function trmm(side::AbstractChar, uplo::AbstractChar, transa::AbstractChar, diag::AbstractChar, @@ -2227,15 +2060,9 @@ for (mmname, smname, elty) in end chkstride1(A) chkstride1(B) - ccall((@blasfunc($smname), libblastrampoline), Cvoid, - (Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, Ref{UInt8}, - Ref{BlasInt}, Ref{BlasInt}, Ref{$elty}, Ptr{$elty}, - Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, - Clong, Clong, Clong, Clong), - side, uplo, transa, diag, - m, n, alpha, A, - max(1,stride(A,2)), B, max(1,stride(B,2)), - 1, 1, 1, 1) + $smname(side, uplo, transa, diag, + m, n, alpha, A, + max(1,stride(A,2)), B, max(1,stride(B,2))) B end function trsm(side::AbstractChar, uplo::AbstractChar, transa::AbstractChar, diag::AbstractChar, alpha::$elty, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}) diff --git a/src/lapack.jl b/src/lapack.jl index 73393e44..313ed0f4 100644 --- a/src/lapack.jl +++ b/src/lapack.jl @@ -12,6 +12,7 @@ using ..LinearAlgebra: libblastrampoline, BlasFloat, BlasInt, LAPACKException, D using Base: iszero, require_one_based_indexing +include("liblapack.jl") # Legacy binding maintained for backwards-compatibility but new packages # should not look at this, instead preferring to parse the output diff --git a/src/libblas.jl b/src/libblas.jl new file mode 100644 index 00000000..fe3d9d9c --- /dev/null +++ b/src/libblas.jl @@ -0,0 +1,1186 @@ +# function cdotc(n, cx, incx, cy, incy) +# @ccall libblastrampoline.cdotc_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, +# incx::Ref{BlasInt}, +# cy::Ptr{ComplexF32}, incy::Ref{BlasInt})::ComplexF32 +# end + +# function cdotu(n, cx, incx, cy, incy) +# @ccall libblastrampoline.cdotu_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, +# incx::Ref{BlasInt}, +# cy::Ptr{ComplexF32}, incy::Ref{BlasInt})::ComplexF32 +# end + +# function zdotc(n, zx, incx, zy, incy) +# @ccall libblastrampoline.zdotc_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, +# incx::Ref{BlasInt}, +# zy::Ptr{ComplexF64}, incy::Ref{BlasInt})::ComplexF64 +# end + +# function zdotu(n, zx, incx, zy, incy) +# @ccall libblastrampoline.zdotu_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, +# incx::Ref{BlasInt}, +# zy::Ptr{ComplexF64}, incy::Ref{BlasInt})::ComplexF64 +# end + +function srotg(a, b, c, s) + @ccall libblastrampoline.srotg_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + s::Ref{Float32})::Cvoid +end + +function drotg(a, b, c, s) + @ccall libblastrampoline.drotg_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + s::Ref{Float64})::Cvoid +end + +function crotg(a, b, c, s) + @ccall libblastrampoline.crotg_(a::Ref{ComplexF32}, b::Ref{ComplexF32}, c::Ref{Float32}, + s::Ref{ComplexF32})::Cvoid +end + +function zrotg(a, b, c, s) + @ccall libblastrampoline.zrotg_(a::Ref{ComplexF64}, b::Ref{ComplexF64}, c::Ref{Float64}, + s::Ref{ComplexF64})::Cvoid +end + +function snrm2(n, x, incx) + @ccall libblastrampoline.snrm2_(n::Ref{BlasInt}, x::Ptr{Float32}, + incx::Ref{BlasInt})::Float32 +end + +function dnrm2(n, x, incx) + @ccall libblastrampoline.dnrm2_(n::Ref{BlasInt}, x::Ptr{Float64}, + incx::Ref{BlasInt})::Float64 +end + +function scnrm2(n, x, incx) + @ccall libblastrampoline.scnrm2_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Float32 +end + +function dznrm2(n, x, incx) + @ccall libblastrampoline.dznrm2_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Float64 +end + +function caxpy(n, ca, cx, incx, cy, incy) + @ccall libblastrampoline.caxpy_(n::Ref{BlasInt}, ca::Ref{ComplexF32}, + cx::Ptr{ComplexF32}, + incx::Ref{BlasInt}, cy::Ptr{ComplexF32}, + incy::Ref{BlasInt})::Cvoid +end + +function ccopy(n, cx, incx, cy, incy) + @ccall libblastrampoline.ccopy_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + cy::Ptr{ComplexF32}, incy::Ref{BlasInt})::Cvoid +end + +function cgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.cgbmv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF32}, y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.cgemm_(transa::Ref{UInt8}, transb::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cgemmt(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.cgemmt_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgemmtr(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.cgemmtr_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.cgemv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + beta::Ref{ComplexF32}, + y::Ptr{ComplexF32}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cgerc(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.cgerc_(m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt})::Cvoid +end + +function cgeru(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.cgeru_(m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt})::Cvoid +end + +function chbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.chbmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + beta::Ref{ComplexF32}, + y::Ptr{ComplexF32}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.chemm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + beta::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function chemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.chemv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, beta::Ref{ComplexF32}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cher(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.cher_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cher2(uplo, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.cher2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.cher2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + beta::Ref{Float32}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.cherk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + beta::Ref{Float32}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chpmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.chpmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + ap::Ptr{ComplexF32}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF32}, y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chpr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.chpr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + ap::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function chpr2(uplo, n, alpha, x, incx, y, incy, ap) + @ccall libblastrampoline.chpr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, ap::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function cscal(n, ca, cx, incx) + @ccall libblastrampoline.cscal_(n::Ref{BlasInt}, ca::Ref{ComplexF32}, + cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Cvoid +end + +function csrot(n, cx, incx, cy, incy, c, s) + @ccall libblastrampoline.csrot_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + cy::Ptr{ComplexF32}, incy::Ref{BlasInt}, + c::Ref{Float32}, + s::Ref{Float32})::Cvoid +end + +function csscal(n, sa, cx, incx) + @ccall libblastrampoline.csscal_(n::Ref{BlasInt}, sa::Ref{Float32}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Cvoid +end + +function cswap(n, cx, incx, cy, incy) + @ccall libblastrampoline.cswap_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + cy::Ptr{ComplexF32}, incy::Ref{BlasInt})::Cvoid +end + +function csymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.csymm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + beta::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function csyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.csyr2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + beta::Ref{ComplexF32}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function csyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.csyrk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + beta::Ref{ComplexF32}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctbmv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.ctbmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctbsv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.ctbsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctpmv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.ctpmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctpsv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.ctpsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.ctrmm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrmv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.ctrmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.ctrsm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrsv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.ctrsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dasum(n, dx, incx) + @ccall libblastrampoline.dasum_(n::Ref{BlasInt}, dx::Ptr{Float64}, + incx::Ref{BlasInt})::Float64 +end + +function daxpy(n, da, dx, incx, dy, incy) + @ccall libblastrampoline.daxpy_(n::Ref{BlasInt}, da::Ref{Float64}, dx::Ptr{Float64}, + incx::Ref{BlasInt}, dy::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function dcabs1(z) + @ccall libblastrampoline.dcabs1_(z::Ref{ComplexF64})::Float64 +end + +function dcopy(n, dx, incx, dy, incy) + @ccall libblastrampoline.dcopy_(n::Ref{BlasInt}, dx::Ptr{Float64}, incx::Ref{BlasInt}, + dy::Ptr{Float64}, incy::Ref{BlasInt})::Cvoid +end + +function ddot(n, dx, incx, dy, incy) + @ccall libblastrampoline.ddot_(n::Ref{BlasInt}, dx::Ptr{Float64}, incx::Ref{BlasInt}, + dy::Ptr{Float64}, incy::Ref{BlasInt})::Float64 +end + +function dgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dgbmv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, alpha::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, x::Ptr{Float64}, incx::Ref{BlasInt}, + beta::Ref{Float64}, y::Ptr{Float64}, incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.dgemm_(transa::Ref{UInt8}, transb::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, beta::Ref{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgemmt(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.dgemmt_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, beta::Ref{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgemmtr(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.dgemmtr_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, beta::Ref{Float64}, + c::Ptr{Float64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dgemv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + x::Ptr{Float64}, incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dger(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.dger_(m::Ref{BlasInt}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{Float64}, + incx::Ref{BlasInt}, y::Ptr{Float64}, incy::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt})::Cvoid +end + +function drot(n, dx, incx, dy, incy, c, s) + @ccall libblastrampoline.drot_(n::Ref{BlasInt}, dx::Ptr{Float64}, incx::Ref{BlasInt}, + dy::Ptr{Float64}, incy::Ref{BlasInt}, c::Ref{Float64}, + s::Ref{Float64})::Cvoid +end + +function drotm(n, dx, incx, dy, incy, dparam) + @ccall libblastrampoline.drotm_(n::Ref{BlasInt}, dx::Ptr{Float64}, incx::Ref{BlasInt}, + dy::Ptr{Float64}, incy::Ref{BlasInt}, + dparam::Ptr{Float64})::Cvoid +end + +function drotmg(dd1, dd2, dx1, dy1, dparam) + @ccall libblastrampoline.drotmg_(dd1::Ref{Float64}, dd2::Ref{Float64}, + dx1::Ref{Float64}, + dy1::Ref{Float64}, dparam::Ptr{Float64})::Cvoid +end + +function dsbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dsbmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + x::Ptr{Float64}, incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dscal(n, da, dx, incx) + @ccall libblastrampoline.dscal_(n::Ref{BlasInt}, da::Ref{Float64}, dx::Ptr{Float64}, + incx::Ref{BlasInt})::Cvoid +end + +function dsdot(n, sx, incx, sy, incy) + @ccall libblastrampoline.dsdot_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt})::Float64 +end + +function dspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.dspmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + ap::Ptr{Float64}, x::Ptr{Float64}, incx::Ref{BlasInt}, + beta::Ref{Float64}, y::Ptr{Float64}, incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dspr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.dspr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{Float64}, incx::Ref{BlasInt}, ap::Ptr{Float64}, + 1::Clong)::Cvoid +end + +function dspr2(uplo, n, alpha, x, incx, y, incy, ap) + @ccall libblastrampoline.dspr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{Float64}, incx::Ref{BlasInt}, y::Ptr{Float64}, + incy::Ref{BlasInt}, ap::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dswap(n, dx, incx, dy, incy) + @ccall libblastrampoline.dswap_(n::Ref{BlasInt}, dx::Ptr{Float64}, incx::Ref{BlasInt}, + dy::Ptr{Float64}, incy::Ref{BlasInt})::Cvoid +end + +function dsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.dsymm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, beta::Ref{Float64}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dsymv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, x::Ptr{Float64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, y::Ptr{Float64}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsyr(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.dsyr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{Float64}, incx::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsyr2(uplo, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.dsyr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{Float64}, incx::Ref{BlasInt}, y::Ptr{Float64}, + incy::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.dsyr2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + beta::Ref{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.dsyrk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + beta::Ref{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtbmv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.dtbmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + x::Ptr{Float64}, incx::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dtbsv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.dtbsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + x::Ptr{Float64}, incx::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dtpmv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.dtpmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, x::Ptr{Float64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtpsv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.dtpsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, x::Ptr{Float64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.dtrmm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrmv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.dtrmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + x::Ptr{Float64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.dtrsm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrsv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.dtrsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + x::Ptr{Float64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dzasum(n, zx, incx) + @ccall libblastrampoline.dzasum_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Float64 +end + +function icamax(n, cx, incx) + @ccall libblastrampoline.icamax_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::BlasInt +end + +function idamax(n, dx, incx) + @ccall libblastrampoline.idamax_(n::Ref{BlasInt}, dx::Ptr{Float64}, + incx::Ref{BlasInt})::BlasInt +end + +function isamax(n, sx, incx) + @ccall libblastrampoline.isamax_(n::Ref{BlasInt}, sx::Ptr{Float32}, + incx::Ref{BlasInt})::BlasInt +end + +function izamax(n, zx, incx) + @ccall libblastrampoline.izamax_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::BlasInt +end + +function sasum(n, sx, incx) + @ccall libblastrampoline.sasum_(n::Ref{BlasInt}, sx::Ptr{Float32}, + incx::Ref{BlasInt})::Float32 +end + +function saxpy(n, sa, sx, incx, sy, incy) + @ccall libblastrampoline.saxpy_(n::Ref{BlasInt}, sa::Ref{Float32}, sx::Ptr{Float32}, + incx::Ref{BlasInt}, sy::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function scabs1(z) + @ccall libblastrampoline.scabs1_(z::Ref{ComplexF32})::Float32 +end + +function scasum(n, cx, incx) + @ccall libblastrampoline.scasum_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Float32 +end + +function scopy(n, sx, incx, sy, incy) + @ccall libblastrampoline.scopy_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt})::Cvoid +end + +function sdot(n, sx, incx, sy, incy) + @ccall libblastrampoline.sdot_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt})::Float32 +end + +function sdsdot(n, sb, sx, incx, sy, incy) + @ccall libblastrampoline.sdsdot_(n::Ref{BlasInt}, sb::Ref{Float32}, sx::Ptr{Float32}, + incx::Ref{BlasInt}, sy::Ptr{Float32}, + incy::Ref{BlasInt})::Float32 +end + +function sgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.sgbmv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, alpha::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, x::Ptr{Float32}, incx::Ref{BlasInt}, + beta::Ref{Float32}, y::Ptr{Float32}, incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.sgemm_(transa::Ref{UInt8}, transb::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, beta::Ref{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgemmt(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.sgemmt_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, beta::Ref{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgemmtr(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.sgemmtr_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, beta::Ref{Float32}, + c::Ptr{Float32}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.sgemv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + x::Ptr{Float32}, incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sger(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.sger_(m::Ref{BlasInt}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{Float32}, + incx::Ref{BlasInt}, y::Ptr{Float32}, incy::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt})::Cvoid +end + +function srot(n, sx, incx, sy, incy, c, s) + @ccall libblastrampoline.srot_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt}, c::Ref{Float32}, + s::Ref{Float32})::Cvoid +end + +function srotm(n, sx, incx, sy, incy, sparam) + @ccall libblastrampoline.srotm_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt}, + sparam::Ptr{Float32})::Cvoid +end + +function srotmg(sd1, sd2, sx1, sy1, sparam) + @ccall libblastrampoline.srotmg_(sd1::Ref{Float32}, sd2::Ref{Float32}, + sx1::Ref{Float32}, + sy1::Ref{Float32}, sparam::Ptr{Float32})::Cvoid +end + +function ssbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.ssbmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + x::Ptr{Float32}, incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sscal(n, sa, sx, incx) + @ccall libblastrampoline.sscal_(n::Ref{BlasInt}, sa::Ref{Float32}, sx::Ptr{Float32}, + incx::Ref{BlasInt})::Cvoid +end + +function sspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.sspmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + ap::Ptr{Float32}, x::Ptr{Float32}, incx::Ref{BlasInt}, + beta::Ref{Float32}, y::Ptr{Float32}, incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sspr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.sspr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{Float32}, incx::Ref{BlasInt}, ap::Ptr{Float32}, + 1::Clong)::Cvoid +end + +function sspr2(uplo, n, alpha, x, incx, y, incy, ap) + @ccall libblastrampoline.sspr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{Float32}, incx::Ref{BlasInt}, y::Ptr{Float32}, + incy::Ref{BlasInt}, ap::Ptr{Float32}, 1::Clong)::Cvoid +end + +function sswap(n, sx, incx, sy, incy) + @ccall libblastrampoline.sswap_(n::Ref{BlasInt}, sx::Ptr{Float32}, incx::Ref{BlasInt}, + sy::Ptr{Float32}, incy::Ref{BlasInt})::Cvoid +end + +function ssymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.ssymm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, beta::Ref{Float32}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.ssymv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, x::Ptr{Float32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, y::Ptr{Float32}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssyr(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.ssyr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{Float32}, incx::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssyr2(uplo, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.ssyr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float32}, + x::Ptr{Float32}, incx::Ref{BlasInt}, y::Ptr{Float32}, + incy::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.ssyr2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + beta::Ref{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.ssyrk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + beta::Ref{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function stbmv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.stbmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + x::Ptr{Float32}, incx::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function stbsv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.stbsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + x::Ptr{Float32}, incx::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function stpmv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.stpmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, x::Ptr{Float32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stpsv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.stpsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, x::Ptr{Float32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function strmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.strmm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function strmv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.strmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + x::Ptr{Float32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function strsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.strsm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function strsv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.strsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + x::Ptr{Float32}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zaxpy(n, za, zx, incx, zy, incy) + @ccall libblastrampoline.zaxpy_(n::Ref{BlasInt}, za::Ref{ComplexF64}, + zx::Ptr{ComplexF64}, + incx::Ref{BlasInt}, zy::Ptr{ComplexF64}, + incy::Ref{BlasInt})::Cvoid +end + +function zcopy(n, zx, incx, zy, incy) + @ccall libblastrampoline.zcopy_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + zy::Ptr{ComplexF64}, incy::Ref{BlasInt})::Cvoid +end + +function zdrot(n, zx, incx, zy, incy, c, s) + @ccall libblastrampoline.zdrot_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + zy::Ptr{ComplexF64}, incy::Ref{BlasInt}, + c::Ref{Float64}, + s::Ref{Float64})::Cvoid +end + +function zdscal(n, da, zx, incx) + @ccall libblastrampoline.zdscal_(n::Ref{BlasInt}, da::Ref{Float64}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Cvoid +end + +function zgbmv(trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zgbmv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF64}, y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zgemm_(transa::Ref{UInt8}, transb::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zgemmt(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zgemmt_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgemmtr(uplo, transa, transb, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zgemmtr_(uplo::Ref{UInt8}, transa::Ref{UInt8}, + transb::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, beta::Ref{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zgemv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zgemv_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + beta::Ref{ComplexF64}, + y::Ptr{ComplexF64}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zgerc(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.zgerc_(m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt})::Cvoid +end + +function zgeru(m, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.zgeru_(m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt})::Cvoid +end + +function zhbmv(uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zhbmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, k::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + beta::Ref{ComplexF64}, + y::Ptr{ComplexF64}, incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zhemm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + beta::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zhemv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zhemv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, beta::Ref{ComplexF64}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zher(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.zher_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zher2(uplo, n, alpha, x, incx, y, incy, a, lda) + @ccall libblastrampoline.zher2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zher2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + beta::Ref{Float64}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.zherk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + beta::Ref{Float64}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhpmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.zhpmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + ap::Ptr{ComplexF64}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF64}, y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhpr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.zhpr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, alpha::Ref{Float64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + ap::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zhpr2(uplo, n, alpha, x, incx, y, incy, ap) + @ccall libblastrampoline.zhpr2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, ap::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zscal(n, za, zx, incx) + @ccall libblastrampoline.zscal_(n::Ref{BlasInt}, za::Ref{ComplexF64}, + zx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Cvoid +end + +function zswap(n, zx, incx, zy, incy) + @ccall libblastrampoline.zswap_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + zy::Ptr{ComplexF64}, incy::Ref{BlasInt})::Cvoid +end + +function zsymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zsymm_(side::Ref{UInt8}, uplo::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + beta::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zsyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) + @ccall libblastrampoline.zsyr2k_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + beta::Ref{ComplexF64}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zsyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc) + @ccall libblastrampoline.zsyrk_(uplo::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + beta::Ref{ComplexF64}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztbmv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.ztbmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztbsv(uplo, trans, diag, n, k, a, lda, x, incx) + @ccall libblastrampoline.ztbsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztpmv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.ztpmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztpsv(uplo, trans, diag, n, ap, x, incx) + @ccall libblastrampoline.ztpsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.ztrmm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrmv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.ztrmv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) + @ccall libblastrampoline.ztrsm_(side::Ref{UInt8}, uplo::Ref{UInt8}, transa::Ref{UInt8}, + diag::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrsv(uplo, trans, diag, n, a, lda, x, incx) + @ccall libblastrampoline.ztrsv_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end diff --git a/src/liblapack.jl b/src/liblapack.jl new file mode 100644 index 00000000..471337fd --- /dev/null +++ b/src/liblapack.jl @@ -0,0 +1,20681 @@ +# --- Wrappers not generated because the Fortran routines are in F90 --- +# The extension of cgedmd.f90 is not supported! +# The extension of cgedmdq.f90 is not supported! +# The extension of clartg.f90 is not supported! +# The extension of classq.f90 is not supported! +# The extension of dgedmd.f90 is not supported! +# The extension of dgedmdq.f90 is not supported! +# The extension of dlartg.f90 is not supported! +# The extension of dlassq.f90 is not supported! +# The extension of sgedmd.f90 is not supported! +# The extension of sgedmdq.f90 is not supported! +# The extension of slartg.f90 is not supported! +# The extension of slassq.f90 is not supported! +# The extension of zgedmd.f90 is not supported! +# The extension of zgedmdq.f90 is not supported! +# The extension of zlartg.f90 is not supported! +# The extension of zlassq.f90 is not supported! + +function cbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, + ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, + b22e, rwork, lrwork, info) + @ccall libblastrampoline.cbbcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, theta::Ptr{Float32}, + phi::Ptr{Float32}, u1::Ptr{ComplexF32}, + ldu1::Ref{BlasInt}, + u2::Ptr{ComplexF32}, ldu2::Ref{BlasInt}, + v1t::Ptr{ComplexF32}, + ldv1t::Ref{BlasInt}, v2t::Ptr{ComplexF32}, + ldv2t::Ref{BlasInt}, + b11d::Ptr{Float32}, b11e::Ptr{Float32}, + b12d::Ptr{Float32}, + b12e::Ptr{Float32}, b21d::Ptr{Float32}, + b21e::Ptr{Float32}, + b22d::Ptr{Float32}, b22e::Ptr{Float32}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info) + @ccall libblastrampoline.cbdsqr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ncvt::Ref{BlasInt}, + nru::Ref{BlasInt}, ncc::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, vt::Ptr{ComplexF32}, + ldvt::Ref{BlasInt}, + u::Ptr{ComplexF32}, ldu::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, + rwork, info) + @ccall libblastrampoline.cgbbrd_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + ncc::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + pt::Ptr{ComplexF32}, + ldpt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.cgbcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.cgbequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.cgbequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, + berr, work, rwork, info) + @ccall libblastrampoline.cgbrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, + ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.cgbrfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + r::Ptr{Float32}, + c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.cgbsv_(n::Ref{BlasInt}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cgbsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgbsvxx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, + nparams, params, work, rwork, info) + @ccall libblastrampoline.cgbsvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.cgbtf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.cgbtrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.cgbtrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + @ccall libblastrampoline.cgebak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float32}, + m::Ref{BlasInt}, v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cgebal(job, n, a, lda, ilo, ihi, scale, info) + @ccall libblastrampoline.cgebal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + @ccall libblastrampoline.cgebd2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tauq::Ptr{ComplexF32}, taup::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt})::Cvoid +end + +function cgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + @ccall libblastrampoline.cgebrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tauq::Ptr{ComplexF32}, taup::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgecon(norm, n, a, lda, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.cgecon_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.cgeequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, r::Ptr{Float32}, c::Ptr{Float32}, + rowcnd::Ref{Float32}, colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.cgeequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, r::Ptr{Float32}, c::Ptr{Float32}, + rowcnd::Ref{Float32}, colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, + info) + @ccall libblastrampoline.cgees_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + sdim::Ref{BlasInt}, w::Ptr{ComplexF32}, + vs::Ptr{ComplexF32}, + ldvs::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cgeesx(jobvs, sort, select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, + work, lwork, rwork, bwork, info) + @ccall libblastrampoline.cgeesx_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, sdim::Ref{BlasInt}, + w::Ptr{ComplexF32}, + vs::Ptr{ComplexF32}, ldvs::Ref{BlasInt}, + rconde::Ref{Float32}, + rcondv::Ref{Float32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + @ccall libblastrampoline.cgeev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + w::Ptr{ComplexF32}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgeevx(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, + scale, abnrm, rconde, rcondv, work, lwork, rwork, info) + @ccall libblastrampoline.cgeevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, w::Ptr{ComplexF32}, + vl::Ptr{ComplexF32}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float32}, + abnrm::Ref{Float32}, rconde::Ptr{Float32}, + rcondv::Ptr{Float32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgehd2(n, ilo, ihi, a, lda, tau, work, info) + @ccall libblastrampoline.cgehd2_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt})::Cvoid +end + +function cgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgehrd_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, + cwork, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.cgejsv_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + jobr::Ptr{UInt8}, jobt::Ptr{UInt8}, jobp::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, sva::Ptr{Float32}, + u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, + cwork::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgelq(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.cgelq_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + tsize::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgelq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.cgelq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgelqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgelqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgelqt(m, n, mb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.cgelqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgelqt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.cgelqt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.cgels_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.cgelsd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, s::Ptr{Float32}, + rcond::Ref{Float32}, + rank::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) + @ccall libblastrampoline.cgelss_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, s::Ptr{Float32}, + rcond::Ref{Float32}, + rank::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgelst(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.cgelst_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info) + @ccall libblastrampoline.cgelsy_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + rcond::Ref{Float32}, + rank::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.cgemlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + tsize::Ref{BlasInt}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.cgemlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.cgemqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + tsize::Ref{BlasInt}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.cgemqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgeql2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.cgeql2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqlf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgeqlf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgeqp3(m, n, a, lda, jpvt, tau, work, lwork, rwork, info) + @ccall libblastrampoline.cgeqp3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqp3rk(m, n, nrhs, kmax, abstol, reltol, a, lda, k, maxc2nrmk, relmaxc2nrmk, + jpiv, tau, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.cgeqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + kmax::Ref{BlasInt}, abstol::Ref{Float32}, + reltol::Ref{Float32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqr(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.cgeqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + tsize::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqr2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.cgeqr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqr2p(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.cgeqr2p_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqrf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgeqrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgeqrfp(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgeqrfp_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgeqrt(m, n, nb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.cgeqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqrt2(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.cgeqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgeqrt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.cgeqrt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.cgerfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.cgerfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgerq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.cgerq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cgerqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cgerqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + @ccall libblastrampoline.cgesc2_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + rhs::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt}, + scale::Ref{Float32})::Cvoid +end + +function cgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.cgesdd_(jobz::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, s::Ptr{Float32}, + u::Ptr{ComplexF32}, ldu::Ref{BlasInt}, + vt::Ptr{ComplexF32}, + ldvt::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.cgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) + @ccall libblastrampoline.cgesvd_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, u::Ptr{ComplexF32}, ldu::Ref{BlasInt}, + vt::Ptr{ComplexF32}, ldvt::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, + iwork, liwork, cwork, lcwork, rwork, lrwork, info) + @ccall libblastrampoline.cgesvdq_(joba::Ref{UInt8}, jobp::Ref{UInt8}, jobr::Ref{UInt8}, + jobu::Ref{UInt8}, jobv::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + s::Ptr{Float32}, u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + numrank::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + cwork::Ptr{ComplexF32}, + lcwork::Ref{BlasInt}, rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function cgesvdx(jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, ns, s, u, ldu, vt, ldvt, + work, lwork, rwork, iwork, info) + @ccall libblastrampoline.cgesvdx_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, + range::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, ns::Ref{BlasInt}, + s::Ptr{Float32}, u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, + vt::Ptr{ComplexF32}, ldvt::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, + lrwork, info) + @ccall libblastrampoline.cgesvj_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, sva::Ptr{Float32}, mv::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + cwork::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cgesvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float32}, c::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function cgesvxx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.cgesvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float32}, c::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgetc2(n, a, lda, ipiv, jpiv, info) + @ccall libblastrampoline.cgetc2_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, jpiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgetf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.cgetf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgetrf(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.cgetrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgetrf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.cgetrf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgetri(n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.cgetri_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.cgetrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.cgetsls_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.cgetsqrhrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb1::Ref{BlasInt}, + nb1::Ref{BlasInt}, nb2::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + @ccall libblastrampoline.cggbak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float32}, + rscale::Ptr{Float32}, m::Ref{BlasInt}, + v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + @ccall libblastrampoline.cggbal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float32}, + rscale::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, + ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + @ccall libblastrampoline.cgges_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, vsl::Ptr{ComplexF32}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{ComplexF32}, ldvsr::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgges3(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, + ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + @ccall libblastrampoline.cgges3_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, vsl::Ptr{ComplexF32}, + ldvsl::Ref{BlasInt}, vsr::Ptr{ComplexF32}, + ldvsr::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + bwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function cggesx(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, + vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, + bwork, info) + @ccall libblastrampoline.cggesx_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, sense::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, sdim::Ref{BlasInt}, + alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, vsl::Ptr{ComplexF32}, + ldvsl::Ref{BlasInt}, vsr::Ptr{ComplexF32}, + ldvsr::Ref{BlasInt}, + rconde::Ptr{Float32}, rcondv::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, + lwork, rwork, info) + @ccall libblastrampoline.cggev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cggev3(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, + lwork, rwork, info) + @ccall libblastrampoline.cggev3_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, vl::Ptr{ComplexF32}, + ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, ldvr::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, + ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, + rwork, iwork, bwork, info) + @ccall libblastrampoline.cggevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + alpha::Ptr{ComplexF32}, beta::Ptr{ComplexF32}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + lscale::Ptr{Float32}, rscale::Ptr{Float32}, + abnrm::Ref{Float32}, bbnrm::Ref{Float32}, + rconde::Ptr{Float32}, rcondv::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + @ccall libblastrampoline.cggglm_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + d::Ptr{ComplexF32}, x::Ptr{ComplexF32}, + y::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgghd3(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, + info) + @ccall libblastrampoline.cgghd3_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + @ccall libblastrampoline.cgghrd_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + @ccall libblastrampoline.cgglse_(m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, d::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.cggqrf_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, taua::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, taub::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.cggrqf_(m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, taua::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, taub::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cggsvd3(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, + ldv, q, ldq, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.cggsvd3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + alpha::Ptr{Float32}, + beta::Ptr{Float32}, u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cggsvp3(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, + ldv, q, ldq, iwork, rwork, tau, work, lwork, info) + @ccall libblastrampoline.cggsvp3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, tola::Ref{Float32}, + tolb::Ref{Float32}, + k::Ref{BlasInt}, l::Ref{BlasInt}, u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + rwork::Ptr{Float32}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.cgsvj0_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + d::Ptr{ComplexF32}, + sva::Ptr{Float32}, mv::Ref{BlasInt}, + v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, eps::Ref{Float32}, + sfmin::Ref{Float32}, + tol::Ref{Float32}, nsweep::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.cgsvj1_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + n1::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + d::Ptr{ComplexF32}, + sva::Ptr{Float32}, mv::Ref{BlasInt}, + v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, eps::Ref{Float32}, + sfmin::Ref{Float32}, + tol::Ref{Float32}, nsweep::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.cgtcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, du::Ptr{ComplexF32}, + du2::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, + berr, work, rwork, info) + @ccall libblastrampoline.cgtrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF32}, d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, + dlf::Ptr{ComplexF32}, df::Ptr{ComplexF32}, + duf::Ptr{ComplexF32}, du2::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cgtsv(n, nrhs, dl, d, du, b, ldb, info) + @ccall libblastrampoline.cgtsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, du::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cgtsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, dlf::Ptr{ComplexF32}, + df::Ptr{ComplexF32}, duf::Ptr{ComplexF32}, + du2::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cgttrf(n, dl, d, du, du2, ipiv, info) + @ccall libblastrampoline.cgttrf_(n::Ref{BlasInt}, dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, du2::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + @ccall libblastrampoline.cgttrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF32}, d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, + du2::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + @ccall libblastrampoline.cgtts2_(itrans::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF32}, d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, + du2::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt})::Cvoid +end + +function chb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, + work) + @ccall libblastrampoline.chb2st_kernels_(uplo::Ref{UInt8}, wantz::Ref{BlasInt}, + ttype::Ref{BlasInt}, + st::Ref{BlasInt}, ed::Ref{BlasInt}, + sweep::Ref{BlasInt}, + n::Ref{BlasInt}, nb::Ref{BlasInt}, + ib::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + v::Ptr{ComplexF32}, tau::Ptr{ComplexF32}, + ldvt::Ref{BlasInt}, work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function chbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.chbev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chbev_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, info) + @ccall libblastrampoline.chbev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function chbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.chbevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chbevd_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, + iwork, liwork, info) + @ccall libblastrampoline.chbevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, + ldz, work, rwork, iwork, ifail, info) + @ccall libblastrampoline.chbevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function chbevx_2stage(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, + m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.chbevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function chbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) + @ccall libblastrampoline.chbgst_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF32}, + ldbb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function chbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.chbgv_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF32}, + ldbb::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, + lrwork, iwork, liwork, info) + @ccall libblastrampoline.chbgvd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF32}, + ldbb::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, + abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + @ccall libblastrampoline.chbgvx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + bb::Ptr{ComplexF32}, + ldbb::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function chbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + @ccall libblastrampoline.chbtrd_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function checon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.checon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function checon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.checon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function checon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.checon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cheequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.cheequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + @ccall libblastrampoline.cheev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cheev_2stage(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + @ccall libblastrampoline.cheev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function cheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.cheevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cheevd_2stage(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, + info) + @ccall libblastrampoline.cheevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, + work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.cheevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function cheevr_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + isuppz, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.cheevr_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function cheevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, + lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.cheevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cheevx_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.cheevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function chegs2(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.chegs2_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chegst(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.chegst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + @ccall libblastrampoline.chegv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chegv_2stage(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + @ccall libblastrampoline.chegv_2stage_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function chegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.chegvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chegvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, + z, ldz, work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.chegvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.cherfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cherfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.cherfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.chesv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.chesv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chesv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.chesv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF32}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.chesv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.chesv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, rwork, info) + @ccall libblastrampoline.chesvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function chesvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.chesvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cheswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.cheswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetd2(uplo, n, a, lda, d, e, tau, info) + @ccall libblastrampoline.chetd2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tau::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.chetf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.chetf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.chetf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + @ccall libblastrampoline.chetrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tau::Ptr{ComplexF32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrd_2stage(vect, uplo, n, a, lda, d, e, tau, hous2, lhous2, work, lwork, info) + @ccall libblastrampoline.chetrd_2stage_(vect::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + d::Ptr{Float32}, + e::Ptr{Float32}, tau::Ptr{ComplexF32}, + hous2::Ptr{ComplexF32}, lhous2::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, + info) + @ccall libblastrampoline.chetrd_hb2st_(stage1::Ref{UInt8}, vect::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, + hous::Ptr{ComplexF32}, lhous::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function chetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) + @ccall libblastrampoline.chetrd_he2hb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + tau::Ptr{ComplexF32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.chetrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.chetrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.chetrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tb::Ptr{ComplexF32}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.chetrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.chetrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.chetri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.chetri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.chetri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.chetri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.chetri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.chetri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.chetrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.chetrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.chetrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.chetrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chetrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.chetrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF32}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.chetrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + @ccall libblastrampoline.chfrk_(transr::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + beta::Ref{Float32}, + c::Ptr{ComplexF32}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function chgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, + work, lwork, rwork, info) + @ccall libblastrampoline.chgeqz_(job::Ref{UInt8}, compq::Ref{UInt8}, compz::Ref{UInt8}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF32}, ldh::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, alpha::Ptr{ComplexF32}, + beta::Ptr{ComplexF32}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function chpcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.chpcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.chpev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, w::Ptr{Float32}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, + info) + @ccall libblastrampoline.chpevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, w::Ptr{Float32}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function chpevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, + iwork, ifail, info) + @ccall libblastrampoline.chpevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function chpgst(itype, uplo, n, ap, bp, info) + @ccall libblastrampoline.chpgst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, bp::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.chpgv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + bp::Ptr{ComplexF32}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.chpgvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + bp::Ptr{ComplexF32}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function chpgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, + work, rwork, iwork, ifail, info) + @ccall libblastrampoline.chpgvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + bp::Ptr{ComplexF32}, vl::Ref{Float32}, + vu::Ref{Float32}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, + m::Ref{BlasInt}, w::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function chprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.chprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, afp::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.chpsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chpsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.chpsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF32}, + afp::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function chptrd(uplo, n, ap, d, e, tau, info) + @ccall libblastrampoline.chptrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + d::Ptr{Float32}, e::Ptr{Float32}, tau::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.chptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.chptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function chptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.chptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function chsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, + rwork, ifaill, ifailr, info) + @ccall libblastrampoline.chsein_(side::Ref{UInt8}, eigsrc::Ref{UInt8}, + initv::Ref{UInt8}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF32}, + vl::Ptr{ComplexF32}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, ifaill::Ptr{BlasInt}, + ifailr::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function chseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info) + @ccall libblastrampoline.chseqr_(job::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF32}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) + @ccall libblastrampoline.cla_gbamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + alpha::Ref{Float32}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function cla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, + rwork) + @ccall libblastrampoline.cla_gbrcond_c_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float32}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_gbrcond_x(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, x, info, work, rwork) + @ccall libblastrampoline.cla_gbrcond_x_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF32}, + info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_gbrfsx_extended(prec_type, trans_type, n, kl, ku, nrhs, ab, ldab, afb, ldafb, + ipiv, colequ, c, b, ldb, y, ldy, berr_out, n_norms, + err_bnds_norm, err_bnds_comp, res, ayb, dy, y_tail, rcond, + ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.cla_gbrfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + y::Ptr{ComplexF32}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{ComplexF32}, ayb::Ptr{Float32}, + dy::Ptr{ComplexF32}, + y_tail::Ptr{ComplexF32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb) + @ccall libblastrampoline.cla_gbrpvgrw_(n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ncols::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt})::Float32 +end + +function cla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.cla_geamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + beta::Ref{Float32}, + y::Ptr{Float32}, incy::Ref{BlasInt})::Cvoid +end + +function cla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.cla_gercond_c_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float32}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_gercond_x(trans, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.cla_gercond_x_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF32}, + info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_gerfsx_extended(prec_type, trans_type, n, nrhs, a, lda, af, ldaf, ipiv, colequ, + c, b, ldb, y, ldy, berr_out, n_norms, errs_n, errs_c, res, ayb, + dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.cla_gerfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF32}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + errs_n::Ptr{Float32}, + errs_c::Ptr{Float32}, + res::Ptr{ComplexF32}, + ayb::Ptr{Float32}, dy::Ptr{ComplexF32}, + y_tail::Ptr{ComplexF32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cla_gerpvgrw(n, ncols, a, lda, af, ldaf) + @ccall libblastrampoline.cla_gerpvgrw_(n::Ref{BlasInt}, ncols::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt})::Float32 +end + +function cla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.cla_heamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function cla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.cla_hercond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float32}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_hercond_x(uplo, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.cla_hercond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF32}, + info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_herfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.cla_herfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF32}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{ComplexF32}, ayb::Ptr{Float32}, + dy::Ptr{ComplexF32}, + y_tail::Ptr{ComplexF32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.cla_herpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_lin_berr(n, nz, nrhs, res, ayb, berr) + @ccall libblastrampoline.cla_lin_berr_(n::Ref{BlasInt}, nz::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + res::Ptr{ComplexF32}, ayb::Ptr{Float32}, + berr::Ptr{Float32})::Cvoid +end + +function cla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork) + @ccall libblastrampoline.cla_porcond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + c::Ptr{Float32}, capply::Ref{BlasInt}, + info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_porcond_x(uplo, n, a, lda, af, ldaf, x, info, work, rwork) + @ccall libblastrampoline.cla_porcond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + x::Ptr{ComplexF32}, info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_porfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, colequ, c, b, ldb, + y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, res, + ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, + info) + @ccall libblastrampoline.cla_porfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + y::Ptr{ComplexF32}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{ComplexF32}, ayb::Ptr{Float32}, + dy::Ptr{ComplexF32}, + y_tail::Ptr{ComplexF32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work) + @ccall libblastrampoline.cla_porpvgrw_(uplo::Ptr{UInt8}, ncols::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.cla_syamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function cla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.cla_syrcond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float32}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_syrcond_x(uplo, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.cla_syrcond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF32}, + info::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + 1::Clong)::Float32 +end + +function cla_syrfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.cla_syrfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF32}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{ComplexF32}, ayb::Ptr{Float32}, + dy::Ptr{ComplexF32}, + y_tail::Ptr{ComplexF32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.cla_syrpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Float32 +end + +function cla_wwaddw(n, x, y, w) + @ccall libblastrampoline.cla_wwaddw_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + y::Ptr{ComplexF32}, + w::Ptr{ComplexF32})::Cvoid +end + +function clabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + @ccall libblastrampoline.clabrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, tauq::Ptr{ComplexF32}, + taup::Ptr{ComplexF32}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + y::Ptr{ComplexF32}, ldy::Ref{BlasInt})::Cvoid +end + +function clacgv(n, x, incx) + @ccall libblastrampoline.clacgv_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Cvoid +end + +function clacn2(n, v, x, est, kase, isave) + @ccall libblastrampoline.clacn2_(n::Ref{BlasInt}, v::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, + est::Ref{Float32}, kase::Ref{BlasInt}, + isave::Ptr{BlasInt})::Cvoid +end + +function clacon(n, v, x, est, kase) + @ccall libblastrampoline.clacon_(n::Ref{BlasInt}, v::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, + est::Ref{Float32}, kase::Ref{BlasInt})::Cvoid +end + +function clacp2(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.clacp2_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clacpy(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.clacpy_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clacrm(m, n, a, lda, b, ldb, c, ldc, rwork) + @ccall libblastrampoline.clacrm_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + rwork::Ptr{Float32})::Cvoid +end + +function clacrt(n, cx, incx, cy, incy, c, s) + @ccall libblastrampoline.clacrt_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + cy::Ptr{ComplexF32}, incy::Ref{BlasInt}, + c::Ref{ComplexF32}, + s::Ref{ComplexF32})::Cvoid +end + +function cladiv(x, y) + @ccall libblastrampoline.cladiv_(x::Ref{ComplexF32}, y::Ref{ComplexF32})::ComplexF32 +end + +function claed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info) + @ccall libblastrampoline.claed0_(qsiz::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + qstore::Ptr{ComplexF32}, ldqs::Ref{BlasInt}, + rwork::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, + prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info) + @ccall libblastrampoline.claed7_(n::Ref{BlasInt}, cutpnt::Ref{BlasInt}, + qsiz::Ref{BlasInt}, + tlvls::Ref{BlasInt}, curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, + d::Ptr{Float32}, q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + rho::Ref{Float32}, indxq::Ptr{BlasInt}, + qstore::Ptr{Float32}, + qptr::Ptr{BlasInt}, prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, + givptr::Ptr{BlasInt}, givcol::Ptr{BlasInt}, + givnum::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlambda, q2, ldq2, w, indxp, indx, + indxq, perm, givptr, givcol, givnum, info) + @ccall libblastrampoline.claed8_(k::Ref{BlasInt}, n::Ref{BlasInt}, qsiz::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, d::Ptr{Float32}, + rho::Ref{Float32}, cutpnt::Ref{BlasInt}, + z::Ptr{Float32}, + dlambda::Ptr{Float32}, q2::Ptr{ComplexF32}, + ldq2::Ref{BlasInt}, + w::Ptr{Float32}, indxp::Ptr{BlasInt}, + indx::Ptr{BlasInt}, + indxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, givnum::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function claein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info) + @ccall libblastrampoline.claein_(rightv::Ref{BlasInt}, noinit::Ref{BlasInt}, + n::Ref{BlasInt}, + h::Ptr{ComplexF32}, ldh::Ref{BlasInt}, + w::Ref{ComplexF32}, + v::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + rwork::Ptr{Float32}, eps3::Ref{Float32}, + smlnum::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function claesy(a, b, c, rt1, rt2, evscal, cs1, sn1) + @ccall libblastrampoline.claesy_(a::Ref{ComplexF32}, b::Ref{ComplexF32}, + c::Ref{ComplexF32}, + rt1::Ref{ComplexF32}, rt2::Ref{ComplexF32}, + evscal::Ref{ComplexF32}, cs1::Ref{ComplexF32}, + sn1::Ref{ComplexF32})::Cvoid +end + +function claev2(a, b, c, rt1, rt2, cs1, sn1) + @ccall libblastrampoline.claev2_(a::Ref{ComplexF32}, b::Ref{ComplexF32}, + c::Ref{ComplexF32}, + rt1::Ref{Float32}, rt2::Ref{Float32}, + cs1::Ref{Float32}, + sn1::Ref{ComplexF32})::Cvoid +end + +function clag2z(m, n, sa, ldsa, a, lda, info) + @ccall libblastrampoline.clag2z_(m::Ref{BlasInt}, n::Ref{BlasInt}, sa::Ptr{ComplexF32}, + ldsa::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function clags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + @ccall libblastrampoline.clags2_(upper::Ref{BlasInt}, a1::Ref{Float32}, + a2::Ref{ComplexF32}, + a3::Ref{Float32}, b1::Ref{Float32}, + b2::Ref{ComplexF32}, + b3::Ref{Float32}, csu::Ref{Float32}, + snu::Ref{ComplexF32}, + csv::Ref{Float32}, snv::Ref{ComplexF32}, + csq::Ref{Float32}, + snq::Ref{ComplexF32})::Cvoid +end + +function clagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + @ccall libblastrampoline.clagtm_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + alpha::Ref{Float32}, dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, + du::Ptr{ComplexF32}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + beta::Ref{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.clahef_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF32}, ldw::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.clahef_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, + work::Ptr{ComplexF32}, 1::Clong)::Cvoid +end + +function clahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.clahef_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF32}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.clahef_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{ComplexF32}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) + @ccall libblastrampoline.clahqr_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF32}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function clahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + @ccall libblastrampoline.clahr2_(n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + y::Ptr{ComplexF32}, + ldy::Ref{BlasInt})::Cvoid +end + +function claic1(job, j, x, sest, w, gamma, sestpr, s, c) + @ccall libblastrampoline.claic1_(job::Ref{BlasInt}, j::Ref{BlasInt}, x::Ptr{ComplexF32}, + sest::Ref{Float32}, w::Ptr{ComplexF32}, + gamma::Ref{ComplexF32}, sestpr::Ref{Float32}, + s::Ref{ComplexF32}, c::Ref{ComplexF32})::Cvoid +end + +function clals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, + givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) + @ccall libblastrampoline.clals0_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, nrhs::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, bx::Ptr{ComplexF32}, + ldbx::Ref{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, givnum::Ptr{Float32}, + ldgnum::Ref{BlasInt}, + poles::Ptr{Float32}, difl::Ptr{Float32}, + difr::Ptr{Float32}, + z::Ptr{Float32}, k::Ref{BlasInt}, c::Ref{Float32}, + s::Ref{Float32}, rwork::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function clalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, + poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) + @ccall libblastrampoline.clalsa_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + bx::Ptr{ComplexF32}, ldbx::Ref{BlasInt}, + u::Ptr{Float32}, + ldu::Ref{BlasInt}, vt::Ptr{Float32}, k::Ptr{BlasInt}, + difl::Ptr{Float32}, difr::Ptr{Float32}, + z::Ptr{Float32}, + poles::Ptr{Float32}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, perm::Ptr{BlasInt}, + givnum::Ptr{Float32}, + c::Ptr{Float32}, s::Ptr{Float32}, rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function clalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) + @ccall libblastrampoline.clalsd_(uplo::Ref{UInt8}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + rcond::Ref{Float32}, + rank::Ref{BlasInt}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.clamswlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function clamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.clamtsqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function clangb(norm, n, kl, ku, ab, ldab, work) + @ccall libblastrampoline.clangb_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function clange(norm, m, n, a, lda, work) + @ccall libblastrampoline.clange_(norm::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function clangt(norm, n, dl, d, du) + @ccall libblastrampoline.clangt_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{ComplexF32}, + d::Ptr{ComplexF32}, du::Ptr{ComplexF32}, + 1::Clong)::Float32 +end + +function clanhb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.clanhb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong, 1::Clong)::Float32 +end + +function clanhe(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.clanhe_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong, 1::Clong)::Float32 +end + +function clanhf(norm, transr, uplo, n, a, work) + @ccall libblastrampoline.clanhf_(norm::Ref{UInt8}, transr::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + work::Ptr{Float32}, + 1::Clong, 1::Clong, 1::Clong)::Float32 +end + +function clanhp(norm, uplo, n, ap, work) + @ccall libblastrampoline.clanhp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, work::Ptr{Float32}, 1::Clong, + 1::Clong)::Float32 +end + +function clanhs(norm, n, a, lda, work) + @ccall libblastrampoline.clanhs_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function clanht(norm, n, d, e) + @ccall libblastrampoline.clanht_(norm::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{ComplexF32}, 1::Clong)::Float32 +end + +function clansb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.clansb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong, 1::Clong)::Float32 +end + +function clansp(norm, uplo, n, ap, work) + @ccall libblastrampoline.clansp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, work::Ptr{Float32}, 1::Clong, + 1::Clong)::Float32 +end + +function clansy(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.clansy_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong, 1::Clong)::Float32 +end + +function clantb(norm, uplo, diag, n, k, ab, ldab, work) + @ccall libblastrampoline.clantb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong, + 1::Clong, + 1::Clong)::Float32 +end + +function clantp(norm, uplo, diag, n, ap, work) + @ccall libblastrampoline.clantp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + work::Ptr{Float32}, + 1::Clong, 1::Clong, 1::Clong)::Float32 +end + +function clantr(norm, uplo, diag, m, n, a, lda, work) + @ccall libblastrampoline.clantr_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong, + 1::Clong, + 1::Clong)::Float32 +end + +function clapll(n, x, incx, y, incy, ssmin) + @ccall libblastrampoline.clapll_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, incy::Ref{BlasInt}, + ssmin::Ref{Float32})::Cvoid +end + +function clapmr(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.clapmr_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function clapmt(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.clapmt_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function claqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.claqgb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function claqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.claqge_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, r::Ptr{Float32}, c::Ptr{Float32}, + rowcnd::Ref{Float32}, colcnd::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function claqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.claqhb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + s::Ptr{Float32}, + scond::Ref{Float32}, amax::Ref{Float32}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function claqhe(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.claqhe_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function claqhp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.claqhp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function claqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + @ccall libblastrampoline.claqp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, + tau::Ptr{ComplexF32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + work::Ptr{ComplexF32})::Cvoid +end + +function claqp2rk(m, n, nrhs, ioffset, kmax, abstol, reltol, kp1, maxc2nrm, a, lda, k, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, work, info) + @ccall libblastrampoline.claqp2rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, kmax::Ref{BlasInt}, + abstol::Ref{Float32}, + reltol::Ref{Float32}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt})::Cvoid +end + +function claqp3rk(m, n, nrhs, ioffset, nb, abstol, reltol, kp1, maxc2nrm, a, lda, done, kb, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, auxv, f, ldf, iwork, info) + @ccall libblastrampoline.claqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, nb::Ref{BlasInt}, + abstol::Ref{Float32}, + reltol::Ref{Float32}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + done::Ref{BlasInt}, kb::Ref{BlasInt}, + maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + auxv::Ptr{ComplexF32}, f::Ptr{ComplexF32}, + ldf::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function claqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + @ccall libblastrampoline.claqps_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{ComplexF32}, + vn1::Ptr{Float32}, + vn2::Ptr{Float32}, auxv::Ptr{ComplexF32}, + f::Ptr{ComplexF32}, + ldf::Ref{BlasInt})::Cvoid +end + +function claqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + @ccall libblastrampoline.claqr0_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF32}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claqr1(n, h, ldh, s1, s2, v) + @ccall libblastrampoline.claqr1_(n::Ref{BlasInt}, h::Ptr{ComplexF32}, ldh::Ref{BlasInt}, + s1::Ref{ComplexF32}, s2::Ref{ComplexF32}, + v::Ptr{ComplexF32})::Cvoid +end + +function claqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, + ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.claqr2_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{ComplexF32}, ldh::Ref{BlasInt}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, + sh::Ptr{ComplexF32}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, + wv::Ptr{ComplexF32}, ldwv::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt})::Cvoid +end + +function claqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, + ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.claqr3_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{ComplexF32}, ldh::Ref{BlasInt}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, + sh::Ptr{ComplexF32}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, + wv::Ptr{ComplexF32}, ldwv::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt})::Cvoid +end + +function claqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + @ccall libblastrampoline.claqr4_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF32}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, + v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + @ccall libblastrampoline.claqr5_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + kacc22::Ref{BlasInt}, + n::Ref{BlasInt}, ktop::Ref{BlasInt}, + kbot::Ref{BlasInt}, + nshfts::Ref{BlasInt}, s::Ptr{ComplexF32}, + h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, u::Ptr{ComplexF32}, + ldu::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{ComplexF32}, + ldwv::Ref{BlasInt}, + nh::Ref{BlasInt}, wh::Ptr{ComplexF32}, + ldwh::Ref{BlasInt})::Cvoid +end + +function claqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.claqsb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + s::Ptr{Float32}, + scond::Ref{Float32}, amax::Ref{Float32}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function claqsp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.claqsp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function claqsy(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.claqsy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function clar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, + mingma, r, isuppz, nrminv, resid, rqcorr, work) + @ccall libblastrampoline.clar1v_(n::Ref{BlasInt}, b1::Ref{BlasInt}, bn::Ref{BlasInt}, + lambda::Ref{Float32}, d::Ptr{Float32}, l::Ptr{Float32}, + ld::Ptr{Float32}, lld::Ptr{Float32}, + pivmin::Ref{Float32}, + gaptol::Ref{Float32}, z::Ptr{ComplexF32}, + wantnc::Ref{BlasInt}, + negcnt::Ref{BlasInt}, ztz::Ref{Float32}, + mingma::Ref{Float32}, + r::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + nrminv::Ref{Float32}, + resid::Ref{Float32}, rqcorr::Ref{Float32}, + work::Ptr{Float32})::Cvoid +end + +function clar2v(n, x, y, z, incx, c, s, incc) + @ccall libblastrampoline.clar2v_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + y::Ptr{ComplexF32}, + z::Ptr{ComplexF32}, incx::Ref{BlasInt}, + c::Ptr{Float32}, + s::Ptr{ComplexF32}, incc::Ref{BlasInt})::Cvoid +end + +function clarcm(m, n, a, lda, b, ldb, c, ldc, rwork) + @ccall libblastrampoline.clarcm_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, rwork::Ptr{Float32})::Cvoid +end + +function clarf(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.clarf_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF32}, incv::Ref{BlasInt}, + tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clarf1f(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.clarf1f_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF32}, incv::Ref{BlasInt}, + tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clarf1l(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.clarf1l_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF32}, incv::Ref{BlasInt}, + tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + @ccall libblastrampoline.clarfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function clarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork) + @ccall libblastrampoline.clarfb_gett_(ident::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, work::Ptr{ComplexF32}, + ldwork::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clarfg(n, alpha, x, incx, tau) + @ccall libblastrampoline.clarfg_(n::Ref{BlasInt}, alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, tau::Ref{ComplexF32})::Cvoid +end + +function clarfgp(n, alpha, x, incx, tau) + @ccall libblastrampoline.clarfgp_(n::Ref{BlasInt}, alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, tau::Ref{ComplexF32})::Cvoid +end + +function clarft(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.clarft_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + tau::Ptr{ComplexF32}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function clarfx(side, m, n, v, tau, c, ldc, work) + @ccall libblastrampoline.clarfx_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF32}, tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clarfy(uplo, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.clarfy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, v::Ptr{ComplexF32}, + incv::Ref{BlasInt}, tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clargv(n, x, incx, y, incy, c, incc) + @ccall libblastrampoline.clargv_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, incy::Ref{BlasInt}, + c::Ptr{Float32}, + incc::Ref{BlasInt})::Cvoid +end + +function clarnv(idist, iseed, n, x) + @ccall libblastrampoline.clarnv_(idist::Ref{BlasInt}, iseed::Ptr{BlasInt}, + n::Ref{BlasInt}, + x::Ptr{ComplexF32})::Cvoid +end + +function clarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, + wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + @ccall libblastrampoline.clarrv_(n::Ref{BlasInt}, vl::Ref{Float32}, vu::Ref{Float32}, + d::Ptr{Float32}, l::Ptr{Float32}, pivmin::Ref{Float32}, + isplit::Ptr{BlasInt}, m::Ref{BlasInt}, + dol::Ref{BlasInt}, + dou::Ref{BlasInt}, minrgp::Ref{Float32}, + rtol1::Ref{Float32}, + rtol2::Ref{Float32}, w::Ptr{Float32}, + werr::Ptr{Float32}, + wgap::Ptr{Float32}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float32}, z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function clarscl2(m, n, d, x, ldx) + @ccall libblastrampoline.clarscl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float32}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt})::Cvoid +end + +function clartv(n, x, incx, y, incy, c, s, incc) + @ccall libblastrampoline.clartv_(n::Ref{BlasInt}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF32}, incy::Ref{BlasInt}, + c::Ptr{Float32}, + s::Ptr{ComplexF32}, incc::Ref{BlasInt})::Cvoid +end + +function clarz(side, m, n, l, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.clarz_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + l::Ref{BlasInt}, + v::Ptr{ComplexF32}, incv::Ref{BlasInt}, + tau::Ref{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function clarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, + ldwork) + @ccall libblastrampoline.clarzb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + ldwork::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function clarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.clarzt_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + tau::Ptr{ComplexF32}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function clascl(type, kl, ku, cfrom, cto, m, n, a, lda, info) + @ccall libblastrampoline.clascl_(type::Ref{UInt8}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + cfrom::Ref{Float32}, cto::Ref{Float32}, + m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clascl2(m, n, d, x, ldx) + @ccall libblastrampoline.clascl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float32}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt})::Cvoid +end + +function claset(uplo, m, n, alpha, beta, a, lda) + @ccall libblastrampoline.claset_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, beta::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clasr(side, pivot, direct, m, n, c, s, a, lda) + @ccall libblastrampoline.clasr_(side::Ref{UInt8}, pivot::Ref{UInt8}, direct::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, c::Ptr{Float32}, + s::Ptr{Float32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function claswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.claswlq_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claswp(n, a, lda, k1, k2, ipiv, incx) + @ccall libblastrampoline.claswp_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + k1::Ref{BlasInt}, k2::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + incx::Ref{BlasInt})::Cvoid +end + +function clasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.clasyf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF32}, ldw::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.clasyf_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{ComplexF32}, + ldh::Ref{BlasInt}, + work::Ptr{ComplexF32}, 1::Clong)::Cvoid +end + +function clasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.clasyf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF32}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.clasyf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{ComplexF32}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + @ccall libblastrampoline.clatbs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + x::Ptr{ComplexF32}, + scale::Ref{Float32}, cnorm::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function clatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + @ccall libblastrampoline.clatdf_(ijob::Ref{BlasInt}, n::Ref{BlasInt}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, rhs::Ptr{ComplexF32}, + rdsum::Ref{Float32}, + rdscal::Ref{Float32}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt})::Cvoid +end + +function clatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + @ccall libblastrampoline.clatps_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, + x::Ptr{ComplexF32}, scale::Ref{Float32}, + cnorm::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function clatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + @ccall libblastrampoline.clatrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, e::Ptr{Float32}, + tau::Ptr{ComplexF32}, w::Ptr{ComplexF32}, + ldw::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function clatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + @ccall libblastrampoline.clatrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, x::Ptr{ComplexF32}, + scale::Ref{Float32}, + cnorm::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function clatrs3(uplo, trans, diag, normin, n, nrhs, a, lda, x, ldx, scale, cnorm, work, + lwork, info) + @ccall libblastrampoline.clatrs3_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, scale::Ptr{Float32}, + cnorm::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function clatrz(m, n, l, a, lda, tau, work) + @ccall libblastrampoline.clatrz_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32})::Cvoid +end + +function clatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.clatsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function claunhr_col_getrfnp(m, n, a, lda, d, info) + @ccall libblastrampoline.claunhr_col_getrfnp_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function claunhr_col_getrfnp2(m, n, a, lda, d, info) + @ccall libblastrampoline.claunhr_col_getrfnp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, d::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function clauu2(uplo, n, a, lda, info) + @ccall libblastrampoline.clauu2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function clauum(uplo, n, a, lda, info) + @ccall libblastrampoline.clauum_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.cpbcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + @ccall libblastrampoline.cpbequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + s::Ptr{Float32}, + scond::Ref{Float32}, amax::Ref{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.cpbrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF32}, ldafb::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbstf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.cpbstf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.cpbsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cpbsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF32}, + ldafb::Ref{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cpbtf2(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.cpbtf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbtrf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.cpbtrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.cpbtrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpftrf(transr, uplo, n, a, info) + @ccall libblastrampoline.cpftrf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cpftri(transr, uplo, n, a, info) + @ccall libblastrampoline.cpftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + @ccall libblastrampoline.cpftrs_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.cpocon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpoequ(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.cpoequ_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function cpoequb(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.cpoequb_(n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function cporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.cporfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cporfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, + n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, + info) + @ccall libblastrampoline.cporfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + s::Ptr{Float32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cposv(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.cposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + ferr, berr, work, rwork, info) + @ccall libblastrampoline.cposvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float32}, b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cposvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, + work, rwork, info) + @ccall libblastrampoline.cposvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + rpvgrw::Ref{Float32}, berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function cpotf2(uplo, n, a, lda, info) + @ccall libblastrampoline.cpotf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpotrf(uplo, n, a, lda, info) + @ccall libblastrampoline.cpotrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpotrf2(uplo, n, a, lda, info) + @ccall libblastrampoline.cpotrf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpotri(uplo, n, a, lda, info) + @ccall libblastrampoline.cpotri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.cpotrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cppcon(uplo, n, ap, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.cppcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cppequ(uplo, n, ap, s, scond, amax, info) + @ccall libblastrampoline.cppequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cpprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, afp::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cppsv(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.cppsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, + work, rwork, info) + @ccall libblastrampoline.cppsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF32}, + afp::Ptr{ComplexF32}, + equed::Ref{UInt8}, s::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function cpptrf(uplo, n, ap, info) + @ccall libblastrampoline.cpptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpptri(uplo, n, ap, info) + @ccall libblastrampoline.cpptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpptrs(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.cpptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.cpstf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.cpstrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cptcon(n, d, e, anorm, rcond, rwork, info) + @ccall libblastrampoline.cptcon_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{ComplexF32}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + rwork::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function cpteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.cpteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.cptrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{ComplexF32}, df::Ptr{Float32}, + ef::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cptsv(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.cptsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.cptsvx_(fact::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{ComplexF32}, df::Ptr{Float32}, + ef::Ptr{ComplexF32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cpttrf(n, d, e, info) + @ccall libblastrampoline.cpttrf_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cpttrs(uplo, n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.cpttrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cptts2(iuplo, n, nrhs, d, e, b, ldb) + @ccall libblastrampoline.cptts2_(iuplo::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt})::Cvoid +end + +function crot(n, cx, incx, cy, incy, c, s) + @ccall libblastrampoline.crot_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, incx::Ref{BlasInt}, + cy::Ptr{ComplexF32}, incy::Ref{BlasInt}, c::Ref{Float32}, + s::Ref{ComplexF32})::Cvoid +end + +function crscl(n, a, x, incx) + @ccall libblastrampoline.crscl_(n::Ref{BlasInt}, a::Ref{ComplexF32}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Cvoid +end + +function cspcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.cspcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.cspmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + ap::Ptr{ComplexF32}, x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF32}, y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cspr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.cspr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + ap::Ptr{ComplexF32}, + 1::Clong)::Cvoid +end + +function csprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.csprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, afp::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.cspsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.cspsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF32}, + afp::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function csptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.csptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.csptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.csptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csrscl(n, sa, sx, incx) + @ccall libblastrampoline.csrscl_(n::Ref{BlasInt}, sa::Ref{Float32}, sx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Cvoid +end + +function cstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.cstedc_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function cstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.cstegr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.cstein_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.cstemr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + nzc::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + tryrac::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function csteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.csteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.csycon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csycon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.csycon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.csycon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csyconv(uplo, way, n, a, lda, ipiv, e, info) + @ccall libblastrampoline.csyconv_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + e::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function csyconvf(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.csyconvf_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function csyconvf_rook(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.csyconvf_rook_(uplo::Ref{UInt8}, way::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function csyequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.csyequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.csymv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + x::Ptr{ComplexF32}, + incx::Ref{BlasInt}, beta::Ref{ComplexF32}, + y::Ptr{ComplexF32}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csyr(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.csyr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF32}, + x::Ptr{ComplexF32}, incx::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.csyrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csyrfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.csyrfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float32}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function csysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.csysv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.csysv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csysv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.csysv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF32}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.csysv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.csysv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, rwork, info) + @ccall libblastrampoline.csysvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function csysvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.csysvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float32}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + rcond::Ref{Float32}, rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function csyswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.csyswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.csytf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.csytf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.csytf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.csytrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.csytrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.csytrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tb::Ptr{ComplexF32}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.csytrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.csytrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.csytri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.csytri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.csytri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.csytri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.csytri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.csytri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.csytrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.csytrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.csytrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + e::Ptr{ComplexF32}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.csytrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function csytrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.csytrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF32}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function csytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.csytrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ctbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info) + @ccall libblastrampoline.ctbcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{ComplexF32}, + ldab::Ref{BlasInt}, rcond::Ref{Float32}, + work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.ctbrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.ctbtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF32}, ldab::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + @ccall libblastrampoline.ctfsm_(transr::Ref{UInt8}, side::Ref{UInt8}, uplo::Ref{UInt8}, + trans::Ref{UInt8}, diag::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, alpha::Ref{ComplexF32}, + a::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctftri(transr, uplo, diag, n, a, info) + @ccall libblastrampoline.ctftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctfttp(transr, uplo, n, arf, ap, info) + @ccall libblastrampoline.ctfttp_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{ComplexF32}, ap::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctfttr(transr, uplo, n, arf, a, lda, info) + @ccall libblastrampoline.ctfttr_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{ComplexF32}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ctgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, + rwork, info) + @ccall libblastrampoline.ctgevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, s::Ptr{ComplexF32}, lds::Ref{BlasInt}, + p::Ptr{ComplexF32}, ldp::Ref{BlasInt}, + vl::Ptr{ComplexF32}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ctgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) + @ccall libblastrampoline.ctgex2_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + j1::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ctgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) + @ccall libblastrampoline.ctgexc_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, ldz::Ref{BlasInt}, + ifst::Ref{BlasInt}, + ilst::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function ctgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, + m, pl, pr, dif, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ctgsen_(ijob::Ref{BlasInt}, wantq::Ref{BlasInt}, + wantz::Ref{BlasInt}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + alpha::Ptr{ComplexF32}, beta::Ptr{ComplexF32}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF32}, + ldz::Ref{BlasInt}, m::Ref{BlasInt}, pl::Ref{Float32}, + pr::Ref{Float32}, dif::Ptr{Float32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ctgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, + ldu, v, ldv, q, ldq, work, ncycle, info) + @ccall libblastrampoline.ctgsja_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + tola::Ref{Float32}, + tolb::Ref{Float32}, alpha::Ptr{Float32}, + beta::Ptr{Float32}, + u::Ptr{ComplexF32}, ldu::Ref{BlasInt}, + v::Ptr{ComplexF32}, + ldv::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + work::Ptr{ComplexF32}, ncycle::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, + work, lwork, iwork, info) + @ccall libblastrampoline.ctgsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + vl::Ptr{ComplexF32}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, + s::Ptr{Float32}, dif::Ptr{Float32}, mm::Ref{BlasInt}, + m::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ctgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + rdsum, rdscal, info) + @ccall libblastrampoline.ctgsy2_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, d::Ptr{ComplexF32}, + ldd::Ref{BlasInt}, + e::Ptr{ComplexF32}, lde::Ref{BlasInt}, + f::Ptr{ComplexF32}, + ldf::Ref{BlasInt}, scale::Ref{Float32}, + rdsum::Ref{Float32}, + rdscal::Ref{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ctgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + dif, work, lwork, iwork, info) + @ccall libblastrampoline.ctgsyl_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, d::Ptr{ComplexF32}, + ldd::Ref{BlasInt}, + e::Ptr{ComplexF32}, lde::Ref{BlasInt}, + f::Ptr{ComplexF32}, + ldf::Ref{BlasInt}, scale::Ref{Float32}, + dif::Ref{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ctpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info) + @ccall libblastrampoline.ctpcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + rcond::Ref{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.ctplqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt})::Cvoid +end + +function ctplqt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.ctplqt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ctpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.ctpmlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ctpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.ctpmqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ctpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.ctpqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt})::Cvoid +end + +function ctpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.ctpqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ctprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, + work, ldwork) + @ccall libblastrampoline.ctprfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{ComplexF32}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF32}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.ctprfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctptri(uplo, diag, n, ap, info) + @ccall libblastrampoline.ctptri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ctptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.ctptrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF32}, + b::Ptr{ComplexF32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ctpttf(transr, uplo, n, ap, arf, info) + @ccall libblastrampoline.ctpttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF32}, arf::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctpttr(uplo, n, ap, a, lda, info) + @ccall libblastrampoline.ctpttr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ctrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info) + @ccall libblastrampoline.ctrcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + rcond::Ref{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, + info) + @ccall libblastrampoline.ctrevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF32}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, + rwork, lrwork, info) + @ccall libblastrampoline.ctrevc3_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info) + @ccall libblastrampoline.ctrexc_(compq::Ref{UInt8}, n::Ref{BlasInt}, t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + ifst::Ref{BlasInt}, ilst::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ctrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.ctrrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{ComplexF32}, + rwork::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ctrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info) + @ccall libblastrampoline.ctrsen_(job::Ref{UInt8}, compq::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + w::Ptr{ComplexF32}, + m::Ref{BlasInt}, s::Ref{Float32}, sep::Ref{Float32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, + ldwork, rwork, info) + @ccall libblastrampoline.ctrsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + vl::Ptr{ComplexF32}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF32}, + ldvr::Ref{BlasInt}, s::Ptr{Float32}, sep::Ptr{Float32}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF32}, + ldwork::Ref{BlasInt}, rwork::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + @ccall libblastrampoline.ctrsyl_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + scale::Ref{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ctrsyl3(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, swork, ldswork, + info) + @ccall libblastrampoline.ctrsyl3_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + scale::Ref{Float32}, + swork::Ptr{Float32}, ldswork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrti2(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.ctrti2_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrtri(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.ctrtri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ctrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.ctrtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, b::Ptr{ComplexF32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function ctrttf(transr, uplo, n, a, lda, arf, info) + @ccall libblastrampoline.ctrttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + arf::Ptr{ComplexF32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ctrttp(uplo, n, a, lda, ap, info) + @ccall libblastrampoline.ctrttp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, ap::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ctzrzf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.ctzrzf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, + theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + @ccall libblastrampoline.cunbdb_(trans::Ref{UInt8}, signs::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, x11::Ptr{ComplexF32}, + ldx11::Ref{BlasInt}, x12::Ptr{ComplexF32}, + ldx12::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + x22::Ptr{ComplexF32}, + ldx22::Ref{BlasInt}, theta::Ptr{Float32}, + phi::Ptr{Float32}, + taup1::Ptr{ComplexF32}, taup2::Ptr{ComplexF32}, + tauq1::Ptr{ComplexF32}, tauq2::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.cunbdb1_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, + phi::Ptr{Float32}, taup1::Ptr{ComplexF32}, + taup2::Ptr{ComplexF32}, tauq1::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.cunbdb2_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, + phi::Ptr{Float32}, taup1::Ptr{ComplexF32}, + taup2::Ptr{ComplexF32}, tauq1::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.cunbdb3_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, + phi::Ptr{Float32}, taup1::Ptr{ComplexF32}, + taup2::Ptr{ComplexF32}, tauq1::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, + work, lwork, info) + @ccall libblastrampoline.cunbdb4_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, + phi::Ptr{Float32}, taup1::Ptr{ComplexF32}, + taup2::Ptr{ComplexF32}, tauq1::Ptr{ComplexF32}, + phantom::Ptr{ComplexF32}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.cunbdb5_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{ComplexF32}, incx1::Ref{BlasInt}, + x2::Ptr{ComplexF32}, + incx2::Ref{BlasInt}, q1::Ptr{ComplexF32}, + ldq1::Ref{BlasInt}, + q2::Ptr{ComplexF32}, ldq2::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.cunbdb6_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{ComplexF32}, incx1::Ref{BlasInt}, + x2::Ptr{ComplexF32}, + incx2::Ref{BlasInt}, q1::Ptr{ComplexF32}, + ldq1::Ref{BlasInt}, + q2::Ptr{ComplexF32}, ldq2::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, + x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, + work, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.cuncsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, + signs::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x12::Ptr{ComplexF32}, + ldx12::Ref{BlasInt}, x21::Ptr{ComplexF32}, + ldx21::Ref{BlasInt}, + x22::Ptr{ComplexF32}, ldx22::Ref{BlasInt}, + theta::Ptr{Float32}, + u1::Ptr{ComplexF32}, ldu1::Ref{BlasInt}, + u2::Ptr{ComplexF32}, + ldu2::Ref{BlasInt}, v1t::Ptr{ComplexF32}, + ldv1t::Ref{BlasInt}, + v2t::Ptr{ComplexF32}, ldv2t::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, + u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.cuncsd2by1_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF32}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF32}, ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, u1::Ptr{ComplexF32}, + ldu1::Ref{BlasInt}, u2::Ptr{ComplexF32}, + ldu2::Ref{BlasInt}, + v1t::Ptr{ComplexF32}, ldv1t::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + rwork::Ptr{Float32}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cung2l(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.cung2l_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cung2r(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.cung2r_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cungbr(vect, m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cungbr_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cunghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cunghr_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cungl2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.cungl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cunglq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cunglq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cungql(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cungql_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cungqr(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cungqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cungr2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.cungr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cungrq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cungrq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function cungtr(uplo, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.cungtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.cungtsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.cungtsqr_row_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, ldt::Ref{BlasInt}, + work::Ptr{ComplexF32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function cunhr_col(m, n, nb, a, lda, t, ldt, d, info) + @ccall libblastrampoline.cunhr_col_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + t::Ptr{ComplexF32}, + ldt::Ref{BlasInt}, d::Ptr{ComplexF32}, + info::Ref{BlasInt})::Cvoid +end + +function cunm22(side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunm22_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + q::Ptr{ComplexF32}, ldq::Ref{BlasInt}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.cunm2l_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.cunm2r_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmbr_(vect::Ref{UInt8}, side::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmhr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF32}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function cunml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.cunml2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmql_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunmr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.cunmr2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunmr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.cunmr3_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function cunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmrq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmrz_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function cunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.cunmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF32}, + c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function cupgtr(uplo, n, ap, tau, q, ldq, work, info) + @ccall libblastrampoline.cupgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + tau::Ptr{ComplexF32}, q::Ptr{ComplexF32}, + ldq::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function cupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + @ccall libblastrampoline.cupmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, ap::Ptr{ComplexF32}, + tau::Ptr{ComplexF32}, c::Ptr{ComplexF32}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, + ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, + b22e, work, lwork, info) + @ccall libblastrampoline.dbbcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, theta::Ptr{Float64}, + phi::Ptr{Float64}, u1::Ptr{Float64}, + ldu1::Ref{BlasInt}, + u2::Ptr{Float64}, ldu2::Ref{BlasInt}, + v1t::Ptr{Float64}, + ldv1t::Ref{BlasInt}, v2t::Ptr{Float64}, + ldv2t::Ref{BlasInt}, + b11d::Ptr{Float64}, b11e::Ptr{Float64}, + b12d::Ptr{Float64}, + b12e::Ptr{Float64}, b21d::Ptr{Float64}, + b21e::Ptr{Float64}, + b22d::Ptr{Float64}, b22e::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info) + @ccall libblastrampoline.dbdsdc_(uplo::Ref{UInt8}, compq::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, u::Ptr{Float64}, + ldu::Ref{BlasInt}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, + q::Ptr{Float64}, iq::Ptr{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + @ccall libblastrampoline.dbdsqr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ncvt::Ref{BlasInt}, + nru::Ref{BlasInt}, ncc::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, vt::Ptr{Float64}, ldvt::Ref{BlasInt}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dbdsvdx(uplo, jobz, range, n, d, e, vl, vu, il, iu, ns, s, z, ldz, work, iwork, + info) + @ccall libblastrampoline.dbdsvdx_(uplo::Ref{UInt8}, jobz::Ref{UInt8}, range::Ref{UInt8}, + n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, ns::Ref{BlasInt}, s::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ddisna(job, m, n, d, sep, info) + @ccall libblastrampoline.ddisna_(job::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + d::Ptr{Float64}, + sep::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, + info) + @ccall libblastrampoline.dgbbrd_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + ncc::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, pt::Ptr{Float64}, + ldpt::Ref{BlasInt}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dgbcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.dgbequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.dgbequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, + berr, work, iwork, info) + @ccall libblastrampoline.dgbrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dgbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, + ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.dgbrfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + r::Ptr{Float64}, + c::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.dgbsv_(n::Ref{BlasInt}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dgbsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgbsvxx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, + nparams, params, work, iwork, info) + @ccall libblastrampoline.dgbsvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.dgbtf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.dgbtrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.dgbtrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + @ccall libblastrampoline.dgebak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float64}, + m::Ref{BlasInt}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgebal(job, n, a, lda, ilo, ihi, scale, info) + @ccall libblastrampoline.dgebal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + @ccall libblastrampoline.dgebd2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, tauq::Ptr{Float64}, + taup::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + @ccall libblastrampoline.dgebrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, tauq::Ptr{Float64}, + taup::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgecon(norm, n, a, lda, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dgecon_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.dgeequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + r::Ptr{Float64}, c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.dgeequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + r::Ptr{Float64}, c::Ptr{Float64}, + rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, + info) + @ccall libblastrampoline.dgees_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + sdim::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + vs::Ptr{Float64}, ldvs::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dgeesx(jobvs, sort, select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, + rcondv, work, lwork, iwork, liwork, bwork, info) + @ccall libblastrampoline.dgeesx_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, sdim::Ref{BlasInt}, + wr::Ptr{Float64}, + wi::Ptr{Float64}, vs::Ptr{Float64}, ldvs::Ref{BlasInt}, + rconde::Ref{Float64}, rcondv::Ref{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) + @ccall libblastrampoline.dgeev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, wr::Ptr{Float64}, + wi::Ptr{Float64}, vl::Ptr{Float64}, ldvl::Ref{BlasInt}, + vr::Ptr{Float64}, ldvr::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dgeevx(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, + ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info) + @ccall libblastrampoline.dgeevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + vl::Ptr{Float64}, ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float64}, abnrm::Ref{Float64}, + rconde::Ptr{Float64}, rcondv::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dgehd2(n, ilo, ihi, a, lda, tau, work, info) + @ccall libblastrampoline.dgehd2_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgehrd_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, + lwork, iwork, info) + @ccall libblastrampoline.dgejsv_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + jobr::Ptr{UInt8}, jobt::Ptr{UInt8}, jobp::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + sva::Ptr{Float64}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dgelq(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.dgelq_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, tsize::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgelq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.dgelq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgelqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgelqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgelqt(m, n, mb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.dgelqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dgelqt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.dgelqt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.dgels_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info) + @ccall libblastrampoline.dgelsd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + s::Ptr{Float64}, rcond::Ref{Float64}, + rank::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) + @ccall libblastrampoline.dgelss_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + s::Ptr{Float64}, rcond::Ref{Float64}, + rank::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgelst(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.dgelst_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info) + @ccall libblastrampoline.dgelsy_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, rcond::Ref{Float64}, + rank::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.dgemlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, tsize::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.dgemlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + v::Ptr{Float64}, + ldv::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.dgemqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, tsize::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.dgemqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + v::Ptr{Float64}, + ldv::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgeql2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.dgeql2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqlf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgeqlf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqp3(m, n, a, lda, jpvt, tau, work, lwork, info) + @ccall libblastrampoline.dgeqp3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgeqp3rk(m, n, nrhs, kmax, abstol, reltol, a, lda, k, maxc2nrmk, relmaxc2nrmk, + jpiv, tau, work, lwork, iwork, info) + @ccall libblastrampoline.dgeqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + kmax::Ref{BlasInt}, abstol::Ref{Float64}, + reltol::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgeqr(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.dgeqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, tsize::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgeqr2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.dgeqr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqr2p(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.dgeqr2p_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqrf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgeqrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqrfp(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgeqrfp_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqrt(m, n, nb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.dgeqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dgeqrt2(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.dgeqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgeqrt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.dgeqrt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.dgerfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + iwork, info) + @ccall libblastrampoline.dgerfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgerq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.dgerq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dgerqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dgerqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + @ccall libblastrampoline.dgesc2_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + rhs::Ptr{Float64}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt}, + scale::Ref{Float64})::Cvoid +end + +function dgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) + @ccall libblastrampoline.dgesdd_(jobz::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, s::Ptr{Float64}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.dgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) + @ccall libblastrampoline.dgesvd_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + vt::Ptr{Float64}, ldvt::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, + iwork, liwork, work, lwork, rwork, lrwork, info) + @ccall libblastrampoline.dgesvdq_(joba::Ref{UInt8}, jobp::Ref{UInt8}, jobr::Ref{UInt8}, + jobu::Ref{UInt8}, jobv::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, + numrank::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dgesvdx(jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, ns, s, u, ldu, vt, ldvt, + work, lwork, iwork, info) + @ccall libblastrampoline.dgesvdx_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, + range::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, ns::Ref{BlasInt}, s::Ptr{Float64}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) + @ccall libblastrampoline.dgesvj_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + sva::Ptr{Float64}, mv::Ref{BlasInt}, v::Ptr{Float64}, + ldv::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dgesvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float64}, c::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dgesvxx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.dgesvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float64}, c::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgetc2(n, a, lda, ipiv, jpiv, info) + @ccall libblastrampoline.dgetc2_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, jpiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgetf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.dgetf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgetrf(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.dgetrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgetrf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.dgetrf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgetri(n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.dgetri_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.dgetrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.dgetsls_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.dgetsqrhrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb1::Ref{BlasInt}, + nb1::Ref{BlasInt}, nb2::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + @ccall libblastrampoline.dggbak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float64}, + rscale::Ptr{Float64}, m::Ref{BlasInt}, v::Ptr{Float64}, + ldv::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + @ccall libblastrampoline.dggbal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float64}, + rscale::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, + vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + @ccall libblastrampoline.dgges_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, vsl::Ptr{Float64}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{Float64}, ldvsr::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgges3(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, + vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + @ccall libblastrampoline.dgges3_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, vsl::Ptr{Float64}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{Float64}, ldvsr::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dggesx(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alphar, + alphai, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, + liwork, bwork, info) + @ccall libblastrampoline.dggesx_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, sense::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, sdim::Ref{BlasInt}, + alphar::Ptr{Float64}, + alphai::Ptr{Float64}, beta::Ptr{Float64}, + vsl::Ptr{Float64}, + ldvsl::Ref{BlasInt}, vsr::Ptr{Float64}, + ldvsr::Ref{BlasInt}, + rconde::Ptr{Float64}, rcondv::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, + work, lwork, info) + @ccall libblastrampoline.dggev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, vl::Ptr{Float64}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float64}, ldvr::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dggev3(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, + work, lwork, info) + @ccall libblastrampoline.dggev3_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, vl::Ptr{Float64}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float64}, ldvr::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl, + ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, + work, lwork, iwork, bwork, info) + @ccall libblastrampoline.dggevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + alphar::Ptr{Float64}, alphai::Ptr{Float64}, + beta::Ptr{Float64}, vl::Ptr{Float64}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float64}, ldvr::Ref{BlasInt}, + ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, lscale::Ptr{Float64}, + rscale::Ptr{Float64}, + abnrm::Ref{Float64}, bbnrm::Ref{Float64}, + rconde::Ptr{Float64}, rcondv::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + bwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + @ccall libblastrampoline.dggglm_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + d::Ptr{Float64}, x::Ptr{Float64}, y::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgghd3(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, + info) + @ccall libblastrampoline.dgghd3_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + @ccall libblastrampoline.dgghrd_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + @ccall libblastrampoline.dgglse_(m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + c::Ptr{Float64}, d::Ptr{Float64}, x::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.dggqrf_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, taua::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, taub::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.dggrqf_(m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, taua::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, taub::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dggsvd3(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, + ldv, q, ldq, work, lwork, iwork, info) + @ccall libblastrampoline.dggsvd3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + alpha::Ptr{Float64}, + beta::Ptr{Float64}, u::Ptr{Float64}, + ldu::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dggsvp3(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, + ldv, q, ldq, iwork, tau, work, lwork, info) + @ccall libblastrampoline.dggsvp3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + tola::Ref{Float64}, tolb::Ref{Float64}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, iwork::Ptr{BlasInt}, + tau::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.dgsvj0_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, d::Ptr{Float64}, + sva::Ptr{Float64}, mv::Ref{BlasInt}, v::Ptr{Float64}, + ldv::Ref{BlasInt}, eps::Ref{Float64}, + sfmin::Ref{Float64}, + tol::Ref{Float64}, nsweep::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.dgsvj1_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + n1::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, d::Ptr{Float64}, + sva::Ptr{Float64}, mv::Ref{BlasInt}, v::Ptr{Float64}, + ldv::Ref{BlasInt}, eps::Ref{Float64}, + sfmin::Ref{Float64}, + tol::Ref{Float64}, nsweep::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dgtcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{Float64}, + d::Ptr{Float64}, du::Ptr{Float64}, du2::Ptr{Float64}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, + berr, work, iwork, info) + @ccall libblastrampoline.dgtrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{Float64}, d::Ptr{Float64}, du::Ptr{Float64}, + dlf::Ptr{Float64}, df::Ptr{Float64}, duf::Ptr{Float64}, + du2::Ptr{Float64}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dgtsv(n, nrhs, dl, d, du, b, ldb, info) + @ccall libblastrampoline.dgtsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, dl::Ptr{Float64}, + d::Ptr{Float64}, du::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dgtsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, dl::Ptr{Float64}, d::Ptr{Float64}, + du::Ptr{Float64}, dlf::Ptr{Float64}, df::Ptr{Float64}, + duf::Ptr{Float64}, du2::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dgttrf(n, dl, d, du, du2, ipiv, info) + @ccall libblastrampoline.dgttrf_(n::Ref{BlasInt}, dl::Ptr{Float64}, d::Ptr{Float64}, + du::Ptr{Float64}, du2::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + @ccall libblastrampoline.dgttrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{Float64}, d::Ptr{Float64}, du::Ptr{Float64}, + du2::Ptr{Float64}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + @ccall libblastrampoline.dgtts2_(itrans::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + dl::Ptr{Float64}, d::Ptr{Float64}, du::Ptr{Float64}, + du2::Ptr{Float64}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt})::Cvoid +end + +function dhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, + ldq, z, ldz, work, lwork, info) + @ccall libblastrampoline.dhgeqz_(job::Ref{UInt8}, compq::Ref{UInt8}, compz::Ref{UInt8}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{Float64}, ldh::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dhsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, + work, ifaill, ifailr, info) + @ccall libblastrampoline.dhsein_(side::Ref{UInt8}, eigsrc::Ref{UInt8}, + initv::Ref{UInt8}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + vl::Ptr{Float64}, ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float64}, ifaill::Ptr{BlasInt}, + ifailr::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dhseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info) + @ccall libblastrampoline.dhseqr_(job::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) + @ccall libblastrampoline.dla_gbamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + alpha::Ref{Float64}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + x::Ptr{Float64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function dla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, + iwork) + @ccall libblastrampoline.dla_gbrcond_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + afb::Ptr{Float64}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + cmode::Ref{BlasInt}, c::Ptr{Float64}, + info::Ref{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + 1::Clong)::Float64 +end + +function dla_gbrfsx_extended(prec_type, trans_type, n, kl, ku, nrhs, ab, ldab, afb, ldafb, + ipiv, colequ, c, b, ldb, y, ldy, berr_out, n_norms, + err_bnds_norm, err_bnds_comp, res, ayb, dy, y_tail, rcond, + ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.dla_gbrfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + y::Ptr{Float64}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{Float64}, + ayb::Ptr{Float64}, dy::Ptr{Float64}, + y_tail::Ptr{Float64}, rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb) + @ccall libblastrampoline.dla_gbrpvgrw_(n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ncols::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + afb::Ptr{Float64}, ldafb::Ref{BlasInt})::Float64 +end + +function dla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dla_geamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + x::Ptr{Float64}, incx::Ref{BlasInt}, + beta::Ref{Float64}, + y::Ptr{Float64}, incy::Ref{BlasInt})::Cvoid +end + +function dla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) + @ccall libblastrampoline.dla_gercond_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, cmode::Ref{BlasInt}, + c::Ptr{Float64}, + info::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + 1::Clong)::Float64 +end + +function dla_gerfsx_extended(prec_type, trans_type, n, nrhs, a, lda, af, ldaf, ipiv, colequ, + c, b, ldb, y, ldy, berr_out, n_norms, errs_n, errs_c, res, ayb, + dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.dla_gerfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + y::Ptr{Float64}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + errs_n::Ptr{Float64}, + errs_c::Ptr{Float64}, + res::Ptr{Float64}, ayb::Ptr{Float64}, + dy::Ptr{Float64}, y_tail::Ptr{Float64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dla_gerpvgrw(n, ncols, a, lda, af, ldaf) + @ccall libblastrampoline.dla_gerpvgrw_(n::Ref{BlasInt}, ncols::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt})::Float64 +end + +function dla_lin_berr(n, nz, nrhs, res, ayb, berr) + @ccall libblastrampoline.dla_lin_berr_(n::Ref{BlasInt}, nz::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + res::Ptr{Float64}, ayb::Ptr{Float64}, + berr::Ptr{Float64})::Cvoid +end + +function dla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork) + @ccall libblastrampoline.dla_porcond_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, + cmode::Ref{BlasInt}, c::Ptr{Float64}, + info::Ref{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + 1::Clong)::Float64 +end + +function dla_porfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, colequ, c, b, ldb, + y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, res, + ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, + info) + @ccall libblastrampoline.dla_porfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, y::Ptr{Float64}, + ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{Float64}, + ayb::Ptr{Float64}, dy::Ptr{Float64}, + y_tail::Ptr{Float64}, rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work) + @ccall libblastrampoline.dla_porpvgrw_(uplo::Ptr{UInt8}, ncols::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Float64 +end + +function dla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.dla_syamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, x::Ptr{Float64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function dla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) + @ccall libblastrampoline.dla_syrcond_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, cmode::Ref{BlasInt}, + c::Ptr{Float64}, + info::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + 1::Clong)::Float64 +end + +function dla_syrfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.dla_syrfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + y::Ptr{Float64}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{Float64}, + ayb::Ptr{Float64}, dy::Ptr{Float64}, + y_tail::Ptr{Float64}, rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.dla_syrpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + af::Ptr{Float64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function dla_wwaddw(n, x, y, w) + @ccall libblastrampoline.dla_wwaddw_(n::Ref{BlasInt}, x::Ptr{Float64}, y::Ptr{Float64}, + w::Ptr{Float64})::Cvoid +end + +function dlabad(small, large) + @ccall libblastrampoline.dlabad_(small::Ref{Float64}, large::Ref{Float64})::Cvoid +end + +function dlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + @ccall libblastrampoline.dlabrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tauq::Ptr{Float64}, taup::Ptr{Float64}, + x::Ptr{Float64}, + ldx::Ref{BlasInt}, y::Ptr{Float64}, + ldy::Ref{BlasInt})::Cvoid +end + +function dlacn2(n, v, x, isgn, est, kase, isave) + @ccall libblastrampoline.dlacn2_(n::Ref{BlasInt}, v::Ptr{Float64}, x::Ptr{Float64}, + isgn::Ptr{BlasInt}, est::Ref{Float64}, + kase::Ref{BlasInt}, + isave::Ptr{BlasInt})::Cvoid +end + +function dlacon(n, v, x, isgn, est, kase) + @ccall libblastrampoline.dlacon_(n::Ref{BlasInt}, v::Ptr{Float64}, x::Ptr{Float64}, + isgn::Ptr{BlasInt}, est::Ref{Float64}, + kase::Ref{BlasInt})::Cvoid +end + +function dlacpy(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.dlacpy_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dladiv(a, b, c, d, p, q) + @ccall libblastrampoline.dladiv_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + d::Ref{Float64}, p::Ref{Float64}, + q::Ref{Float64})::Cvoid +end + +function dladiv1(a, b, c, d, p, q) + @ccall libblastrampoline.dladiv1_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + d::Ref{Float64}, p::Ref{Float64}, + q::Ref{Float64})::Cvoid +end + +function dladiv2(a, b, c, d, r, t) + @ccall libblastrampoline.dladiv2_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + d::Ref{Float64}, r::Ref{Float64}, + t::Ref{Float64})::Float64 +end + +function dlae2(a, b, c, rt1, rt2) + @ccall libblastrampoline.dlae2_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + rt1::Ref{Float64}, rt2::Ref{Float64})::Cvoid +end + +function dlaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, + ab, c, mout, nab, work, iwork, info) + @ccall libblastrampoline.dlaebz_(ijob::Ref{BlasInt}, nitmax::Ref{BlasInt}, + n::Ref{BlasInt}, + mmax::Ref{BlasInt}, minp::Ref{BlasInt}, + nbmin::Ref{BlasInt}, + abstol::Ref{Float64}, reltol::Ref{Float64}, + pivmin::Ref{Float64}, d::Ptr{Float64}, e::Ptr{Float64}, + e2::Ptr{Float64}, nval::Ptr{BlasInt}, ab::Ptr{Float64}, + c::Ptr{Float64}, mout::Ref{BlasInt}, nab::Ptr{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info) + @ccall libblastrampoline.dlaed0_(icompq::Ref{BlasInt}, qsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, qstore::Ptr{Float64}, + ldqs::Ref{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) + @ccall libblastrampoline.dlaed1_(n::Ref{BlasInt}, d::Ptr{Float64}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, indxq::Ptr{BlasInt}, + rho::Ref{Float64}, + cutpnt::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed2(k, n, n1, d, q, ldq, indxq, rho, z, dlambda, w, q2, indx, indxc, indxp, + coltyp, info) + @ccall libblastrampoline.dlaed2_(k::Ref{BlasInt}, n::Ref{BlasInt}, n1::Ref{BlasInt}, + d::Ptr{Float64}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, + indxq::Ptr{BlasInt}, + rho::Ref{Float64}, z::Ptr{Float64}, + dlambda::Ptr{Float64}, + w::Ptr{Float64}, q2::Ptr{Float64}, indx::Ptr{BlasInt}, + indxc::Ptr{BlasInt}, indxp::Ptr{BlasInt}, + coltyp::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed3(k, n, n1, d, q, ldq, rho, dlambda, q2, indx, ctot, w, s, info) + @ccall libblastrampoline.dlaed3_(k::Ref{BlasInt}, n::Ref{BlasInt}, n1::Ref{BlasInt}, + d::Ptr{Float64}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, rho::Ref{Float64}, + dlambda::Ptr{Float64}, q2::Ptr{Float64}, + indx::Ptr{BlasInt}, + ctot::Ptr{BlasInt}, w::Ptr{Float64}, s::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed4(n, i, d, z, delta, rho, dlam, info) + @ccall libblastrampoline.dlaed4_(n::Ref{BlasInt}, i::Ref{BlasInt}, d::Ptr{Float64}, + z::Ptr{Float64}, + delta::Ptr{Float64}, rho::Ref{Float64}, + dlam::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed5(i, d, z, delta, rho, dlam) + @ccall libblastrampoline.dlaed5_(i::Ref{BlasInt}, d::Ptr{Float64}, z::Ptr{Float64}, + delta::Ptr{Float64}, rho::Ref{Float64}, + dlam::Ref{Float64})::Cvoid +end + +function dlaed6(kniter, orgati, rho, d, z, finit, tau, info) + @ccall libblastrampoline.dlaed6_(kniter::Ref{BlasInt}, orgati::Ref{BlasInt}, + rho::Ref{Float64}, + d::Ptr{Float64}, z::Ptr{Float64}, finit::Ref{Float64}, + tau::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, + qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info) + @ccall libblastrampoline.dlaed7_(icompq::Ref{BlasInt}, n::Ref{BlasInt}, + qsiz::Ref{BlasInt}, + tlvls::Ref{BlasInt}, curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, + d::Ptr{Float64}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + indxq::Ptr{BlasInt}, rho::Ref{Float64}, + cutpnt::Ref{BlasInt}, + qstore::Ptr{Float64}, qptr::Ptr{BlasInt}, + prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + givnum::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlambda, q2, ldq2, w, + perm, givptr, givcol, givnum, indxp, indx, info) + @ccall libblastrampoline.dlaed8_(icompq::Ref{BlasInt}, k::Ref{BlasInt}, n::Ref{BlasInt}, + qsiz::Ref{BlasInt}, d::Ptr{Float64}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, indxq::Ptr{BlasInt}, + rho::Ref{Float64}, + cutpnt::Ref{BlasInt}, z::Ptr{Float64}, + dlambda::Ptr{Float64}, + q2::Ptr{Float64}, ldq2::Ref{BlasInt}, w::Ptr{Float64}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + givnum::Ptr{Float64}, indxp::Ptr{BlasInt}, + indx::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaed9(k, kstart, kstop, n, d, q, ldq, rho, dlambda, w, s, lds, info) + @ccall libblastrampoline.dlaed9_(k::Ref{BlasInt}, kstart::Ref{BlasInt}, + kstop::Ref{BlasInt}, + n::Ref{BlasInt}, d::Ptr{Float64}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, rho::Ref{Float64}, + dlambda::Ptr{Float64}, + w::Ptr{Float64}, s::Ptr{Float64}, lds::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, + ztemp, info) + @ccall libblastrampoline.dlaeda_(n::Ref{BlasInt}, tlvls::Ref{BlasInt}, + curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, + givptr::Ptr{BlasInt}, givcol::Ptr{BlasInt}, + givnum::Ptr{Float64}, + q::Ptr{Float64}, qptr::Ptr{BlasInt}, z::Ptr{Float64}, + ztemp::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, + bignum, info) + @ccall libblastrampoline.dlaein_(rightv::Ref{BlasInt}, noinit::Ref{BlasInt}, + n::Ref{BlasInt}, + h::Ptr{Float64}, ldh::Ref{BlasInt}, wr::Ref{Float64}, + wi::Ref{Float64}, vr::Ptr{Float64}, vi::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, work::Ptr{Float64}, + eps3::Ref{Float64}, smlnum::Ref{Float64}, + bignum::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlaev2(a, b, c, rt1, rt2, cs1, sn1) + @ccall libblastrampoline.dlaev2_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + rt1::Ref{Float64}, rt2::Ref{Float64}, + cs1::Ref{Float64}, + sn1::Ref{Float64})::Cvoid +end + +function dlaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) + @ccall libblastrampoline.dlaexc_(wantq::Ref{BlasInt}, n::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + j1::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlag2(a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) + @ccall libblastrampoline.dlag2_(a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, safmin::Ref{Float64}, + scale1::Ref{Float64}, + scale2::Ref{Float64}, wr1::Ref{Float64}, + wr2::Ref{Float64}, + wi::Ref{Float64})::Cvoid +end + +function dlag2s(m, n, a, lda, sa, ldsa, info) + @ccall libblastrampoline.dlag2s_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + sa::Ptr{Float32}, ldsa::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + @ccall libblastrampoline.dlags2_(upper::Ref{BlasInt}, a1::Ref{Float64}, + a2::Ref{Float64}, + a3::Ref{Float64}, b1::Ref{Float64}, b2::Ref{Float64}, + b3::Ref{Float64}, csu::Ref{Float64}, snu::Ref{Float64}, + csv::Ref{Float64}, snv::Ref{Float64}, + csq::Ref{Float64}, + snq::Ref{Float64})::Cvoid +end + +function dlagtf(n, a, lambda, b, c, tol, d, in, info) + @ccall libblastrampoline.dlagtf_(n::Ref{BlasInt}, a::Ptr{Float64}, lambda::Ref{Float64}, + b::Ptr{Float64}, c::Ptr{Float64}, tol::Ref{Float64}, + d::Ptr{Float64}, in::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + @ccall libblastrampoline.dlagtm_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + alpha::Ref{Float64}, dl::Ptr{Float64}, d::Ptr{Float64}, + du::Ptr{Float64}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + beta::Ref{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlagts(job, n, a, b, c, d, in, y, tol, info) + @ccall libblastrampoline.dlagts_(job::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + b::Ptr{Float64}, c::Ptr{Float64}, d::Ptr{Float64}, + in::Ptr{BlasInt}, y::Ptr{Float64}, tol::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlagv2(a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) + @ccall libblastrampoline.dlagv2_(a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, alphar::Ptr{Float64}, + alphai::Ptr{Float64}, + beta::Ptr{Float64}, csl::Ref{Float64}, + snl::Ref{Float64}, + csr::Ref{Float64}, snr::Ref{Float64})::Cvoid +end + +function dlahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) + @ccall libblastrampoline.dlahqr_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float64}, + ldz::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dlahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + @ccall libblastrampoline.dlahr2_(n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, y::Ptr{Float64}, + ldy::Ref{BlasInt})::Cvoid +end + +function dlaic1(job, j, x, sest, w, gamma, sestpr, s, c) + @ccall libblastrampoline.dlaic1_(job::Ref{BlasInt}, j::Ref{BlasInt}, x::Ptr{Float64}, + sest::Ref{Float64}, w::Ptr{Float64}, + gamma::Ref{Float64}, + sestpr::Ref{Float64}, s::Ref{Float64}, + c::Ref{Float64})::Cvoid +end + +function dlaln2(ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, + xnorm, info) + @ccall libblastrampoline.dlaln2_(ltrans::Ref{BlasInt}, na::Ref{BlasInt}, + nw::Ref{BlasInt}, + smin::Ref{Float64}, ca::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, d1::Ref{Float64}, d2::Ref{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, wr::Ref{Float64}, + wi::Ref{Float64}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + scale::Ref{Float64}, xnorm::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, + givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) + @ccall libblastrampoline.dlals0_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, nrhs::Ref{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, bx::Ptr{Float64}, + ldbx::Ref{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, givnum::Ptr{Float64}, + ldgnum::Ref{BlasInt}, + poles::Ptr{Float64}, difl::Ptr{Float64}, + difr::Ptr{Float64}, + z::Ptr{Float64}, k::Ref{BlasInt}, c::Ref{Float64}, + s::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, + poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + @ccall libblastrampoline.dlalsa_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + bx::Ptr{Float64}, ldbx::Ref{BlasInt}, u::Ptr{Float64}, + ldu::Ref{BlasInt}, vt::Ptr{Float64}, k::Ptr{BlasInt}, + difl::Ptr{Float64}, difr::Ptr{Float64}, + z::Ptr{Float64}, + poles::Ptr{Float64}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, perm::Ptr{BlasInt}, + givnum::Ptr{Float64}, + c::Ptr{Float64}, s::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) + @ccall libblastrampoline.dlalsd_(uplo::Ref{UInt8}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + rcond::Ref{Float64}, + rank::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlamrg(n1, n2, a, dtrd1, dtrd2, index) + @ccall libblastrampoline.dlamrg_(n1::Ref{BlasInt}, n2::Ref{BlasInt}, a::Ptr{Float64}, + dtrd1::Ref{BlasInt}, dtrd2::Ref{BlasInt}, + index::Ptr{BlasInt})::Cvoid +end + +function dlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.dlamswlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.dlamtsqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dlaneg(n, d, lld, sigma, pivmin, r) + @ccall libblastrampoline.dlaneg_(n::Ref{BlasInt}, d::Ptr{Float64}, lld::Ptr{Float64}, + sigma::Ref{Float64}, pivmin::Ref{Float64}, + r::Ref{BlasInt})::BlasInt +end + +function dlangb(norm, n, kl, ku, ab, ldab, work) + @ccall libblastrampoline.dlangb_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function dlange(norm, m, n, a, lda, work) + @ccall libblastrampoline.dlange_(norm::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function dlangt(norm, n, dl, d, du) + @ccall libblastrampoline.dlangt_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{Float64}, + d::Ptr{Float64}, du::Ptr{Float64}, 1::Clong)::Float64 +end + +function dlanhs(norm, n, a, lda, work) + @ccall libblastrampoline.dlanhs_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function dlansb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.dlansb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{Float64}, ldab::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong, 1::Clong)::Float64 +end + +function dlansf(norm, transr, uplo, n, a, work) + @ccall libblastrampoline.dlansf_(norm::Ref{UInt8}, transr::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, work::Ptr{Float64}, + 1::Clong, 1::Clong, 1::Clong)::Float64 +end + +function dlansp(norm, uplo, n, ap, work) + @ccall libblastrampoline.dlansp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, work::Ptr{Float64}, 1::Clong, + 1::Clong)::Float64 +end + +function dlanst(norm, n, d, e) + @ccall libblastrampoline.dlanst_(norm::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, 1::Clong)::Float64 +end + +function dlansy(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.dlansy_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, work::Ptr{Float64}, + 1::Clong, 1::Clong)::Float64 +end + +function dlantb(norm, uplo, diag, n, k, ab, ldab, work) + @ccall libblastrampoline.dlantb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong, + 1::Clong, + 1::Clong)::Float64 +end + +function dlantp(norm, uplo, diag, n, ap, work) + @ccall libblastrampoline.dlantp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, work::Ptr{Float64}, + 1::Clong, 1::Clong, 1::Clong)::Float64 +end + +function dlantr(norm, uplo, diag, m, n, a, lda, work) + @ccall libblastrampoline.dlantr_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong, 1::Clong, + 1::Clong)::Float64 +end + +function dlanv2(a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) + @ccall libblastrampoline.dlanv2_(a::Ref{Float64}, b::Ref{Float64}, c::Ref{Float64}, + d::Ref{Float64}, rt1r::Ref{Float64}, + rt1i::Ref{Float64}, + rt2r::Ref{Float64}, rt2i::Ref{Float64}, + cs::Ref{Float64}, + sn::Ref{Float64})::Cvoid +end + +function dlaorhr_col_getrfnp(m, n, a, lda, d, info) + @ccall libblastrampoline.dlaorhr_col_getrfnp_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlaorhr_col_getrfnp2(m, n, a, lda, d, info) + @ccall libblastrampoline.dlaorhr_col_getrfnp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlapll(n, x, incx, y, incy, ssmin) + @ccall libblastrampoline.dlapll_(n::Ref{BlasInt}, x::Ptr{Float64}, incx::Ref{BlasInt}, + y::Ptr{Float64}, incy::Ref{BlasInt}, + ssmin::Ref{Float64})::Cvoid +end + +function dlapmr(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.dlapmr_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function dlapmt(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.dlapmt_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function dlapy2(x, y) + @ccall libblastrampoline.dlapy2_(x::Ref{Float64}, y::Ref{Float64})::Float64 +end + +function dlapy3(x, y, z) + @ccall libblastrampoline.dlapy3_(x::Ref{Float64}, y::Ref{Float64}, + z::Ref{Float64})::Float64 +end + +function dlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.dlaqgb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function dlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.dlaqge_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + r::Ptr{Float64}, c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, amax::Ref{Float64}, + equed::Ref{UInt8}, + 1::Clong)::Cvoid +end + +function dlaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + @ccall libblastrampoline.dlaqp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + tau::Ptr{Float64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + work::Ptr{Float64})::Cvoid +end + +function dlaqp2rk(m, n, nrhs, ioffset, kmax, abstol, reltol, kp1, maxc2nrm, a, lda, k, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, work, info) + @ccall libblastrampoline.dlaqp2rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, kmax::Ref{BlasInt}, + abstol::Ref{Float64}, + reltol::Ref{Float64}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlaqp3rk(m, n, nrhs, ioffset, nb, abstol, reltol, kp1, maxc2nrm, a, lda, done, kb, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, auxv, f, ldf, iwork, info) + @ccall libblastrampoline.dlaqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, nb::Ref{BlasInt}, + abstol::Ref{Float64}, + reltol::Ref{Float64}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float64}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + done::Ref{BlasInt}, kb::Ref{BlasInt}, + maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + auxv::Ptr{Float64}, f::Ptr{Float64}, + ldf::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + @ccall libblastrampoline.dlaqps_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{Float64}, + vn1::Ptr{Float64}, + vn2::Ptr{Float64}, auxv::Ptr{Float64}, f::Ptr{Float64}, + ldf::Ref{BlasInt})::Cvoid +end + +function dlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, + info) + @ccall libblastrampoline.dlaqr0_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaqr1(n, h, ldh, sr1, si1, sr2, si2, v) + @ccall libblastrampoline.dlaqr1_(n::Ref{BlasInt}, h::Ptr{Float64}, ldh::Ref{BlasInt}, + sr1::Ref{Float64}, si1::Ref{Float64}, + sr2::Ref{Float64}, + si2::Ref{Float64}, v::Ptr{Float64})::Cvoid +end + +function dlaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, + v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.dlaqr2_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{Float64}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, sr::Ptr{Float64}, + si::Ptr{Float64}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{Float64}, ldwv::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt})::Cvoid +end + +function dlaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, + v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.dlaqr3_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{Float64}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, sr::Ptr{Float64}, + si::Ptr{Float64}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{Float64}, ldwv::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt})::Cvoid +end + +function dlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, + info) + @ccall libblastrampoline.dlaqr4_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, wr::Ptr{Float64}, wi::Ptr{Float64}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, + ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + @ccall libblastrampoline.dlaqr5_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + kacc22::Ref{BlasInt}, + n::Ref{BlasInt}, ktop::Ref{BlasInt}, + kbot::Ref{BlasInt}, + nshfts::Ref{BlasInt}, sr::Ptr{Float64}, + si::Ptr{Float64}, + h::Ptr{Float64}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, u::Ptr{Float64}, + ldu::Ref{BlasInt}, nv::Ref{BlasInt}, wv::Ptr{Float64}, + ldwv::Ref{BlasInt}, nh::Ref{BlasInt}, wh::Ptr{Float64}, + ldwh::Ref{BlasInt})::Cvoid +end + +function dlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.dlaqsb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, amax::Ref{Float64}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function dlaqsp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.dlaqsp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function dlaqsy(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.dlaqsy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function dlaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info) + @ccall libblastrampoline.dlaqtr_(ltran::Ref{BlasInt}, lreal::Ref{BlasInt}, + n::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, b::Ptr{Float64}, + w::Ref{Float64}, scale::Ref{Float64}, x::Ptr{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, + mingma, r, isuppz, nrminv, resid, rqcorr, work) + @ccall libblastrampoline.dlar1v_(n::Ref{BlasInt}, b1::Ref{BlasInt}, bn::Ref{BlasInt}, + lambda::Ref{Float64}, d::Ptr{Float64}, l::Ptr{Float64}, + ld::Ptr{Float64}, lld::Ptr{Float64}, + pivmin::Ref{Float64}, + gaptol::Ref{Float64}, z::Ptr{Float64}, + wantnc::Ref{BlasInt}, + negcnt::Ref{BlasInt}, ztz::Ref{Float64}, + mingma::Ref{Float64}, + r::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + nrminv::Ref{Float64}, + resid::Ref{Float64}, rqcorr::Ref{Float64}, + work::Ptr{Float64})::Cvoid +end + +function dlar2v(n, x, y, z, incx, c, s, incc) + @ccall libblastrampoline.dlar2v_(n::Ref{BlasInt}, x::Ptr{Float64}, y::Ptr{Float64}, + z::Ptr{Float64}, incx::Ref{BlasInt}, c::Ptr{Float64}, + s::Ptr{Float64}, incc::Ref{BlasInt})::Cvoid +end + +function dlarf(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.dlarf_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float64}, + incv::Ref{BlasInt}, tau::Ref{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dlarf1f(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.dlarf1f_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float64}, incv::Ref{BlasInt}, + tau::Ref{Float64}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Cvoid +end + +function dlarf1l(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.dlarf1l_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float64}, incv::Ref{BlasInt}, + tau::Ref{Float64}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Cvoid +end + +function dlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + @ccall libblastrampoline.dlarfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork) + @ccall libblastrampoline.dlarfb_gett_(ident::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, work::Ptr{Float64}, + ldwork::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlarfg(n, alpha, x, incx, tau) + @ccall libblastrampoline.dlarfg_(n::Ref{BlasInt}, alpha::Ref{Float64}, x::Ptr{Float64}, + incx::Ref{BlasInt}, tau::Ref{Float64})::Cvoid +end + +function dlarfgp(n, alpha, x, incx, tau) + @ccall libblastrampoline.dlarfgp_(n::Ref{BlasInt}, alpha::Ref{Float64}, x::Ptr{Float64}, + incx::Ref{BlasInt}, tau::Ref{Float64})::Cvoid +end + +function dlarft(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.dlarft_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + tau::Ptr{Float64}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dlarfx(side, m, n, v, tau, c, ldc, work) + @ccall libblastrampoline.dlarfx_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float64}, tau::Ref{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dlarfy(uplo, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.dlarfy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, v::Ptr{Float64}, + incv::Ref{BlasInt}, tau::Ref{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dlargv(n, x, incx, y, incy, c, incc) + @ccall libblastrampoline.dlargv_(n::Ref{BlasInt}, x::Ptr{Float64}, incx::Ref{BlasInt}, + y::Ptr{Float64}, incy::Ref{BlasInt}, c::Ptr{Float64}, + incc::Ref{BlasInt})::Cvoid +end + +function dlarmm(anorm, bnorm, cnorm) + @ccall libblastrampoline.dlarmm_(anorm::Ref{Float64}, bnorm::Ref{Float64}, + cnorm::Ref{Float64})::Float64 +end + +function dlarnv(idist, iseed, n, x) + @ccall libblastrampoline.dlarnv_(idist::Ref{BlasInt}, iseed::Ptr{BlasInt}, + n::Ref{BlasInt}, + x::Ptr{Float64})::Cvoid +end + +function dlarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info) + @ccall libblastrampoline.dlarra_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + e2::Ptr{Float64}, spltol::Ref{Float64}, + tnrm::Ref{Float64}, + nsplit::Ref{BlasInt}, isplit::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, + pivmin, spdiam, twist, info) + @ccall libblastrampoline.dlarrb_(n::Ref{BlasInt}, d::Ptr{Float64}, lld::Ptr{Float64}, + ifirst::Ref{BlasInt}, ilast::Ref{BlasInt}, + rtol1::Ref{Float64}, + rtol2::Ref{Float64}, offset::Ref{BlasInt}, + w::Ptr{Float64}, + wgap::Ptr{Float64}, werr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, pivmin::Ref{Float64}, + spdiam::Ref{Float64}, + twist::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dlarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info) + @ccall libblastrampoline.dlarrc_(jobt::Ref{UInt8}, n::Ref{BlasInt}, vl::Ref{Float64}, + vu::Ref{Float64}, d::Ptr{Float64}, e::Ptr{Float64}, + pivmin::Ref{Float64}, eigcnt::Ref{BlasInt}, + lcnt::Ref{BlasInt}, + rcnt::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, + isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info) + @ccall libblastrampoline.dlarrd_(range::Ref{UInt8}, order::Ref{UInt8}, n::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, gers::Ptr{Float64}, + reltol::Ref{Float64}, + d::Ptr{Float64}, e::Ptr{Float64}, e2::Ptr{Float64}, + pivmin::Ref{Float64}, nsplit::Ref{BlasInt}, + isplit::Ptr{BlasInt}, + m::Ref{BlasInt}, w::Ptr{Float64}, werr::Ptr{Float64}, + wl::Ref{Float64}, wu::Ref{Float64}, + iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dlarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, + w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info) + @ccall libblastrampoline.dlarre_(range::Ref{UInt8}, n::Ref{BlasInt}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, e2::Ptr{Float64}, + rtol1::Ref{Float64}, rtol2::Ref{Float64}, + spltol::Ref{Float64}, nsplit::Ref{BlasInt}, + isplit::Ptr{BlasInt}, + m::Ref{BlasInt}, w::Ptr{Float64}, werr::Ptr{Float64}, + wgap::Ptr{Float64}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float64}, pivmin::Ref{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, + sigma, dplus, lplus, work, info) + @ccall libblastrampoline.dlarrf_(n::Ref{BlasInt}, d::Ptr{Float64}, l::Ptr{Float64}, + ld::Ptr{Float64}, clstrt::Ref{BlasInt}, + clend::Ref{BlasInt}, + w::Ptr{Float64}, wgap::Ptr{Float64}, + werr::Ptr{Float64}, + spdiam::Ref{Float64}, clgapl::Ref{Float64}, + clgapr::Ref{Float64}, pivmin::Ref{Float64}, + sigma::Ref{Float64}, dplus::Ptr{Float64}, + lplus::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, + info) + @ccall libblastrampoline.dlarrj_(n::Ref{BlasInt}, d::Ptr{Float64}, e2::Ptr{Float64}, + ifirst::Ref{BlasInt}, ilast::Ref{BlasInt}, + rtol::Ref{Float64}, + offset::Ref{BlasInt}, w::Ptr{Float64}, + werr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + pivmin::Ref{Float64}, + spdiam::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info) + @ccall libblastrampoline.dlarrk_(n::Ref{BlasInt}, iw::Ref{BlasInt}, gl::Ref{Float64}, + gu::Ref{Float64}, d::Ptr{Float64}, e2::Ptr{Float64}, + pivmin::Ref{Float64}, reltol::Ref{Float64}, + w::Ref{Float64}, + werr::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlarrr(n, d, e, info) + @ccall libblastrampoline.dlarrr_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, + wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + @ccall libblastrampoline.dlarrv_(n::Ref{BlasInt}, vl::Ref{Float64}, vu::Ref{Float64}, + d::Ptr{Float64}, l::Ptr{Float64}, pivmin::Ref{Float64}, + isplit::Ptr{BlasInt}, m::Ref{BlasInt}, + dol::Ref{BlasInt}, + dou::Ref{BlasInt}, minrgp::Ref{Float64}, + rtol1::Ref{Float64}, + rtol2::Ref{Float64}, w::Ptr{Float64}, + werr::Ptr{Float64}, + wgap::Ptr{Float64}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlarscl2(m, n, d, x, ldx) + @ccall libblastrampoline.dlarscl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float64}, + x::Ptr{Float64}, ldx::Ref{BlasInt})::Cvoid +end + +function dlartgp(f, g, cs, sn, r) + @ccall libblastrampoline.dlartgp_(f::Ref{Float64}, g::Ref{Float64}, cs::Ref{Float64}, + sn::Ref{Float64}, r::Ref{Float64})::Cvoid +end + +function dlartgs(x, y, sigma, cs, sn) + @ccall libblastrampoline.dlartgs_(x::Ref{Float64}, y::Ref{Float64}, sigma::Ref{Float64}, + cs::Ref{Float64}, sn::Ref{Float64})::Cvoid +end + +function dlartv(n, x, incx, y, incy, c, s, incc) + @ccall libblastrampoline.dlartv_(n::Ref{BlasInt}, x::Ptr{Float64}, incx::Ref{BlasInt}, + y::Ptr{Float64}, incy::Ref{BlasInt}, c::Ptr{Float64}, + s::Ptr{Float64}, incc::Ref{BlasInt})::Cvoid +end + +function dlaruv(iseed, n, x) + @ccall libblastrampoline.dlaruv_(iseed::Ptr{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float64})::Cvoid +end + +function dlarz(side, m, n, l, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.dlarz_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + l::Ref{BlasInt}, + v::Ptr{Float64}, incv::Ref{BlasInt}, tau::Ref{Float64}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, work::Ptr{Float64}, + 1::Clong)::Cvoid +end + +function dlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, + ldwork) + @ccall libblastrampoline.dlarzb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + ldwork::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dlarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.dlarzt_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + tau::Ptr{Float64}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dlas2(f, g, h, ssmin, ssmax) + @ccall libblastrampoline.dlas2_(f::Ref{Float64}, g::Ref{Float64}, h::Ref{Float64}, + ssmin::Ref{Float64}, ssmax::Ref{Float64})::Cvoid +end + +function dlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info) + @ccall libblastrampoline.dlascl_(type::Ref{UInt8}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + cfrom::Ref{Float64}, cto::Ref{Float64}, + m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlascl2(m, n, d, x, ldx) + @ccall libblastrampoline.dlascl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float64}, + x::Ptr{Float64}, ldx::Ref{BlasInt})::Cvoid +end + +function dlasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info) + @ccall libblastrampoline.dlasd0_(n::Ref{BlasInt}, sqre::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + vt::Ptr{Float64}, ldvt::Ref{BlasInt}, + smlsiz::Ref{BlasInt}, + iwork::Ptr{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info) + @ccall libblastrampoline.dlasd1_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + d::Ptr{Float64}, alpha::Ref{Float64}, + beta::Ref{Float64}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, idxq::Ptr{BlasInt}, + iwork::Ptr{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlasd2(nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt, ldvt, dsigma, u2, ldu2, vt2, + ldvt2, idxp, idx, idxc, idxq, coltyp, info) + @ccall libblastrampoline.dlasd2_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + k::Ref{BlasInt}, + d::Ptr{Float64}, z::Ptr{Float64}, alpha::Ref{Float64}, + beta::Ref{Float64}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + vt::Ptr{Float64}, ldvt::Ref{BlasInt}, + dsigma::Ptr{Float64}, + u2::Ptr{Float64}, ldu2::Ref{BlasInt}, + vt2::Ptr{Float64}, + ldvt2::Ref{BlasInt}, idxp::Ptr{BlasInt}, + idx::Ptr{BlasInt}, + idxc::Ptr{BlasInt}, idxq::Ptr{BlasInt}, + coltyp::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlasd3(nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, + idxc, ctot, z, info) + @ccall libblastrampoline.dlasd3_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + k::Ref{BlasInt}, + d::Ptr{Float64}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + dsigma::Ptr{Float64}, u::Ptr{Float64}, + ldu::Ref{BlasInt}, + u2::Ptr{Float64}, ldu2::Ref{BlasInt}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, vt2::Ptr{Float64}, + ldvt2::Ref{BlasInt}, + idxc::Ptr{BlasInt}, ctot::Ptr{BlasInt}, + z::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasd4(n, i, d, z, delta, rho, sigma, work, info) + @ccall libblastrampoline.dlasd4_(n::Ref{BlasInt}, i::Ref{BlasInt}, d::Ptr{Float64}, + z::Ptr{Float64}, + delta::Ptr{Float64}, rho::Ref{Float64}, + sigma::Ref{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlasd5(i, d, z, delta, rho, dsigma, work) + @ccall libblastrampoline.dlasd5_(i::Ref{BlasInt}, d::Ptr{Float64}, z::Ptr{Float64}, + delta::Ptr{Float64}, rho::Ref{Float64}, + dsigma::Ref{Float64}, + work::Ptr{Float64})::Cvoid +end + +function dlasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, + ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info) + @ccall libblastrampoline.dlasd6_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, d::Ptr{Float64}, vf::Ptr{Float64}, + vl::Ptr{Float64}, alpha::Ref{Float64}, + beta::Ref{Float64}, + idxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + givnum::Ptr{Float64}, + ldgnum::Ref{BlasInt}, poles::Ptr{Float64}, + difl::Ptr{Float64}, + difr::Ptr{Float64}, z::Ptr{Float64}, k::Ref{BlasInt}, + c::Ref{Float64}, s::Ref{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dlasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, + idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info) + @ccall libblastrampoline.dlasd7_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, k::Ref{BlasInt}, d::Ptr{Float64}, + z::Ptr{Float64}, zw::Ptr{Float64}, vf::Ptr{Float64}, + vfw::Ptr{Float64}, vl::Ptr{Float64}, vlw::Ptr{Float64}, + alpha::Ref{Float64}, beta::Ref{Float64}, + dsigma::Ptr{Float64}, idx::Ptr{BlasInt}, + idxp::Ptr{BlasInt}, + idxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + givnum::Ptr{Float64}, + ldgnum::Ref{BlasInt}, c::Ref{Float64}, s::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info) + @ccall libblastrampoline.dlasd8_(icompq::Ref{BlasInt}, k::Ref{BlasInt}, d::Ptr{Float64}, + z::Ptr{Float64}, vf::Ptr{Float64}, vl::Ptr{Float64}, + difl::Ptr{Float64}, difr::Ptr{Float64}, + lddifr::Ref{BlasInt}, + dsigma::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, + givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + @ccall libblastrampoline.dlasda_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + sqre::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, vt::Ptr{Float64}, + k::Ptr{BlasInt}, difl::Ptr{Float64}, + difr::Ptr{Float64}, + z::Ptr{Float64}, poles::Ptr{Float64}, + givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + perm::Ptr{BlasInt}, + givnum::Ptr{Float64}, c::Ptr{Float64}, s::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + @ccall libblastrampoline.dlasdq_(uplo::Ref{UInt8}, sqre::Ref{BlasInt}, n::Ref{BlasInt}, + ncvt::Ref{BlasInt}, nru::Ref{BlasInt}, + ncc::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vt::Ptr{Float64}, + ldvt::Ref{BlasInt}, u::Ptr{Float64}, ldu::Ref{BlasInt}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlasdt(n, lvl, nd, inode, ndiml, ndimr, msub) + @ccall libblastrampoline.dlasdt_(n::Ref{BlasInt}, lvl::Ref{BlasInt}, nd::Ref{BlasInt}, + inode::Ptr{BlasInt}, ndiml::Ptr{BlasInt}, + ndimr::Ptr{BlasInt}, + msub::Ref{BlasInt})::Cvoid +end + +function dlaset(uplo, m, n, alpha, beta, a, lda) + @ccall libblastrampoline.dlaset_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, beta::Ref{Float64}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlasq1(n, d, e, work, info) + @ccall libblastrampoline.dlasq1_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dlasq2(n, z, info) + @ccall libblastrampoline.dlasq2_(n::Ref{BlasInt}, z::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasq3(i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee, ttype, + dmin1, dmin2, dn, dn1, dn2, g, tau) + @ccall libblastrampoline.dlasq3_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float64}, + pp::Ref{BlasInt}, + dmin::Ref{Float64}, sigma::Ref{Float64}, + desig::Ref{Float64}, + qmax::Ref{Float64}, nfail::Ref{BlasInt}, + iter::Ref{BlasInt}, + ndiv::Ref{BlasInt}, ieee::Ref{BlasInt}, + ttype::Ref{BlasInt}, + dmin1::Ref{Float64}, dmin2::Ref{Float64}, + dn::Ref{Float64}, + dn1::Ref{Float64}, dn2::Ref{Float64}, g::Ref{Float64}, + tau::Ref{Float64})::Cvoid +end + +function dlasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g) + @ccall libblastrampoline.dlasq4_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float64}, + pp::Ref{BlasInt}, + n0in::Ref{BlasInt}, dmin::Ref{Float64}, + dmin1::Ref{Float64}, + dmin2::Ref{Float64}, dn::Ref{Float64}, + dn1::Ref{Float64}, + dn2::Ref{Float64}, tau::Ref{Float64}, + ttype::Ref{BlasInt}, + g::Ref{Float64})::Cvoid +end + +function dlasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps) + @ccall libblastrampoline.dlasq5_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float64}, + pp::Ref{BlasInt}, + tau::Ref{Float64}, sigma::Ref{Float64}, + dmin::Ref{Float64}, + dmin1::Ref{Float64}, dmin2::Ref{Float64}, + dn::Ref{Float64}, + dnm1::Ref{Float64}, dnm2::Ref{Float64}, + ieee::Ref{BlasInt}, + eps::Ref{Float64})::Cvoid +end + +function dlasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) + @ccall libblastrampoline.dlasq6_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float64}, + pp::Ref{BlasInt}, + dmin::Ref{Float64}, dmin1::Ref{Float64}, + dmin2::Ref{Float64}, + dn::Ref{Float64}, dnm1::Ref{Float64}, + dnm2::Ref{Float64})::Cvoid +end + +function dlasr(side, pivot, direct, m, n, c, s, a, lda) + @ccall libblastrampoline.dlasr_(side::Ref{UInt8}, pivot::Ref{UInt8}, direct::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, c::Ptr{Float64}, + s::Ptr{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dlasrt(id, n, d, info) + @ccall libblastrampoline.dlasrt_(id::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlasv2(f, g, h, ssmin, ssmax, snr, csr, snl, csl) + @ccall libblastrampoline.dlasv2_(f::Ref{Float64}, g::Ref{Float64}, h::Ref{Float64}, + ssmin::Ref{Float64}, ssmax::Ref{Float64}, + snr::Ref{Float64}, + csr::Ref{Float64}, snl::Ref{Float64}, + csl::Ref{Float64})::Cvoid +end + +function dlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.dlaswlq_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlaswp(n, a, lda, k1, k2, ipiv, incx) + @ccall libblastrampoline.dlaswp_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + k1::Ref{BlasInt}, + k2::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + incx::Ref{BlasInt})::Cvoid +end + +function dlasy2(ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, + xnorm, info) + @ccall libblastrampoline.dlasy2_(ltranl::Ref{BlasInt}, ltranr::Ref{BlasInt}, + isgn::Ref{BlasInt}, + n1::Ref{BlasInt}, n2::Ref{BlasInt}, tl::Ptr{Float64}, + ldtl::Ref{BlasInt}, tr::Ptr{Float64}, + ldtr::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + scale::Ref{Float64}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + xnorm::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.dlasyf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + w::Ptr{Float64}, ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.dlasyf_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{Float64}, + ldh::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.dlasyf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + e::Ptr{Float64}, ipiv::Ptr{BlasInt}, + w::Ptr{Float64}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.dlasyf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{Float64}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlat2s(uplo, n, a, lda, sa, ldsa, info) + @ccall libblastrampoline.dlat2s_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, sa::Ptr{Float32}, + ldsa::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + @ccall libblastrampoline.dlatbs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, x::Ptr{Float64}, + scale::Ref{Float64}, cnorm::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + @ccall libblastrampoline.dlatdf_(ijob::Ref{BlasInt}, n::Ref{BlasInt}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, rhs::Ptr{Float64}, + rdsum::Ref{Float64}, + rdscal::Ref{Float64}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt})::Cvoid +end + +function dlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + @ccall libblastrampoline.dlatps_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + x::Ptr{Float64}, scale::Ref{Float64}, + cnorm::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dlatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + @ccall libblastrampoline.dlatrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, e::Ptr{Float64}, + tau::Ptr{Float64}, w::Ptr{Float64}, ldw::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + @ccall libblastrampoline.dlatrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, x::Ptr{Float64}, + scale::Ref{Float64}, + cnorm::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dlatrs3(uplo, trans, diag, normin, n, nrhs, a, lda, x, ldx, scale, cnorm, work, + lwork, info) + @ccall libblastrampoline.dlatrs3_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, scale::Ptr{Float64}, + cnorm::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dlatrz(m, n, l, a, lda, tau, work) + @ccall libblastrampoline.dlatrz_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64})::Cvoid +end + +function dlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.dlatsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dlauu2(uplo, n, a, lda, info) + @ccall libblastrampoline.dlauu2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dlauum(uplo, n, a, lda, info) + @ccall libblastrampoline.dlauum_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dopgtr(uplo, n, ap, tau, q, ldq, work, info) + @ccall libblastrampoline.dopgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + tau::Ptr{Float64}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + @ccall libblastrampoline.dopmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, ap::Ptr{Float64}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, + theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + @ccall libblastrampoline.dorbdb_(trans::Ref{UInt8}, signs::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x12::Ptr{Float64}, + ldx12::Ref{BlasInt}, + x21::Ptr{Float64}, ldx21::Ref{BlasInt}, + x22::Ptr{Float64}, + ldx22::Ref{BlasInt}, theta::Ptr{Float64}, + phi::Ptr{Float64}, + taup1::Ptr{Float64}, taup2::Ptr{Float64}, + tauq1::Ptr{Float64}, tauq2::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.dorbdb1_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x21::Ptr{Float64}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, phi::Ptr{Float64}, + taup1::Ptr{Float64}, + taup2::Ptr{Float64}, tauq1::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.dorbdb2_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x21::Ptr{Float64}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, phi::Ptr{Float64}, + taup1::Ptr{Float64}, + taup2::Ptr{Float64}, tauq1::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.dorbdb3_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x21::Ptr{Float64}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, phi::Ptr{Float64}, + taup1::Ptr{Float64}, + taup2::Ptr{Float64}, tauq1::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, + work, lwork, info) + @ccall libblastrampoline.dorbdb4_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x21::Ptr{Float64}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, phi::Ptr{Float64}, + taup1::Ptr{Float64}, + taup2::Ptr{Float64}, tauq1::Ptr{Float64}, + phantom::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.dorbdb5_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{Float64}, incx1::Ref{BlasInt}, + x2::Ptr{Float64}, + incx2::Ref{BlasInt}, q1::Ptr{Float64}, + ldq1::Ref{BlasInt}, + q2::Ptr{Float64}, ldq2::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.dorbdb6_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{Float64}, incx1::Ref{BlasInt}, + x2::Ptr{Float64}, + incx2::Ref{BlasInt}, q1::Ptr{Float64}, + ldq1::Ref{BlasInt}, + q2::Ptr{Float64}, ldq2::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, + x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, + work, lwork, iwork, info) + @ccall libblastrampoline.dorcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, + signs::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, + ldx11::Ref{BlasInt}, x12::Ptr{Float64}, + ldx12::Ref{BlasInt}, + x21::Ptr{Float64}, ldx21::Ref{BlasInt}, + x22::Ptr{Float64}, + ldx22::Ref{BlasInt}, theta::Ptr{Float64}, + u1::Ptr{Float64}, + ldu1::Ref{BlasInt}, u2::Ptr{Float64}, + ldu2::Ref{BlasInt}, + v1t::Ptr{Float64}, ldv1t::Ref{BlasInt}, + v2t::Ptr{Float64}, + ldv2t::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, + u2, ldu2, v1t, ldv1t, work, lwork, iwork, info) + @ccall libblastrampoline.dorcsd2by1_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float64}, ldx11::Ref{BlasInt}, + x21::Ptr{Float64}, + ldx21::Ref{BlasInt}, theta::Ptr{Float64}, + u1::Ptr{Float64}, + ldu1::Ref{BlasInt}, u2::Ptr{Float64}, + ldu2::Ref{BlasInt}, + v1t::Ptr{Float64}, ldv1t::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dorg2l(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.dorg2l_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dorg2r(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.dorg2r_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dorgbr(vect, m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorgbr_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dorghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorghr_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorgl2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.dorgl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dorglq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorglq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorgql(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorgql_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorgqr(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorgqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorgr2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.dorgr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dorgrq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorgrq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorgtr(uplo, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dorgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.dorgtsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.dorgtsqr_row_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dorhr_col(m, n, nb, a, lda, t, ldt, d, info) + @ccall libblastrampoline.dorhr_col_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, d::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dorm22(side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) + @ccall libblastrampoline.dorm22_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + q::Ptr{Float64}, + ldq::Ref{BlasInt}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.dorm2l_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.dorm2r_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormbr_(vect::Ref{UInt8}, side::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormhr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, tau::Ptr{Float64}, + c::Ptr{Float64}, ldc::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dorml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.dorml2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormql_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dormr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.dormr2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dormr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.dormr3_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormrq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormrz_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tau::Ptr{Float64}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.dormtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, c::Ptr{Float64}, ldc::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dpbcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + @ccall libblastrampoline.dpbequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, amax::Ref{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.dpbrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + afb::Ptr{Float64}, ldafb::Ref{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbstf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.dpbstf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.dpbsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dpbsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, afb::Ptr{Float64}, + ldafb::Ref{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dpbtf2(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.dpbtf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbtrf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.dpbtrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.dpbtrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpftrf(transr, uplo, n, a, info) + @ccall libblastrampoline.dpftrf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dpftri(transr, uplo, n, a, info) + @ccall libblastrampoline.dpftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + @ccall libblastrampoline.dpftrs_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dpocon(uplo, n, a, lda, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dpocon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpoequ(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.dpoequ_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dpoequb(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.dpoequb_(n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.dporfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dporfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, + n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, iwork, + info) + @ccall libblastrampoline.dporfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, s::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dposv(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.dposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + ferr, berr, work, iwork, info) + @ccall libblastrampoline.dposvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dposvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, + work, iwork, info) + @ccall libblastrampoline.dposvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + rpvgrw::Ref{Float64}, berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dpotf2(uplo, n, a, lda, info) + @ccall libblastrampoline.dpotf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpotrf(uplo, n, a, lda, info) + @ccall libblastrampoline.dpotrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpotrf2(uplo, n, a, lda, info) + @ccall libblastrampoline.dpotrf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpotri(uplo, n, a, lda, info) + @ccall libblastrampoline.dpotri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.dpotrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dppcon(uplo, n, ap, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dppcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dppequ(uplo, n, ap, s, scond, amax, info) + @ccall libblastrampoline.dppequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dpprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, afp::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dppsv(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.dppsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, + work, iwork, info) + @ccall libblastrampoline.dppsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{Float64}, + afp::Ptr{Float64}, + equed::Ref{UInt8}, s::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dpptrf(uplo, n, ap, info) + @ccall libblastrampoline.dpptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpptri(uplo, n, ap, info) + @ccall libblastrampoline.dpptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpptrs(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.dpptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.dpstf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.dpstrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dptcon(n, d, e, anorm, rcond, work, info) + @ccall libblastrampoline.dptcon_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dpteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.dpteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) + @ccall libblastrampoline.dptrfs_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, df::Ptr{Float64}, ef::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dptsv(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.dptsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info) + @ccall libblastrampoline.dptsvx_(fact::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, df::Ptr{Float64}, + ef::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dpttrf(n, d, e, info) + @ccall libblastrampoline.dpttrf_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dpttrs(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.dpttrs_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dptts2(n, nrhs, d, e, b, ldb) + @ccall libblastrampoline.dptts2_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt})::Cvoid +end + +function drscl(n, sa, sx, incx) + @ccall libblastrampoline.drscl_(n::Ref{BlasInt}, sa::Ref{Float64}, sx::Ptr{Float64}, + incx::Ref{BlasInt})::Cvoid +end + +function dsb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, + work) + @ccall libblastrampoline.dsb2st_kernels_(uplo::Ref{UInt8}, wantz::Ref{BlasInt}, + ttype::Ref{BlasInt}, + st::Ref{BlasInt}, ed::Ref{BlasInt}, + sweep::Ref{BlasInt}, + n::Ref{BlasInt}, nb::Ref{BlasInt}, + ib::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + v::Ptr{Float64}, + tau::Ptr{Float64}, ldvt::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Cvoid +end + +function dsbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info) + @ccall libblastrampoline.dsbev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float64}, ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsbev_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, info) + @ccall libblastrampoline.dsbev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsbevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float64}, ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsbevd_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, + info) + @ccall libblastrampoline.dsbevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, + ldz, work, iwork, ifail, info) + @ccall libblastrampoline.dsbevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dsbevx_2stage(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, + m, w, z, ldz, work, lwork, iwork, ifail, info) + @ccall libblastrampoline.dsbevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, + ldab::Ref{BlasInt}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) + @ccall libblastrampoline.dsbgst_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, bb::Ptr{Float64}, + ldbb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dsbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info) + @ccall libblastrampoline.dsbgv_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, bb::Ptr{Float64}, + ldbb::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, + liwork, info) + @ccall libblastrampoline.dsbgvd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, bb::Ptr{Float64}, + ldbb::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, + abstol, m, w, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.dsbgvx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{Float64}, + ldab::Ref{BlasInt}, bb::Ptr{Float64}, + ldbb::Ref{BlasInt}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + @ccall libblastrampoline.dsbtrd_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float64}, ldab::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, q::Ptr{Float64}, + ldq::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + @ccall libblastrampoline.dsfrk_(transr::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, beta::Ref{Float64}, + c::Ptr{Float64}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsgesv(n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, iter, info) + @ccall libblastrampoline.dsgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + work::Ptr{Float64}, swork::Ptr{Float32}, + iter::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dspcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dspev(jobz, uplo, n, ap, w, z, ldz, work, info) + @ccall libblastrampoline.dspev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dspevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dspevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, + ifail, info) + @ccall libblastrampoline.dspevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dspgst(itype, uplo, n, ap, bp, info) + @ccall libblastrampoline.dspgst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, bp::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info) + @ccall libblastrampoline.dspgv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, bp::Ptr{Float64}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dspgvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, bp::Ptr{Float64}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dspgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, + work, iwork, ifail, info) + @ccall libblastrampoline.dspgvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + bp::Ptr{Float64}, vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, + m::Ref{BlasInt}, w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dsposv(uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, iter, info) + @ccall libblastrampoline.dsposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + work::Ptr{Float64}, swork::Ptr{Float32}, + iter::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + @ccall libblastrampoline.dsprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, afp::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.dspsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.dspsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{Float64}, + afp::Ptr{Float64}, + ipiv::Ptr{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsptrd(uplo, n, ap, d, e, tau, info) + @ccall libblastrampoline.dsptrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + d::Ptr{Float64}, e::Ptr{Float64}, tau::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.dsptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.dsptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + ipiv::Ptr{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.dsptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float64}, ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, + work, iwork, info) + @ccall libblastrampoline.dstebz_(range::Ref{UInt8}, order::Ref{UInt8}, n::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + d::Ptr{Float64}, + e::Ptr{Float64}, m::Ref{BlasInt}, nsplit::Ref{BlasInt}, + w::Ptr{Float64}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dstedc_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.dstegr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.dstein_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dstemr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + nzc::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + tryrac::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.dsteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsterf(n, d, e, info) + @ccall libblastrampoline.dsterf_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function dstev(jobz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.dstev_(jobz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dstevd_(jobz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.dstevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dstevx(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, + ifail, info) + @ccall libblastrampoline.dstevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dsycon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsycon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dsycon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.dsycon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsyconv(uplo, way, n, a, lda, ipiv, e, info) + @ccall libblastrampoline.dsyconv_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + e::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsyconvf(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.dsyconvf_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.dsyconvf_rook_(uplo::Ref{UInt8}, way::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function dsyequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.dsyequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsyev(jobz, uplo, n, a, lda, w, work, lwork, info) + @ccall libblastrampoline.dsyev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsyev_2stage(jobz, uplo, n, a, lda, w, work, lwork, info) + @ccall libblastrampoline.dsyev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsyevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsyevd_2stage(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsyevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsyevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsyevr_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + isuppz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsyevr_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dsyevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, + lwork, iwork, ifail, info) + @ccall libblastrampoline.dsyevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dsyevx_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + work, lwork, iwork, ifail, info) + @ccall libblastrampoline.dsyevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, + ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsygs2(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.dsygs2_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsygst(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.dsygst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + @ccall libblastrampoline.dsygv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsygv_2stage(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + @ccall libblastrampoline.dsygv_2stage_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dsygvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsygvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, + z, ldz, work, lwork, iwork, ifail, info) + @ccall libblastrampoline.dsygvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{Float64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.dsyrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, af::Ptr{Float64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsyrfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + iwork, info) + @ccall libblastrampoline.dsyrfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float64}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.dsysv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.dsysv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsysv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.dsysv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + tb::Ptr{Float64}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.dsysv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.dsysv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, iwork, info) + @ccall libblastrampoline.dsysvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dsysvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.dsysvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + af::Ptr{Float64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float64}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsyswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.dsyswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytd2(uplo, n, a, lda, d, e, tau, info) + @ccall libblastrampoline.dsytd2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tau::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.dsytf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.dsytf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.dsytf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + @ccall libblastrampoline.dsytrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytrd_2stage(vect, uplo, n, a, lda, d, e, tau, hous2, lhous2, work, lwork, info) + @ccall libblastrampoline.dsytrd_2stage_(vect::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + d::Ptr{Float64}, + e::Ptr{Float64}, tau::Ptr{Float64}, + hous2::Ptr{Float64}, lhous2::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dsytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, + info) + @ccall libblastrampoline.dsytrd_sb2st_(stage1::Ref{UInt8}, vect::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float64}, + ldab::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, + hous::Ptr{Float64}, lhous::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dsytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) + @ccall libblastrampoline.dsytrd_sy2sb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ab::Ptr{Float64}, + ldab::Ref{BlasInt}, tau::Ptr{Float64}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.dsytrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, tb::Ptr{Float64}, + ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.dsytri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.dsytri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.dsytri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.dsytri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.dsytri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.dsytrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.dsytrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.dsytrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, e::Ptr{Float64}, + ipiv::Ptr{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.dsytrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.dsytrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + tb::Ptr{Float64}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.dsytrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dtbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info) + @ccall libblastrampoline.dtbcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{Float64}, + ldab::Ref{BlasInt}, rcond::Ref{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.dtbrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, x::Ptr{Float64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.dtbtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float64}, ldab::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + @ccall libblastrampoline.dtfsm_(transr::Ref{UInt8}, side::Ref{UInt8}, uplo::Ref{UInt8}, + trans::Ref{UInt8}, diag::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, alpha::Ref{Float64}, a::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtftri(transr, uplo, diag, n, a, info) + @ccall libblastrampoline.dtftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dtfttp(transr, uplo, n, arf, ap, info) + @ccall libblastrampoline.dtfttp_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{Float64}, ap::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtfttr(transr, uplo, n, arf, a, lda, info) + @ccall libblastrampoline.dtfttr_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{Float64}, a::Ptr{Float64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, + info) + @ccall libblastrampoline.dtgevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, s::Ptr{Float64}, lds::Ref{BlasInt}, + p::Ptr{Float64}, ldp::Ref{BlasInt}, vl::Ptr{Float64}, + ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, + info) + @ccall libblastrampoline.dtgex2_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, j1::Ref{BlasInt}, + n1::Ref{BlasInt}, n2::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dtgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, + info) + @ccall libblastrampoline.dtgexc_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, ifst::Ref{BlasInt}, + ilst::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dtgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, + z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.dtgsen_(ijob::Ref{BlasInt}, wantq::Ref{BlasInt}, + wantz::Ref{BlasInt}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + alphar::Ptr{Float64}, alphai::Ptr{Float64}, + beta::Ptr{Float64}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + z::Ptr{Float64}, ldz::Ref{BlasInt}, m::Ref{BlasInt}, + pl::Ref{Float64}, pr::Ref{Float64}, dif::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function dtgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, + ldu, v, ldv, q, ldq, work, ncycle, info) + @ccall libblastrampoline.dtgsja_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, tola::Ref{Float64}, + tolb::Ref{Float64}, alpha::Ptr{Float64}, + beta::Ptr{Float64}, + u::Ptr{Float64}, ldu::Ref{BlasInt}, v::Ptr{Float64}, + ldv::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + work::Ptr{Float64}, ncycle::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, + work, lwork, iwork, info) + @ccall libblastrampoline.dtgsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, vl::Ptr{Float64}, + ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, + s::Ptr{Float64}, dif::Ptr{Float64}, mm::Ref{BlasInt}, + m::Ref{BlasInt}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dtgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + rdsum, rdscal, iwork, pq, info) + @ccall libblastrampoline.dtgsy2_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, d::Ptr{Float64}, ldd::Ref{BlasInt}, + e::Ptr{Float64}, lde::Ref{BlasInt}, f::Ptr{Float64}, + ldf::Ref{BlasInt}, scale::Ref{Float64}, + rdsum::Ref{Float64}, + rdscal::Ref{Float64}, iwork::Ptr{BlasInt}, + pq::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dtgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + dif, work, lwork, iwork, info) + @ccall libblastrampoline.dtgsyl_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, d::Ptr{Float64}, ldd::Ref{BlasInt}, + e::Ptr{Float64}, lde::Ref{BlasInt}, f::Ptr{Float64}, + ldf::Ref{BlasInt}, scale::Ref{Float64}, + dif::Ref{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dtpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info) + @ccall libblastrampoline.dtpcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float64}, rcond::Ref{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.dtplqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dtplqt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.dtplqt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dtpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.dtpmlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.dtpmqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + v::Ptr{Float64}, ldv::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.dtpqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{Float64}, + ldb::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function dtpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.dtpqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dtprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, + work, ldwork) + @ccall libblastrampoline.dtprfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{Float64}, ldv::Ref{BlasInt}, + t::Ptr{Float64}, ldt::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + work::Ptr{Float64}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.dtprfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, ap::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, x::Ptr{Float64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function dtptri(uplo, diag, n, ap, info) + @ccall libblastrampoline.dtptri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dtptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.dtptrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, ap::Ptr{Float64}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function dtpttf(transr, uplo, n, ap, arf, info) + @ccall libblastrampoline.dtpttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float64}, arf::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtpttr(uplo, n, ap, a, lda, info) + @ccall libblastrampoline.dtpttr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float64}, + a::Ptr{Float64}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dtrcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info) + @ccall libblastrampoline.dtrcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + rcond::Ref{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dtrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) + @ccall libblastrampoline.dtrevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + vl::Ptr{Float64}, ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function dtrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, + info) + @ccall libblastrampoline.dtrevc3_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + vl::Ptr{Float64}, ldvl::Ref{BlasInt}, + vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info) + @ccall libblastrampoline.dtrexc_(compq::Ref{UInt8}, n::Ref{BlasInt}, t::Ptr{Float64}, + ldt::Ref{BlasInt}, q::Ptr{Float64}, ldq::Ref{BlasInt}, + ifst::Ref{BlasInt}, ilst::Ref{BlasInt}, + work::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function dtrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.dtrrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + x::Ptr{Float64}, ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dtrsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, + iwork, liwork, info) + @ccall libblastrampoline.dtrsen_(job::Ref{UInt8}, compq::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + q::Ptr{Float64}, ldq::Ref{BlasInt}, wr::Ptr{Float64}, + wi::Ptr{Float64}, m::Ref{BlasInt}, s::Ref{Float64}, + sep::Ref{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, + ldwork, iwork, info) + @ccall libblastrampoline.dtrsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float64}, ldt::Ref{BlasInt}, + vl::Ptr{Float64}, ldvl::Ref{BlasInt}, vr::Ptr{Float64}, + ldvr::Ref{BlasInt}, s::Ptr{Float64}, sep::Ptr{Float64}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, work::Ptr{Float64}, + ldwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + @ccall libblastrampoline.dtrsyl_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, scale::Ref{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function dtrsyl3(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, iwork, liwork, + swork, ldswork, info) + @ccall libblastrampoline.dtrsyl3_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + b::Ptr{Float64}, ldb::Ref{BlasInt}, c::Ptr{Float64}, + ldc::Ref{BlasInt}, scale::Ref{Float64}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, swork::Ptr{Float64}, + ldswork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtrti2(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.dtrti2_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtrtri(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.dtrtri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function dtrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.dtrtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function dtrttf(transr, uplo, n, a, lda, arf, info) + @ccall libblastrampoline.dtrttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, arf::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function dtrttp(uplo, n, a, lda, ap, info) + @ccall libblastrampoline.dtrttp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, ap::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function dtzrzf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.dtzrzf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + tau::Ptr{Float64}, work::Ptr{Float64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function dzsum1(n, cx, incx) + @ccall libblastrampoline.dzsum1_(n::Ref{BlasInt}, cx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Float64 +end + +function icmax1(n, cx, incx) + @ccall libblastrampoline.icmax1_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::BlasInt +end + +function ieeeck(ispec, zero, one) + @ccall libblastrampoline.ieeeck_(ispec::Ref{BlasInt}, zero::Ref{Float32}, + one::Ref{Float32})::BlasInt +end + +function ilaclc(m, n, a, lda) + @ccall libblastrampoline.ilaclc_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt})::BlasInt +end + +function ilaclr(m, n, a, lda) + @ccall libblastrampoline.ilaclr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF32}, + lda::Ref{BlasInt})::BlasInt +end + +function iladiag(diag) + @ccall libblastrampoline.iladiag_(diag::Ref{UInt8}, 1::Clong)::BlasInt +end + +function iladlc(m, n, a, lda) + @ccall libblastrampoline.iladlc_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt})::BlasInt +end + +function iladlr(m, n, a, lda) + @ccall libblastrampoline.iladlr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt})::BlasInt +end + +function ilaprec(prec) + @ccall libblastrampoline.ilaprec_(prec::Ref{UInt8}, 1::Clong)::BlasInt +end + +function ilaslc(m, n, a, lda) + @ccall libblastrampoline.ilaslc_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt})::BlasInt +end + +function ilaslr(m, n, a, lda) + @ccall libblastrampoline.ilaslr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt})::BlasInt +end + +function ilatrans(trans) + @ccall libblastrampoline.ilatrans_(trans::Ref{UInt8}, 1::Clong)::BlasInt +end + +function ilauplo(uplo) + @ccall libblastrampoline.ilauplo_(uplo::Ref{UInt8}, 1::Clong)::BlasInt +end + +function ilazlc(m, n, a, lda) + @ccall libblastrampoline.ilazlc_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt})::BlasInt +end + +function ilazlr(m, n, a, lda) + @ccall libblastrampoline.ilazlr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt})::BlasInt +end + +function izmax1(n, zx, incx) + @ccall libblastrampoline.izmax1_(n::Ref{BlasInt}, zx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::BlasInt +end + +function sbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, + ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, + b22e, work, lwork, info) + @ccall libblastrampoline.sbbcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, theta::Ptr{Float32}, + phi::Ptr{Float32}, u1::Ptr{Float32}, + ldu1::Ref{BlasInt}, + u2::Ptr{Float32}, ldu2::Ref{BlasInt}, + v1t::Ptr{Float32}, + ldv1t::Ref{BlasInt}, v2t::Ptr{Float32}, + ldv2t::Ref{BlasInt}, + b11d::Ptr{Float32}, b11e::Ptr{Float32}, + b12d::Ptr{Float32}, + b12e::Ptr{Float32}, b21d::Ptr{Float32}, + b21e::Ptr{Float32}, + b22d::Ptr{Float32}, b22e::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sbdsdc(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info) + @ccall libblastrampoline.sbdsdc_(uplo::Ref{UInt8}, compq::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, u::Ptr{Float32}, + ldu::Ref{BlasInt}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, + q::Ptr{Float32}, iq::Ptr{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + @ccall libblastrampoline.sbdsqr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ncvt::Ref{BlasInt}, + nru::Ref{BlasInt}, ncc::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, vt::Ptr{Float32}, ldvt::Ref{BlasInt}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sbdsvdx(uplo, jobz, range, n, d, e, vl, vu, il, iu, ns, s, z, ldz, work, iwork, + info) + @ccall libblastrampoline.sbdsvdx_(uplo::Ref{UInt8}, jobz::Ref{UInt8}, range::Ref{UInt8}, + n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, ns::Ref{BlasInt}, s::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function scsum1(n, cx, incx) + @ccall libblastrampoline.scsum1_(n::Ref{BlasInt}, cx::Ptr{ComplexF32}, + incx::Ref{BlasInt})::Float32 +end + +function sdisna(job, m, n, d, sep, info) + @ccall libblastrampoline.sdisna_(job::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + d::Ptr{Float32}, + sep::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, + info) + @ccall libblastrampoline.sgbbrd_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + ncc::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, pt::Ptr{Float32}, + ldpt::Ref{BlasInt}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.sgbcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.sgbequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.sgbequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, + berr, work, iwork, info) + @ccall libblastrampoline.sgbrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sgbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, + ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.sgbrfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + r::Ptr{Float32}, + c::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.sgbsv_(n::Ref{BlasInt}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.sgbsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgbsvxx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, + nparams, params, work, iwork, info) + @ccall libblastrampoline.sgbsvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.sgbtf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.sgbtrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.sgbtrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + @ccall libblastrampoline.sgebak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float32}, + m::Ref{BlasInt}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgebal(job, n, a, lda, ilo, ihi, scale, info) + @ccall libblastrampoline.sgebal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + @ccall libblastrampoline.sgebd2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, tauq::Ptr{Float32}, + taup::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + @ccall libblastrampoline.sgebrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, tauq::Ptr{Float32}, + taup::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgecon(norm, n, a, lda, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.sgecon_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.sgeequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + r::Ptr{Float32}, c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.sgeequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + r::Ptr{Float32}, c::Ptr{Float32}, + rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgees(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, + info) + @ccall libblastrampoline.sgees_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + sdim::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + vs::Ptr{Float32}, ldvs::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sgeesx(jobvs, sort, select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, + rcondv, work, lwork, iwork, liwork, bwork, info) + @ccall libblastrampoline.sgeesx_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, sdim::Ref{BlasInt}, + wr::Ptr{Float32}, + wi::Ptr{Float32}, vs::Ptr{Float32}, ldvs::Ref{BlasInt}, + rconde::Ref{Float32}, rcondv::Ref{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgeev(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info) + @ccall libblastrampoline.sgeev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, wr::Ptr{Float32}, + wi::Ptr{Float32}, vl::Ptr{Float32}, ldvl::Ref{BlasInt}, + vr::Ptr{Float32}, ldvr::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sgeevx(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, + ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info) + @ccall libblastrampoline.sgeevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + vl::Ptr{Float32}, ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float32}, abnrm::Ref{Float32}, + rconde::Ptr{Float32}, rcondv::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sgehd2(n, ilo, ihi, a, lda, tau, work, info) + @ccall libblastrampoline.sgehd2_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgehrd_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, work, + lwork, iwork, info) + @ccall libblastrampoline.sgejsv_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + jobr::Ptr{UInt8}, jobt::Ptr{UInt8}, jobp::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + sva::Ptr{Float32}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sgelq(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.sgelq_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, tsize::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgelq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.sgelq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgelqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgelqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgelqt(m, n, mb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.sgelqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sgelqt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.sgelqt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.sgels_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info) + @ccall libblastrampoline.sgelsd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + s::Ptr{Float32}, rcond::Ref{Float32}, + rank::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info) + @ccall libblastrampoline.sgelss_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + s::Ptr{Float32}, rcond::Ref{Float32}, + rank::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgelst(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.sgelst_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info) + @ccall libblastrampoline.sgelsy_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, rcond::Ref{Float32}, + rank::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.sgemlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, tsize::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.sgemlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + v::Ptr{Float32}, + ldv::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.sgemqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, tsize::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.sgemqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + v::Ptr{Float32}, + ldv::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgeql2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.sgeql2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqlf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgeqlf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqp3(m, n, a, lda, jpvt, tau, work, lwork, info) + @ccall libblastrampoline.sgeqp3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgeqp3rk(m, n, nrhs, kmax, abstol, reltol, a, lda, k, maxc2nrmk, relmaxc2nrmk, + jpiv, tau, work, lwork, iwork, info) + @ccall libblastrampoline.sgeqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + kmax::Ref{BlasInt}, abstol::Ref{Float32}, + reltol::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgeqr(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.sgeqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, tsize::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgeqr2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.sgeqr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqr2p(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.sgeqr2p_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqrf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgeqrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqrfp(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgeqrfp_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqrt(m, n, nb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.sgeqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sgeqrt2(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.sgeqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgeqrt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.sgeqrt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.sgerfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + iwork, info) + @ccall libblastrampoline.sgerfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + r::Ptr{Float32}, c::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgerq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.sgerq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sgerqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sgerqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + @ccall libblastrampoline.sgesc2_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + rhs::Ptr{Float32}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt}, + scale::Ref{Float32})::Cvoid +end + +function sgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info) + @ccall libblastrampoline.sgesdd_(jobz::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, s::Ptr{Float32}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.sgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info) + @ccall libblastrampoline.sgesvd_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + vt::Ptr{Float32}, ldvt::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, + iwork, liwork, work, lwork, rwork, lrwork, info) + @ccall libblastrampoline.sgesvdq_(joba::Ref{UInt8}, jobp::Ref{UInt8}, jobr::Ref{UInt8}, + jobu::Ref{UInt8}, jobv::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, + numrank::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, rwork::Ptr{Float32}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function sgesvdx(jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, ns, s, u, ldu, vt, ldvt, + work, lwork, iwork, info) + @ccall libblastrampoline.sgesvdx_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, + range::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, ns::Ref{BlasInt}, s::Ptr{Float32}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function sgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, work, lwork, info) + @ccall libblastrampoline.sgesvj_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + sva::Ptr{Float32}, mv::Ref{BlasInt}, v::Ptr{Float32}, + ldv::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.sgesvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float32}, c::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sgesvxx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.sgesvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float32}, c::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgetc2(n, a, lda, ipiv, jpiv, info) + @ccall libblastrampoline.sgetc2_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, jpiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgetf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.sgetf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgetrf(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.sgetrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgetrf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.sgetrf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgetri(n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.sgetri_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.sgetrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.sgetsls_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.sgetsqrhrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb1::Ref{BlasInt}, + nb1::Ref{BlasInt}, nb2::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + @ccall libblastrampoline.sggbak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float32}, + rscale::Ptr{Float32}, m::Ref{BlasInt}, v::Ptr{Float32}, + ldv::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + @ccall libblastrampoline.sggbal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float32}, + rscale::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, + vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + @ccall libblastrampoline.sgges_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, vsl::Ptr{Float32}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{Float32}, ldvsr::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgges3(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, beta, + vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info) + @ccall libblastrampoline.sgges3_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, vsl::Ptr{Float32}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{Float32}, ldvsr::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sggesx(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alphar, + alphai, beta, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, + liwork, bwork, info) + @ccall libblastrampoline.sggesx_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, sense::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, sdim::Ref{BlasInt}, + alphar::Ptr{Float32}, + alphai::Ptr{Float32}, beta::Ptr{Float32}, + vsl::Ptr{Float32}, + ldvsl::Ref{BlasInt}, vsr::Ptr{Float32}, + ldvsr::Ref{BlasInt}, + rconde::Ptr{Float32}, rcondv::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sggev(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, + work, lwork, info) + @ccall libblastrampoline.sggev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, vl::Ptr{Float32}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float32}, ldvr::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sggev3(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, beta, vl, ldvl, vr, ldvr, + work, lwork, info) + @ccall libblastrampoline.sggev3_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, vl::Ptr{Float32}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float32}, ldvr::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, beta, vl, + ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, + work, lwork, iwork, bwork, info) + @ccall libblastrampoline.sggevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + alphar::Ptr{Float32}, alphai::Ptr{Float32}, + beta::Ptr{Float32}, vl::Ptr{Float32}, + ldvl::Ref{BlasInt}, + vr::Ptr{Float32}, ldvr::Ref{BlasInt}, + ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, lscale::Ptr{Float32}, + rscale::Ptr{Float32}, + abnrm::Ref{Float32}, bbnrm::Ref{Float32}, + rconde::Ptr{Float32}, rcondv::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + bwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function sggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + @ccall libblastrampoline.sggglm_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + d::Ptr{Float32}, x::Ptr{Float32}, y::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgghd3(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, + info) + @ccall libblastrampoline.sgghd3_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + @ccall libblastrampoline.sgghrd_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + @ccall libblastrampoline.sgglse_(m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + c::Ptr{Float32}, d::Ptr{Float32}, x::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.sggqrf_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, taua::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, taub::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.sggrqf_(m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, taua::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, taub::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sggsvd3(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, + ldv, q, ldq, work, lwork, iwork, info) + @ccall libblastrampoline.sggsvd3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + alpha::Ptr{Float32}, + beta::Ptr{Float32}, u::Ptr{Float32}, + ldu::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function sggsvp3(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, + ldv, q, ldq, iwork, tau, work, lwork, info) + @ccall libblastrampoline.sggsvp3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + tola::Ref{Float32}, tolb::Ref{Float32}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, iwork::Ptr{BlasInt}, + tau::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.sgsvj0_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, d::Ptr{Float32}, + sva::Ptr{Float32}, mv::Ref{BlasInt}, v::Ptr{Float32}, + ldv::Ref{BlasInt}, eps::Ref{Float32}, + sfmin::Ref{Float32}, + tol::Ref{Float32}, nsweep::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.sgsvj1_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + n1::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, d::Ptr{Float32}, + sva::Ptr{Float32}, mv::Ref{BlasInt}, v::Ptr{Float32}, + ldv::Ref{BlasInt}, eps::Ref{Float32}, + sfmin::Ref{Float32}, + tol::Ref{Float32}, nsweep::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.sgtcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{Float32}, + d::Ptr{Float32}, du::Ptr{Float32}, du2::Ptr{Float32}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, + berr, work, iwork, info) + @ccall libblastrampoline.sgtrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{Float32}, d::Ptr{Float32}, du::Ptr{Float32}, + dlf::Ptr{Float32}, df::Ptr{Float32}, duf::Ptr{Float32}, + du2::Ptr{Float32}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sgtsv(n, nrhs, dl, d, du, b, ldb, info) + @ccall libblastrampoline.sgtsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, dl::Ptr{Float32}, + d::Ptr{Float32}, du::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.sgtsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, dl::Ptr{Float32}, d::Ptr{Float32}, + du::Ptr{Float32}, dlf::Ptr{Float32}, df::Ptr{Float32}, + duf::Ptr{Float32}, du2::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sgttrf(n, dl, d, du, du2, ipiv, info) + @ccall libblastrampoline.sgttrf_(n::Ref{BlasInt}, dl::Ptr{Float32}, d::Ptr{Float32}, + du::Ptr{Float32}, du2::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + @ccall libblastrampoline.sgttrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{Float32}, d::Ptr{Float32}, du::Ptr{Float32}, + du2::Ptr{Float32}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + @ccall libblastrampoline.sgtts2_(itrans::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + dl::Ptr{Float32}, d::Ptr{Float32}, du::Ptr{Float32}, + du2::Ptr{Float32}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt})::Cvoid +end + +function shgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alphar, alphai, beta, q, + ldq, z, ldz, work, lwork, info) + @ccall libblastrampoline.shgeqz_(job::Ref{UInt8}, compq::Ref{UInt8}, compz::Ref{UInt8}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{Float32}, ldh::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function shsein(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, + work, ifaill, ifailr, info) + @ccall libblastrampoline.shsein_(side::Ref{UInt8}, eigsrc::Ref{UInt8}, + initv::Ref{UInt8}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + vl::Ptr{Float32}, ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float32}, ifaill::Ptr{BlasInt}, + ifailr::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function shseqr(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info) + @ccall libblastrampoline.shseqr_(job::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) + @ccall libblastrampoline.sla_gbamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + alpha::Ref{Float32}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + x::Ptr{Float32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function sla_gbrcond(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, cmode, c, info, work, + iwork) + @ccall libblastrampoline.sla_gbrcond_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + afb::Ptr{Float32}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + cmode::Ref{BlasInt}, c::Ptr{Float32}, + info::Ref{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + 1::Clong)::Float32 +end + +function sla_gbrfsx_extended(prec_type, trans_type, n, kl, ku, nrhs, ab, ldab, afb, ldafb, + ipiv, colequ, c, b, ldb, y, ldy, berr_out, n_norms, + err_bnds_norm, err_bnds_comp, res, ayb, dy, y_tail, rcond, + ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.sla_gbrfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + y::Ptr{Float32}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{Float32}, + ayb::Ptr{Float32}, dy::Ptr{Float32}, + y_tail::Ptr{Float32}, rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb) + @ccall libblastrampoline.sla_gbrpvgrw_(n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ncols::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + afb::Ptr{Float32}, ldafb::Ref{BlasInt})::Float32 +end + +function sla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.sla_geamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + x::Ptr{Float32}, incx::Ref{BlasInt}, + beta::Ref{Float32}, + y::Ptr{Float32}, incy::Ref{BlasInt})::Cvoid +end + +function sla_gercond(trans, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) + @ccall libblastrampoline.sla_gercond_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, cmode::Ref{BlasInt}, + c::Ptr{Float32}, + info::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + 1::Clong)::Float32 +end + +function sla_gerfsx_extended(prec_type, trans_type, n, nrhs, a, lda, af, ldaf, ipiv, colequ, + c, b, ldb, y, ldy, berr_out, n_norms, errs_n, errs_c, res, ayb, + dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.sla_gerfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + y::Ptr{Float32}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + errs_n::Ptr{Float32}, + errs_c::Ptr{Float32}, + res::Ptr{Float32}, ayb::Ptr{Float32}, + dy::Ptr{Float32}, y_tail::Ptr{Float32}, + rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sla_gerpvgrw(n, ncols, a, lda, af, ldaf) + @ccall libblastrampoline.sla_gerpvgrw_(n::Ref{BlasInt}, ncols::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt})::Float32 +end + +function sla_lin_berr(n, nz, nrhs, res, ayb, berr) + @ccall libblastrampoline.sla_lin_berr_(n::Ref{BlasInt}, nz::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + res::Ptr{Float32}, ayb::Ptr{Float32}, + berr::Ptr{Float32})::Cvoid +end + +function sla_porcond(uplo, n, a, lda, af, ldaf, cmode, c, info, work, iwork) + @ccall libblastrampoline.sla_porcond_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, + cmode::Ref{BlasInt}, c::Ptr{Float32}, + info::Ref{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + 1::Clong)::Float32 +end + +function sla_porfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, colequ, c, b, ldb, + y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, res, + ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, + info) + @ccall libblastrampoline.sla_porfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, y::Ptr{Float32}, + ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{Float32}, + ayb::Ptr{Float32}, dy::Ptr{Float32}, + y_tail::Ptr{Float32}, rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work) + @ccall libblastrampoline.sla_porpvgrw_(uplo::Ptr{UInt8}, ncols::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Float32 +end + +function sla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.sla_syamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, x::Ptr{Float32}, + incx::Ref{BlasInt}, beta::Ref{Float32}, + y::Ptr{Float32}, + incy::Ref{BlasInt})::Cvoid +end + +function sla_syrcond(uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) + @ccall libblastrampoline.sla_syrcond_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, cmode::Ref{BlasInt}, + c::Ptr{Float32}, + info::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + 1::Clong)::Float32 +end + +function sla_syrfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.sla_syrfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + y::Ptr{Float32}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float32}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + res::Ptr{Float32}, + ayb::Ptr{Float32}, dy::Ptr{Float32}, + y_tail::Ptr{Float32}, rcond::Ref{Float32}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float32}, + dz_ub::Ref{Float32}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.sla_syrpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + af::Ptr{Float32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function sla_wwaddw(n, x, y, w) + @ccall libblastrampoline.sla_wwaddw_(n::Ref{BlasInt}, x::Ptr{Float32}, y::Ptr{Float32}, + w::Ptr{Float32})::Cvoid +end + +function slabad(small, large) + @ccall libblastrampoline.slabad_(small::Ref{Float32}, large::Ref{Float32})::Cvoid +end + +function slabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + @ccall libblastrampoline.slabrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tauq::Ptr{Float32}, taup::Ptr{Float32}, + x::Ptr{Float32}, + ldx::Ref{BlasInt}, y::Ptr{Float32}, + ldy::Ref{BlasInt})::Cvoid +end + +function slacn2(n, v, x, isgn, est, kase, isave) + @ccall libblastrampoline.slacn2_(n::Ref{BlasInt}, v::Ptr{Float32}, x::Ptr{Float32}, + isgn::Ptr{BlasInt}, est::Ref{Float32}, + kase::Ref{BlasInt}, + isave::Ptr{BlasInt})::Cvoid +end + +function slacon(n, v, x, isgn, est, kase) + @ccall libblastrampoline.slacon_(n::Ref{BlasInt}, v::Ptr{Float32}, x::Ptr{Float32}, + isgn::Ptr{BlasInt}, est::Ref{Float32}, + kase::Ref{BlasInt})::Cvoid +end + +function slacpy(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.slacpy_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sladiv(a, b, c, d, p, q) + @ccall libblastrampoline.sladiv_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + d::Ref{Float32}, p::Ref{Float32}, + q::Ref{Float32})::Cvoid +end + +function sladiv1(a, b, c, d, p, q) + @ccall libblastrampoline.sladiv1_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + d::Ref{Float32}, p::Ref{Float32}, + q::Ref{Float32})::Cvoid +end + +function sladiv2(a, b, c, d, r, t) + @ccall libblastrampoline.sladiv2_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + d::Ref{Float32}, r::Ref{Float32}, + t::Ref{Float32})::Float32 +end + +function slae2(a, b, c, rt1, rt2) + @ccall libblastrampoline.slae2_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + rt1::Ref{Float32}, rt2::Ref{Float32})::Cvoid +end + +function slaebz(ijob, nitmax, n, mmax, minp, nbmin, abstol, reltol, pivmin, d, e, e2, nval, + ab, c, mout, nab, work, iwork, info) + @ccall libblastrampoline.slaebz_(ijob::Ref{BlasInt}, nitmax::Ref{BlasInt}, + n::Ref{BlasInt}, + mmax::Ref{BlasInt}, minp::Ref{BlasInt}, + nbmin::Ref{BlasInt}, + abstol::Ref{Float32}, reltol::Ref{Float32}, + pivmin::Ref{Float32}, d::Ptr{Float32}, e::Ptr{Float32}, + e2::Ptr{Float32}, nval::Ptr{BlasInt}, ab::Ptr{Float32}, + c::Ptr{Float32}, mout::Ref{BlasInt}, nab::Ptr{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed0(icompq, qsiz, n, d, e, q, ldq, qstore, ldqs, work, iwork, info) + @ccall libblastrampoline.slaed0_(icompq::Ref{BlasInt}, qsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, qstore::Ptr{Float32}, + ldqs::Ref{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed1(n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) + @ccall libblastrampoline.slaed1_(n::Ref{BlasInt}, d::Ptr{Float32}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, indxq::Ptr{BlasInt}, + rho::Ref{Float32}, + cutpnt::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed2(k, n, n1, d, q, ldq, indxq, rho, z, dlambda, w, q2, indx, indxc, indxp, + coltyp, info) + @ccall libblastrampoline.slaed2_(k::Ref{BlasInt}, n::Ref{BlasInt}, n1::Ref{BlasInt}, + d::Ptr{Float32}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, + indxq::Ptr{BlasInt}, + rho::Ref{Float32}, z::Ptr{Float32}, + dlambda::Ptr{Float32}, + w::Ptr{Float32}, q2::Ptr{Float32}, indx::Ptr{BlasInt}, + indxc::Ptr{BlasInt}, indxp::Ptr{BlasInt}, + coltyp::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed3(k, n, n1, d, q, ldq, rho, dlambda, q2, indx, ctot, w, s, info) + @ccall libblastrampoline.slaed3_(k::Ref{BlasInt}, n::Ref{BlasInt}, n1::Ref{BlasInt}, + d::Ptr{Float32}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, rho::Ref{Float32}, + dlambda::Ptr{Float32}, q2::Ptr{Float32}, + indx::Ptr{BlasInt}, + ctot::Ptr{BlasInt}, w::Ptr{Float32}, s::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slaed4(n, i, d, z, delta, rho, dlam, info) + @ccall libblastrampoline.slaed4_(n::Ref{BlasInt}, i::Ref{BlasInt}, d::Ptr{Float32}, + z::Ptr{Float32}, + delta::Ptr{Float32}, rho::Ref{Float32}, + dlam::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slaed5(i, d, z, delta, rho, dlam) + @ccall libblastrampoline.slaed5_(i::Ref{BlasInt}, d::Ptr{Float32}, z::Ptr{Float32}, + delta::Ptr{Float32}, rho::Ref{Float32}, + dlam::Ref{Float32})::Cvoid +end + +function slaed6(kniter, orgati, rho, d, z, finit, tau, info) + @ccall libblastrampoline.slaed6_(kniter::Ref{BlasInt}, orgati::Ref{BlasInt}, + rho::Ref{Float32}, + d::Ptr{Float32}, z::Ptr{Float32}, finit::Ref{Float32}, + tau::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slaed7(icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq, indxq, rho, cutpnt, + qstore, qptr, prmptr, perm, givptr, givcol, givnum, work, iwork, info) + @ccall libblastrampoline.slaed7_(icompq::Ref{BlasInt}, n::Ref{BlasInt}, + qsiz::Ref{BlasInt}, + tlvls::Ref{BlasInt}, curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, + d::Ptr{Float32}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + indxq::Ptr{BlasInt}, rho::Ref{Float32}, + cutpnt::Ref{BlasInt}, + qstore::Ptr{Float32}, qptr::Ptr{BlasInt}, + prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + givnum::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed8(icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z, dlambda, q2, ldq2, w, + perm, givptr, givcol, givnum, indxp, indx, info) + @ccall libblastrampoline.slaed8_(icompq::Ref{BlasInt}, k::Ref{BlasInt}, n::Ref{BlasInt}, + qsiz::Ref{BlasInt}, d::Ptr{Float32}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, indxq::Ptr{BlasInt}, + rho::Ref{Float32}, + cutpnt::Ref{BlasInt}, z::Ptr{Float32}, + dlambda::Ptr{Float32}, + q2::Ptr{Float32}, ldq2::Ref{BlasInt}, w::Ptr{Float32}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + givnum::Ptr{Float32}, indxp::Ptr{BlasInt}, + indx::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaed9(k, kstart, kstop, n, d, q, ldq, rho, dlambda, w, s, lds, info) + @ccall libblastrampoline.slaed9_(k::Ref{BlasInt}, kstart::Ref{BlasInt}, + kstop::Ref{BlasInt}, + n::Ref{BlasInt}, d::Ptr{Float32}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, rho::Ref{Float32}, + dlambda::Ptr{Float32}, + w::Ptr{Float32}, s::Ptr{Float32}, lds::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaeda(n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol, givnum, q, qptr, z, + ztemp, info) + @ccall libblastrampoline.slaeda_(n::Ref{BlasInt}, tlvls::Ref{BlasInt}, + curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, + givptr::Ptr{BlasInt}, givcol::Ptr{BlasInt}, + givnum::Ptr{Float32}, + q::Ptr{Float32}, qptr::Ptr{BlasInt}, z::Ptr{Float32}, + ztemp::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slaein(rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb, work, eps3, smlnum, + bignum, info) + @ccall libblastrampoline.slaein_(rightv::Ref{BlasInt}, noinit::Ref{BlasInt}, + n::Ref{BlasInt}, + h::Ptr{Float32}, ldh::Ref{BlasInt}, wr::Ref{Float32}, + wi::Ref{Float32}, vr::Ptr{Float32}, vi::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, work::Ptr{Float32}, + eps3::Ref{Float32}, smlnum::Ref{Float32}, + bignum::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slaev2(a, b, c, rt1, rt2, cs1, sn1) + @ccall libblastrampoline.slaev2_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + rt1::Ref{Float32}, rt2::Ref{Float32}, + cs1::Ref{Float32}, + sn1::Ref{Float32})::Cvoid +end + +function slaexc(wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info) + @ccall libblastrampoline.slaexc_(wantq::Ref{BlasInt}, n::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + j1::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slag2(a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) + @ccall libblastrampoline.slag2_(a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, safmin::Ref{Float32}, + scale1::Ref{Float32}, + scale2::Ref{Float32}, wr1::Ref{Float32}, + wr2::Ref{Float32}, + wi::Ref{Float32})::Cvoid +end + +function slag2d(m, n, sa, ldsa, a, lda, info) + @ccall libblastrampoline.slag2d_(m::Ref{BlasInt}, n::Ref{BlasInt}, sa::Ptr{Float32}, + ldsa::Ref{BlasInt}, a::Ptr{Float64}, lda::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + @ccall libblastrampoline.slags2_(upper::Ref{BlasInt}, a1::Ref{Float32}, + a2::Ref{Float32}, + a3::Ref{Float32}, b1::Ref{Float32}, b2::Ref{Float32}, + b3::Ref{Float32}, csu::Ref{Float32}, snu::Ref{Float32}, + csv::Ref{Float32}, snv::Ref{Float32}, + csq::Ref{Float32}, + snq::Ref{Float32})::Cvoid +end + +function slagtf(n, a, lambda, b, c, tol, d, in, info) + @ccall libblastrampoline.slagtf_(n::Ref{BlasInt}, a::Ptr{Float32}, lambda::Ref{Float32}, + b::Ptr{Float32}, c::Ptr{Float32}, tol::Ref{Float32}, + d::Ptr{Float32}, in::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + @ccall libblastrampoline.slagtm_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + alpha::Ref{Float32}, dl::Ptr{Float32}, d::Ptr{Float32}, + du::Ptr{Float32}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + beta::Ref{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slagts(job, n, a, b, c, d, in, y, tol, info) + @ccall libblastrampoline.slagts_(job::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + b::Ptr{Float32}, c::Ptr{Float32}, d::Ptr{Float32}, + in::Ptr{BlasInt}, y::Ptr{Float32}, tol::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slagv2(a, lda, b, ldb, alphar, alphai, beta, csl, snl, csr, snr) + @ccall libblastrampoline.slagv2_(a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, alphar::Ptr{Float32}, + alphai::Ptr{Float32}, + beta::Ptr{Float32}, csl::Ref{Float32}, + snl::Ref{Float32}, + csr::Ref{Float32}, snr::Ref{Float32})::Cvoid +end + +function slahqr(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, info) + @ccall libblastrampoline.slahqr_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float32}, + ldz::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function slahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + @ccall libblastrampoline.slahr2_(n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, y::Ptr{Float32}, + ldy::Ref{BlasInt})::Cvoid +end + +function slaic1(job, j, x, sest, w, gamma, sestpr, s, c) + @ccall libblastrampoline.slaic1_(job::Ref{BlasInt}, j::Ref{BlasInt}, x::Ptr{Float32}, + sest::Ref{Float32}, w::Ptr{Float32}, + gamma::Ref{Float32}, + sestpr::Ref{Float32}, s::Ref{Float32}, + c::Ref{Float32})::Cvoid +end + +function slaln2(ltrans, na, nw, smin, ca, a, lda, d1, d2, b, ldb, wr, wi, x, ldx, scale, + xnorm, info) + @ccall libblastrampoline.slaln2_(ltrans::Ref{BlasInt}, na::Ref{BlasInt}, + nw::Ref{BlasInt}, + smin::Ref{Float32}, ca::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, d1::Ref{Float32}, d2::Ref{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, wr::Ref{Float32}, + wi::Ref{Float32}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + scale::Ref{Float32}, xnorm::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, + givnum, ldgnum, poles, difl, difr, z, k, c, s, work, info) + @ccall libblastrampoline.slals0_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, nrhs::Ref{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, bx::Ptr{Float32}, + ldbx::Ref{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, givnum::Ptr{Float32}, + ldgnum::Ref{BlasInt}, + poles::Ptr{Float32}, difl::Ptr{Float32}, + difr::Ptr{Float32}, + z::Ptr{Float32}, k::Ref{BlasInt}, c::Ref{Float32}, + s::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, + poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + @ccall libblastrampoline.slalsa_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + bx::Ptr{Float32}, ldbx::Ref{BlasInt}, u::Ptr{Float32}, + ldu::Ref{BlasInt}, vt::Ptr{Float32}, k::Ptr{BlasInt}, + difl::Ptr{Float32}, difr::Ptr{Float32}, + z::Ptr{Float32}, + poles::Ptr{Float32}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, perm::Ptr{BlasInt}, + givnum::Ptr{Float32}, + c::Ptr{Float32}, s::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function slalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, iwork, info) + @ccall libblastrampoline.slalsd_(uplo::Ref{UInt8}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + rcond::Ref{Float32}, + rank::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slamrg(n1, n2, a, strd1, strd2, index) + @ccall libblastrampoline.slamrg_(n1::Ref{BlasInt}, n2::Ref{BlasInt}, a::Ptr{Float32}, + strd1::Ref{BlasInt}, strd2::Ref{BlasInt}, + index::Ptr{BlasInt})::Cvoid +end + +function slamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.slamswlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function slamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.slamtsqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function slaneg(n, d, lld, sigma, pivmin, r) + @ccall libblastrampoline.slaneg_(n::Ref{BlasInt}, d::Ptr{Float32}, lld::Ptr{Float32}, + sigma::Ref{Float32}, pivmin::Ref{Float32}, + r::Ref{BlasInt})::BlasInt +end + +function slangb(norm, n, kl, ku, ab, ldab, work) + @ccall libblastrampoline.slangb_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function slange(norm, m, n, a, lda, work) + @ccall libblastrampoline.slange_(norm::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function slangt(norm, n, dl, d, du) + @ccall libblastrampoline.slangt_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{Float32}, + d::Ptr{Float32}, du::Ptr{Float32}, 1::Clong)::Float32 +end + +function slanhs(norm, n, a, lda, work) + @ccall libblastrampoline.slanhs_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, work::Ptr{Float32}, + 1::Clong)::Float32 +end + +function slansb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.slansb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{Float32}, ldab::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong, 1::Clong)::Float32 +end + +function slansf(norm, transr, uplo, n, a, work) + @ccall libblastrampoline.slansf_(norm::Ref{UInt8}, transr::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, work::Ptr{Float32}, + 1::Clong, 1::Clong, 1::Clong)::Float32 +end + +function slansp(norm, uplo, n, ap, work) + @ccall libblastrampoline.slansp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, work::Ptr{Float32}, 1::Clong, + 1::Clong)::Float32 +end + +function slanst(norm, n, d, e) + @ccall libblastrampoline.slanst_(norm::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, 1::Clong)::Float32 +end + +function slansy(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.slansy_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, work::Ptr{Float32}, + 1::Clong, 1::Clong)::Float32 +end + +function slantb(norm, uplo, diag, n, k, ab, ldab, work) + @ccall libblastrampoline.slantb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong, + 1::Clong, + 1::Clong)::Float32 +end + +function slantp(norm, uplo, diag, n, ap, work) + @ccall libblastrampoline.slantp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, work::Ptr{Float32}, + 1::Clong, 1::Clong, 1::Clong)::Float32 +end + +function slantr(norm, uplo, diag, m, n, a, lda, work) + @ccall libblastrampoline.slantr_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong, 1::Clong, + 1::Clong)::Float32 +end + +function slanv2(a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) + @ccall libblastrampoline.slanv2_(a::Ref{Float32}, b::Ref{Float32}, c::Ref{Float32}, + d::Ref{Float32}, rt1r::Ref{Float32}, + rt1i::Ref{Float32}, + rt2r::Ref{Float32}, rt2i::Ref{Float32}, + cs::Ref{Float32}, + sn::Ref{Float32})::Cvoid +end + +function slaorhr_col_getrfnp(m, n, a, lda, d, info) + @ccall libblastrampoline.slaorhr_col_getrfnp_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slaorhr_col_getrfnp2(m, n, a, lda, d, info) + @ccall libblastrampoline.slaorhr_col_getrfnp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slapll(n, x, incx, y, incy, ssmin) + @ccall libblastrampoline.slapll_(n::Ref{BlasInt}, x::Ptr{Float32}, incx::Ref{BlasInt}, + y::Ptr{Float32}, incy::Ref{BlasInt}, + ssmin::Ref{Float32})::Cvoid +end + +function slapmr(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.slapmr_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function slapmt(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.slapmt_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function slapy2(x, y) + @ccall libblastrampoline.slapy2_(x::Ref{Float32}, y::Ref{Float32})::Float32 +end + +function slapy3(x, y, z) + @ccall libblastrampoline.slapy3_(x::Ref{Float32}, y::Ref{Float32}, + z::Ref{Float32})::Float32 +end + +function slaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.slaqgb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, r::Ptr{Float32}, + c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function slaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.slaqge_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + r::Ptr{Float32}, c::Ptr{Float32}, rowcnd::Ref{Float32}, + colcnd::Ref{Float32}, amax::Ref{Float32}, + equed::Ref{UInt8}, + 1::Clong)::Cvoid +end + +function slaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + @ccall libblastrampoline.slaqp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + tau::Ptr{Float32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + work::Ptr{Float32})::Cvoid +end + +function slaqp2rk(m, n, nrhs, ioffset, kmax, abstol, reltol, kp1, maxc2nrm, a, lda, k, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, work, info) + @ccall libblastrampoline.slaqp2rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, kmax::Ref{BlasInt}, + abstol::Ref{Float32}, + reltol::Ref{Float32}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slaqp3rk(m, n, nrhs, ioffset, nb, abstol, reltol, kp1, maxc2nrm, a, lda, done, kb, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, auxv, f, ldf, iwork, info) + @ccall libblastrampoline.slaqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, nb::Ref{BlasInt}, + abstol::Ref{Float32}, + reltol::Ref{Float32}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float32}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + done::Ref{BlasInt}, kb::Ref{BlasInt}, + maxc2nrmk::Ref{Float32}, + relmaxc2nrmk::Ref{Float32}, jpiv::Ptr{BlasInt}, + tau::Ptr{Float32}, vn1::Ptr{Float32}, + vn2::Ptr{Float32}, + auxv::Ptr{Float32}, f::Ptr{Float32}, + ldf::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function slaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + @ccall libblastrampoline.slaqps_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{Float32}, + vn1::Ptr{Float32}, + vn2::Ptr{Float32}, auxv::Ptr{Float32}, f::Ptr{Float32}, + ldf::Ref{BlasInt})::Cvoid +end + +function slaqr0(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, + info) + @ccall libblastrampoline.slaqr0_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaqr1(n, h, ldh, sr1, si1, sr2, si2, v) + @ccall libblastrampoline.slaqr1_(n::Ref{BlasInt}, h::Ptr{Float32}, ldh::Ref{BlasInt}, + sr1::Ref{Float32}, si1::Ref{Float32}, + sr2::Ref{Float32}, + si2::Ref{Float32}, v::Ptr{Float32})::Cvoid +end + +function slaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, + v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.slaqr2_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{Float32}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, sr::Ptr{Float32}, + si::Ptr{Float32}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{Float32}, ldwv::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt})::Cvoid +end + +function slaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sr, si, + v, ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.slaqr3_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{Float32}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, sr::Ptr{Float32}, + si::Ptr{Float32}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{Float32}, ldwv::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt})::Cvoid +end + +function slaqr4(wantt, wantz, n, ilo, ihi, h, ldh, wr, wi, iloz, ihiz, z, ldz, work, lwork, + info) + @ccall libblastrampoline.slaqr4_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, wr::Ptr{Float32}, wi::Ptr{Float32}, + iloz::Ref{BlasInt}, ihiz::Ref{BlasInt}, + z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, sr, si, h, ldh, iloz, ihiz, z, + ldz, v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + @ccall libblastrampoline.slaqr5_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + kacc22::Ref{BlasInt}, + n::Ref{BlasInt}, ktop::Ref{BlasInt}, + kbot::Ref{BlasInt}, + nshfts::Ref{BlasInt}, sr::Ptr{Float32}, + si::Ptr{Float32}, + h::Ptr{Float32}, ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, u::Ptr{Float32}, + ldu::Ref{BlasInt}, nv::Ref{BlasInt}, wv::Ptr{Float32}, + ldwv::Ref{BlasInt}, nh::Ref{BlasInt}, wh::Ptr{Float32}, + ldwh::Ref{BlasInt})::Cvoid +end + +function slaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.slaqsb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, amax::Ref{Float32}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function slaqsp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.slaqsp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function slaqsy(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.slaqsy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function slaqtr(ltran, lreal, n, t, ldt, b, w, scale, x, work, info) + @ccall libblastrampoline.slaqtr_(ltran::Ref{BlasInt}, lreal::Ref{BlasInt}, + n::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, b::Ptr{Float32}, + w::Ref{Float32}, scale::Ref{Float32}, x::Ptr{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, + mingma, r, isuppz, nrminv, resid, rqcorr, work) + @ccall libblastrampoline.slar1v_(n::Ref{BlasInt}, b1::Ref{BlasInt}, bn::Ref{BlasInt}, + lambda::Ref{Float32}, d::Ptr{Float32}, l::Ptr{Float32}, + ld::Ptr{Float32}, lld::Ptr{Float32}, + pivmin::Ref{Float32}, + gaptol::Ref{Float32}, z::Ptr{Float32}, + wantnc::Ref{BlasInt}, + negcnt::Ref{BlasInt}, ztz::Ref{Float32}, + mingma::Ref{Float32}, + r::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + nrminv::Ref{Float32}, + resid::Ref{Float32}, rqcorr::Ref{Float32}, + work::Ptr{Float32})::Cvoid +end + +function slar2v(n, x, y, z, incx, c, s, incc) + @ccall libblastrampoline.slar2v_(n::Ref{BlasInt}, x::Ptr{Float32}, y::Ptr{Float32}, + z::Ptr{Float32}, incx::Ref{BlasInt}, c::Ptr{Float32}, + s::Ptr{Float32}, incc::Ref{BlasInt})::Cvoid +end + +function slarf(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.slarf_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float32}, + incv::Ref{BlasInt}, tau::Ref{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong)::Cvoid +end + +function slarf1f(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.slarf1f_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float32}, incv::Ref{BlasInt}, + tau::Ref{Float32}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Cvoid +end + +function slarf1l(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.slarf1l_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float32}, incv::Ref{BlasInt}, + tau::Ref{Float32}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, + 1::Clong)::Cvoid +end + +function slarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + @ccall libblastrampoline.slarfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function slarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork) + @ccall libblastrampoline.slarfb_gett_(ident::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, work::Ptr{Float32}, + ldwork::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slarfg(n, alpha, x, incx, tau) + @ccall libblastrampoline.slarfg_(n::Ref{BlasInt}, alpha::Ref{Float32}, x::Ptr{Float32}, + incx::Ref{BlasInt}, tau::Ref{Float32})::Cvoid +end + +function slarfgp(n, alpha, x, incx, tau) + @ccall libblastrampoline.slarfgp_(n::Ref{BlasInt}, alpha::Ref{Float32}, x::Ptr{Float32}, + incx::Ref{BlasInt}, tau::Ref{Float32})::Cvoid +end + +function slarft(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.slarft_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + tau::Ptr{Float32}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function slarfx(side, m, n, v, tau, c, ldc, work) + @ccall libblastrampoline.slarfx_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{Float32}, tau::Ref{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong)::Cvoid +end + +function slarfy(uplo, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.slarfy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, v::Ptr{Float32}, + incv::Ref{BlasInt}, tau::Ref{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, 1::Clong)::Cvoid +end + +function slargv(n, x, incx, y, incy, c, incc) + @ccall libblastrampoline.slargv_(n::Ref{BlasInt}, x::Ptr{Float32}, incx::Ref{BlasInt}, + y::Ptr{Float32}, incy::Ref{BlasInt}, c::Ptr{Float32}, + incc::Ref{BlasInt})::Cvoid +end + +function slarmm(anorm, bnorm, cnorm) + @ccall libblastrampoline.slarmm_(anorm::Ref{Float32}, bnorm::Ref{Float32}, + cnorm::Ref{Float32})::Float32 +end + +function slarnv(idist, iseed, n, x) + @ccall libblastrampoline.slarnv_(idist::Ref{BlasInt}, iseed::Ptr{BlasInt}, + n::Ref{BlasInt}, + x::Ptr{Float32})::Cvoid +end + +function slarra(n, d, e, e2, spltol, tnrm, nsplit, isplit, info) + @ccall libblastrampoline.slarra_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + e2::Ptr{Float32}, spltol::Ref{Float32}, + tnrm::Ref{Float32}, + nsplit::Ref{BlasInt}, isplit::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slarrb(n, d, lld, ifirst, ilast, rtol1, rtol2, offset, w, wgap, werr, work, iwork, + pivmin, spdiam, twist, info) + @ccall libblastrampoline.slarrb_(n::Ref{BlasInt}, d::Ptr{Float32}, lld::Ptr{Float32}, + ifirst::Ref{BlasInt}, ilast::Ref{BlasInt}, + rtol1::Ref{Float32}, + rtol2::Ref{Float32}, offset::Ref{BlasInt}, + w::Ptr{Float32}, + wgap::Ptr{Float32}, werr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, pivmin::Ref{Float32}, + spdiam::Ref{Float32}, + twist::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function slarrc(jobt, n, vl, vu, d, e, pivmin, eigcnt, lcnt, rcnt, info) + @ccall libblastrampoline.slarrc_(jobt::Ref{UInt8}, n::Ref{BlasInt}, vl::Ref{Float32}, + vu::Ref{Float32}, d::Ptr{Float32}, e::Ptr{Float32}, + pivmin::Ref{Float32}, eigcnt::Ref{BlasInt}, + lcnt::Ref{BlasInt}, + rcnt::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slarrd(range, order, n, vl, vu, il, iu, gers, reltol, d, e, e2, pivmin, nsplit, + isplit, m, w, werr, wl, wu, iblock, indexw, work, iwork, info) + @ccall libblastrampoline.slarrd_(range::Ref{UInt8}, order::Ref{UInt8}, n::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, gers::Ptr{Float32}, + reltol::Ref{Float32}, + d::Ptr{Float32}, e::Ptr{Float32}, e2::Ptr{Float32}, + pivmin::Ref{Float32}, nsplit::Ref{BlasInt}, + isplit::Ptr{BlasInt}, + m::Ref{BlasInt}, w::Ptr{Float32}, werr::Ptr{Float32}, + wl::Ref{Float32}, wu::Ref{Float32}, + iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function slarre(range, n, vl, vu, il, iu, d, e, e2, rtol1, rtol2, spltol, nsplit, isplit, m, + w, werr, wgap, iblock, indexw, gers, pivmin, work, iwork, info) + @ccall libblastrampoline.slarre_(range::Ref{UInt8}, n::Ref{BlasInt}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, e2::Ptr{Float32}, + rtol1::Ref{Float32}, rtol2::Ref{Float32}, + spltol::Ref{Float32}, nsplit::Ref{BlasInt}, + isplit::Ptr{BlasInt}, + m::Ref{BlasInt}, w::Ptr{Float32}, werr::Ptr{Float32}, + wgap::Ptr{Float32}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float32}, pivmin::Ref{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slarrf(n, d, l, ld, clstrt, clend, w, wgap, werr, spdiam, clgapl, clgapr, pivmin, + sigma, dplus, lplus, work, info) + @ccall libblastrampoline.slarrf_(n::Ref{BlasInt}, d::Ptr{Float32}, l::Ptr{Float32}, + ld::Ptr{Float32}, clstrt::Ref{BlasInt}, + clend::Ref{BlasInt}, + w::Ptr{Float32}, wgap::Ptr{Float32}, + werr::Ptr{Float32}, + spdiam::Ref{Float32}, clgapl::Ref{Float32}, + clgapr::Ref{Float32}, pivmin::Ref{Float32}, + sigma::Ref{Float32}, dplus::Ptr{Float32}, + lplus::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slarrj(n, d, e2, ifirst, ilast, rtol, offset, w, werr, work, iwork, pivmin, spdiam, + info) + @ccall libblastrampoline.slarrj_(n::Ref{BlasInt}, d::Ptr{Float32}, e2::Ptr{Float32}, + ifirst::Ref{BlasInt}, ilast::Ref{BlasInt}, + rtol::Ref{Float32}, + offset::Ref{BlasInt}, w::Ptr{Float32}, + werr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + pivmin::Ref{Float32}, + spdiam::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slarrk(n, iw, gl, gu, d, e2, pivmin, reltol, w, werr, info) + @ccall libblastrampoline.slarrk_(n::Ref{BlasInt}, iw::Ref{BlasInt}, gl::Ref{Float32}, + gu::Ref{Float32}, d::Ptr{Float32}, e2::Ptr{Float32}, + pivmin::Ref{Float32}, reltol::Ref{Float32}, + w::Ref{Float32}, + werr::Ref{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slarrr(n, d, e, info) + @ccall libblastrampoline.slarrr_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, + wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + @ccall libblastrampoline.slarrv_(n::Ref{BlasInt}, vl::Ref{Float32}, vu::Ref{Float32}, + d::Ptr{Float32}, l::Ptr{Float32}, pivmin::Ref{Float32}, + isplit::Ptr{BlasInt}, m::Ref{BlasInt}, + dol::Ref{BlasInt}, + dou::Ref{BlasInt}, minrgp::Ref{Float32}, + rtol1::Ref{Float32}, + rtol2::Ref{Float32}, w::Ptr{Float32}, + werr::Ptr{Float32}, + wgap::Ptr{Float32}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slarscl2(m, n, d, x, ldx) + @ccall libblastrampoline.slarscl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float32}, + x::Ptr{Float32}, ldx::Ref{BlasInt})::Cvoid +end + +function slartgp(f, g, cs, sn, r) + @ccall libblastrampoline.slartgp_(f::Ref{Float32}, g::Ref{Float32}, cs::Ref{Float32}, + sn::Ref{Float32}, r::Ref{Float32})::Cvoid +end + +function slartgs(x, y, sigma, cs, sn) + @ccall libblastrampoline.slartgs_(x::Ref{Float32}, y::Ref{Float32}, sigma::Ref{Float32}, + cs::Ref{Float32}, sn::Ref{Float32})::Cvoid +end + +function slartv(n, x, incx, y, incy, c, s, incc) + @ccall libblastrampoline.slartv_(n::Ref{BlasInt}, x::Ptr{Float32}, incx::Ref{BlasInt}, + y::Ptr{Float32}, incy::Ref{BlasInt}, c::Ptr{Float32}, + s::Ptr{Float32}, incc::Ref{BlasInt})::Cvoid +end + +function slaruv(iseed, n, x) + @ccall libblastrampoline.slaruv_(iseed::Ptr{BlasInt}, n::Ref{BlasInt}, + x::Ptr{Float32})::Cvoid +end + +function slarz(side, m, n, l, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.slarz_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + l::Ref{BlasInt}, + v::Ptr{Float32}, incv::Ref{BlasInt}, tau::Ref{Float32}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, work::Ptr{Float32}, + 1::Clong)::Cvoid +end + +function slarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, + ldwork) + @ccall libblastrampoline.slarzb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + ldwork::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function slarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.slarzt_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + tau::Ptr{Float32}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function slas2(f, g, h, ssmin, ssmax) + @ccall libblastrampoline.slas2_(f::Ref{Float32}, g::Ref{Float32}, h::Ref{Float32}, + ssmin::Ref{Float32}, ssmax::Ref{Float32})::Cvoid +end + +function slascl(type, kl, ku, cfrom, cto, m, n, a, lda, info) + @ccall libblastrampoline.slascl_(type::Ref{UInt8}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + cfrom::Ref{Float32}, cto::Ref{Float32}, + m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slascl2(m, n, d, x, ldx) + @ccall libblastrampoline.slascl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float32}, + x::Ptr{Float32}, ldx::Ref{BlasInt})::Cvoid +end + +function slasd0(n, sqre, d, e, u, ldu, vt, ldvt, smlsiz, iwork, work, info) + @ccall libblastrampoline.slasd0_(n::Ref{BlasInt}, sqre::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + vt::Ptr{Float32}, ldvt::Ref{BlasInt}, + smlsiz::Ref{BlasInt}, + iwork::Ptr{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasd1(nl, nr, sqre, d, alpha, beta, u, ldu, vt, ldvt, idxq, iwork, work, info) + @ccall libblastrampoline.slasd1_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + d::Ptr{Float32}, alpha::Ref{Float32}, + beta::Ref{Float32}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, idxq::Ptr{BlasInt}, + iwork::Ptr{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slasd2(nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt, ldvt, dsigma, u2, ldu2, vt2, + ldvt2, idxp, idx, idxc, idxq, coltyp, info) + @ccall libblastrampoline.slasd2_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + k::Ref{BlasInt}, + d::Ptr{Float32}, z::Ptr{Float32}, alpha::Ref{Float32}, + beta::Ref{Float32}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + vt::Ptr{Float32}, ldvt::Ref{BlasInt}, + dsigma::Ptr{Float32}, + u2::Ptr{Float32}, ldu2::Ref{BlasInt}, + vt2::Ptr{Float32}, + ldvt2::Ref{BlasInt}, idxp::Ptr{BlasInt}, + idx::Ptr{BlasInt}, + idxc::Ptr{BlasInt}, idxq::Ptr{BlasInt}, + coltyp::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slasd3(nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, + idxc, ctot, z, info) + @ccall libblastrampoline.slasd3_(nl::Ref{BlasInt}, nr::Ref{BlasInt}, sqre::Ref{BlasInt}, + k::Ref{BlasInt}, + d::Ptr{Float32}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + dsigma::Ptr{Float32}, u::Ptr{Float32}, + ldu::Ref{BlasInt}, + u2::Ptr{Float32}, ldu2::Ref{BlasInt}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, vt2::Ptr{Float32}, + ldvt2::Ref{BlasInt}, + idxc::Ptr{BlasInt}, ctot::Ptr{BlasInt}, + z::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasd4(n, i, d, z, delta, rho, sigma, work, info) + @ccall libblastrampoline.slasd4_(n::Ref{BlasInt}, i::Ref{BlasInt}, d::Ptr{Float32}, + z::Ptr{Float32}, + delta::Ptr{Float32}, rho::Ref{Float32}, + sigma::Ref{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slasd5(i, d, z, delta, rho, dsigma, work) + @ccall libblastrampoline.slasd5_(i::Ref{BlasInt}, d::Ptr{Float32}, z::Ptr{Float32}, + delta::Ptr{Float32}, rho::Ref{Float32}, + dsigma::Ref{Float32}, + work::Ptr{Float32})::Cvoid +end + +function slasd6(icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, + ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info) + @ccall libblastrampoline.slasd6_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, d::Ptr{Float32}, vf::Ptr{Float32}, + vl::Ptr{Float32}, alpha::Ref{Float32}, + beta::Ref{Float32}, + idxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + givnum::Ptr{Float32}, + ldgnum::Ref{BlasInt}, poles::Ptr{Float32}, + difl::Ptr{Float32}, + difr::Ptr{Float32}, z::Ptr{Float32}, k::Ref{BlasInt}, + c::Ref{Float32}, s::Ref{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function slasd7(icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, + idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info) + @ccall libblastrampoline.slasd7_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, k::Ref{BlasInt}, d::Ptr{Float32}, + z::Ptr{Float32}, zw::Ptr{Float32}, vf::Ptr{Float32}, + vfw::Ptr{Float32}, vl::Ptr{Float32}, vlw::Ptr{Float32}, + alpha::Ref{Float32}, beta::Ref{Float32}, + dsigma::Ptr{Float32}, idx::Ptr{BlasInt}, + idxp::Ptr{BlasInt}, + idxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + givnum::Ptr{Float32}, + ldgnum::Ref{BlasInt}, c::Ref{Float32}, s::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasd8(icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info) + @ccall libblastrampoline.slasd8_(icompq::Ref{BlasInt}, k::Ref{BlasInt}, d::Ptr{Float32}, + z::Ptr{Float32}, vf::Ptr{Float32}, vl::Ptr{Float32}, + difl::Ptr{Float32}, difr::Ptr{Float32}, + lddifr::Ref{BlasInt}, + dsigma::Ptr{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasda(icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, + givcol, ldgcol, perm, givnum, c, s, work, iwork, info) + @ccall libblastrampoline.slasda_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + sqre::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, vt::Ptr{Float32}, + k::Ptr{BlasInt}, difl::Ptr{Float32}, + difr::Ptr{Float32}, + z::Ptr{Float32}, poles::Ptr{Float32}, + givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, ldgcol::Ref{BlasInt}, + perm::Ptr{BlasInt}, + givnum::Ptr{Float32}, c::Ptr{Float32}, s::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slasdq(uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info) + @ccall libblastrampoline.slasdq_(uplo::Ref{UInt8}, sqre::Ref{BlasInt}, n::Ref{BlasInt}, + ncvt::Ref{BlasInt}, nru::Ref{BlasInt}, + ncc::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vt::Ptr{Float32}, + ldvt::Ref{BlasInt}, u::Ptr{Float32}, ldu::Ref{BlasInt}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slasdt(n, lvl, nd, inode, ndiml, ndimr, msub) + @ccall libblastrampoline.slasdt_(n::Ref{BlasInt}, lvl::Ref{BlasInt}, nd::Ref{BlasInt}, + inode::Ptr{BlasInt}, ndiml::Ptr{BlasInt}, + ndimr::Ptr{BlasInt}, + msub::Ref{BlasInt})::Cvoid +end + +function slaset(uplo, m, n, alpha, beta, a, lda) + @ccall libblastrampoline.slaset_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float32}, beta::Ref{Float32}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slasq1(n, d, e, work, info) + @ccall libblastrampoline.slasq1_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function slasq2(n, z, info) + @ccall libblastrampoline.slasq2_(n::Ref{BlasInt}, z::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasq3(i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee, ttype, + dmin1, dmin2, dn, dn1, dn2, g, tau) + @ccall libblastrampoline.slasq3_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float32}, + pp::Ref{BlasInt}, + dmin::Ref{Float32}, sigma::Ref{Float32}, + desig::Ref{Float32}, + qmax::Ref{Float32}, nfail::Ref{BlasInt}, + iter::Ref{BlasInt}, + ndiv::Ref{BlasInt}, ieee::Ref{BlasInt}, + ttype::Ref{BlasInt}, + dmin1::Ref{Float32}, dmin2::Ref{Float32}, + dn::Ref{Float32}, + dn1::Ref{Float32}, dn2::Ref{Float32}, g::Ref{Float32}, + tau::Ref{Float32})::Cvoid +end + +function slasq4(i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype, g) + @ccall libblastrampoline.slasq4_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float32}, + pp::Ref{BlasInt}, + n0in::Ref{BlasInt}, dmin::Ref{Float32}, + dmin1::Ref{Float32}, + dmin2::Ref{Float32}, dn::Ref{Float32}, + dn1::Ref{Float32}, + dn2::Ref{Float32}, tau::Ref{Float32}, + ttype::Ref{BlasInt}, + g::Ref{Float32})::Cvoid +end + +function slasq5(i0, n0, z, pp, tau, sigma, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee, eps) + @ccall libblastrampoline.slasq5_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float32}, + pp::Ref{BlasInt}, + tau::Ref{Float32}, sigma::Ref{Float32}, + dmin::Ref{Float32}, + dmin1::Ref{Float32}, dmin2::Ref{Float32}, + dn::Ref{Float32}, + dnm1::Ref{Float32}, dnm2::Ref{Float32}, + ieee::Ref{BlasInt}, + eps::Ref{Float32})::Cvoid +end + +function slasq6(i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) + @ccall libblastrampoline.slasq6_(i0::Ref{BlasInt}, n0::Ref{BlasInt}, z::Ptr{Float32}, + pp::Ref{BlasInt}, + dmin::Ref{Float32}, dmin1::Ref{Float32}, + dmin2::Ref{Float32}, + dn::Ref{Float32}, dnm1::Ref{Float32}, + dnm2::Ref{Float32})::Cvoid +end + +function slasr(side, pivot, direct, m, n, c, s, a, lda) + @ccall libblastrampoline.slasr_(side::Ref{UInt8}, pivot::Ref{UInt8}, direct::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, c::Ptr{Float32}, + s::Ptr{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function slasrt(id, n, d, info) + @ccall libblastrampoline.slasrt_(id::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slasv2(f, g, h, ssmin, ssmax, snr, csr, snl, csl) + @ccall libblastrampoline.slasv2_(f::Ref{Float32}, g::Ref{Float32}, h::Ref{Float32}, + ssmin::Ref{Float32}, ssmax::Ref{Float32}, + snr::Ref{Float32}, + csr::Ref{Float32}, snl::Ref{Float32}, + csl::Ref{Float32})::Cvoid +end + +function slaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.slaswlq_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slaswp(n, a, lda, k1, k2, ipiv, incx) + @ccall libblastrampoline.slaswp_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + k1::Ref{BlasInt}, + k2::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + incx::Ref{BlasInt})::Cvoid +end + +function slasy2(ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, + xnorm, info) + @ccall libblastrampoline.slasy2_(ltranl::Ref{BlasInt}, ltranr::Ref{BlasInt}, + isgn::Ref{BlasInt}, + n1::Ref{BlasInt}, n2::Ref{BlasInt}, tl::Ptr{Float32}, + ldtl::Ref{BlasInt}, tr::Ptr{Float32}, + ldtr::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + scale::Ref{Float32}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + xnorm::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function slasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.slasyf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + w::Ptr{Float32}, ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.slasyf_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{Float32}, + ldh::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Cvoid +end + +function slasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.slasyf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + e::Ptr{Float32}, ipiv::Ptr{BlasInt}, + w::Ptr{Float32}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.slasyf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{Float32}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + @ccall libblastrampoline.slatbs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, x::Ptr{Float32}, + scale::Ref{Float32}, cnorm::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function slatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + @ccall libblastrampoline.slatdf_(ijob::Ref{BlasInt}, n::Ref{BlasInt}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, rhs::Ptr{Float32}, + rdsum::Ref{Float32}, + rdscal::Ref{Float32}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt})::Cvoid +end + +function slatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + @ccall libblastrampoline.slatps_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + x::Ptr{Float32}, scale::Ref{Float32}, + cnorm::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function slatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + @ccall libblastrampoline.slatrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, e::Ptr{Float32}, + tau::Ptr{Float32}, w::Ptr{Float32}, ldw::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function slatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + @ccall libblastrampoline.slatrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, x::Ptr{Float32}, + scale::Ref{Float32}, + cnorm::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function slatrs3(uplo, trans, diag, normin, n, nrhs, a, lda, x, ldx, scale, cnorm, work, + lwork, info) + @ccall libblastrampoline.slatrs3_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, scale::Ptr{Float32}, + cnorm::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function slatrz(m, n, l, a, lda, tau, work) + @ccall libblastrampoline.slatrz_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32})::Cvoid +end + +function slatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.slatsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function slauu2(uplo, n, a, lda, info) + @ccall libblastrampoline.slauu2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function slauum(uplo, n, a, lda, info) + @ccall libblastrampoline.slauum_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sopgtr(uplo, n, ap, tau, q, ldq, work, info) + @ccall libblastrampoline.sopgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + tau::Ptr{Float32}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sopmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + @ccall libblastrampoline.sopmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, ap::Ptr{Float32}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function sorbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, + theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + @ccall libblastrampoline.sorbdb_(trans::Ref{UInt8}, signs::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x12::Ptr{Float32}, + ldx12::Ref{BlasInt}, + x21::Ptr{Float32}, ldx21::Ref{BlasInt}, + x22::Ptr{Float32}, + ldx22::Ref{BlasInt}, theta::Ptr{Float32}, + phi::Ptr{Float32}, + taup1::Ptr{Float32}, taup2::Ptr{Float32}, + tauq1::Ptr{Float32}, tauq2::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sorbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.sorbdb1_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x21::Ptr{Float32}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, phi::Ptr{Float32}, + taup1::Ptr{Float32}, + taup2::Ptr{Float32}, tauq1::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.sorbdb2_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x21::Ptr{Float32}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, phi::Ptr{Float32}, + taup1::Ptr{Float32}, + taup2::Ptr{Float32}, tauq1::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.sorbdb3_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x21::Ptr{Float32}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, phi::Ptr{Float32}, + taup1::Ptr{Float32}, + taup2::Ptr{Float32}, tauq1::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, + work, lwork, info) + @ccall libblastrampoline.sorbdb4_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x21::Ptr{Float32}, + ldx21::Ref{BlasInt}, + theta::Ptr{Float32}, phi::Ptr{Float32}, + taup1::Ptr{Float32}, + taup2::Ptr{Float32}, tauq1::Ptr{Float32}, + phantom::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.sorbdb5_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{Float32}, incx1::Ref{BlasInt}, + x2::Ptr{Float32}, + incx2::Ref{BlasInt}, q1::Ptr{Float32}, + ldq1::Ref{BlasInt}, + q2::Ptr{Float32}, ldq2::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.sorbdb6_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{Float32}, incx1::Ref{BlasInt}, + x2::Ptr{Float32}, + incx2::Ref{BlasInt}, q1::Ptr{Float32}, + ldq1::Ref{BlasInt}, + q2::Ptr{Float32}, ldq2::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorcsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, + x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, + work, lwork, iwork, info) + @ccall libblastrampoline.sorcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, + signs::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, + ldx11::Ref{BlasInt}, x12::Ptr{Float32}, + ldx12::Ref{BlasInt}, + x21::Ptr{Float32}, ldx21::Ref{BlasInt}, + x22::Ptr{Float32}, + ldx22::Ref{BlasInt}, theta::Ptr{Float32}, + u1::Ptr{Float32}, + ldu1::Ref{BlasInt}, u2::Ptr{Float32}, + ldu2::Ref{BlasInt}, + v1t::Ptr{Float32}, ldv1t::Ref{BlasInt}, + v2t::Ptr{Float32}, + ldv2t::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sorcsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, + u2, ldu2, v1t, ldv1t, work, lwork, iwork, info) + @ccall libblastrampoline.sorcsd2by1_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{Float32}, ldx11::Ref{BlasInt}, + x21::Ptr{Float32}, + ldx21::Ref{BlasInt}, theta::Ptr{Float32}, + u1::Ptr{Float32}, + ldu1::Ref{BlasInt}, u2::Ptr{Float32}, + ldu2::Ref{BlasInt}, + v1t::Ptr{Float32}, ldv1t::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sorg2l(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.sorg2l_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sorg2r(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.sorg2r_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sorgbr(vect, m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorgbr_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sorghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorghr_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorgl2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.sorgl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sorglq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorglq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorgql(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorgql_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorgqr(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorgqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorgr2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.sorgr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sorgrq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorgrq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorgtr(uplo, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.sorgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sorgtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.sorgtsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sorgtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.sorgtsqr_row_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function sorhr_col(m, n, nb, a, lda, t, ldt, d, info) + @ccall libblastrampoline.sorhr_col_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, d::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sorm22(side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) + @ccall libblastrampoline.sorm22_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + q::Ptr{Float32}, + ldq::Ref{BlasInt}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sorm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.sorm2l_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sorm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.sorm2r_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sormbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormbr_(vect::Ref{UInt8}, side::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function sormhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormhr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, tau::Ptr{Float32}, + c::Ptr{Float32}, ldc::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sorml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.sorml2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sormlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sormql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormql_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sormqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sormr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.sormr2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sormr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.sormr3_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sormrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormrq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sormrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormrz_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tau::Ptr{Float32}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sormtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.sormtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, c::Ptr{Float32}, ldc::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function spbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.spbcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + @ccall libblastrampoline.spbequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, amax::Ref{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.spbrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + afb::Ptr{Float32}, ldafb::Ref{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbstf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.spbstf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.spbsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, + rcond, ferr, berr, work, iwork, info) + @ccall libblastrampoline.spbsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, afb::Ptr{Float32}, + ldafb::Ref{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function spbtf2(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.spbtf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbtrf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.spbtrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.spbtrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spftrf(transr, uplo, n, a, info) + @ccall libblastrampoline.spftrf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function spftri(transr, uplo, n, a, info) + @ccall libblastrampoline.spftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function spftrs(transr, uplo, n, nrhs, a, b, ldb, info) + @ccall libblastrampoline.spftrs_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function spocon(uplo, n, a, lda, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.spocon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spoequ(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.spoequ_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function spoequb(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.spoequb_(n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.sporfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sporfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, + n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, iwork, + info) + @ccall libblastrampoline.sporfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, s::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function sposv(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.sposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + ferr, berr, work, iwork, info) + @ccall libblastrampoline.sposvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function sposvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, + work, iwork, info) + @ccall libblastrampoline.sposvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + rpvgrw::Ref{Float32}, berr::Ptr{Float32}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, nparams::Ref{BlasInt}, + params::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function spotf2(uplo, n, a, lda, info) + @ccall libblastrampoline.spotf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spotrf(uplo, n, a, lda, info) + @ccall libblastrampoline.spotrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spotrf2(uplo, n, a, lda, info) + @ccall libblastrampoline.spotrf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spotri(uplo, n, a, lda, info) + @ccall libblastrampoline.spotri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spotrs(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.spotrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sppcon(uplo, n, ap, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.sppcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sppequ(uplo, n, ap, s, scond, amax, info) + @ccall libblastrampoline.sppequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + s::Ptr{Float32}, scond::Ref{Float32}, + amax::Ref{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info) + @ccall libblastrampoline.spprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, afp::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sppsv(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.sppsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, + work, iwork, info) + @ccall libblastrampoline.sppsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{Float32}, + afp::Ptr{Float32}, + equed::Ref{UInt8}, s::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function spptrf(uplo, n, ap, info) + @ccall libblastrampoline.spptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spptri(uplo, n, ap, info) + @ccall libblastrampoline.spptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spptrs(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.spptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spstf2(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.spstf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function spstrf(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.spstrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sptcon(n, d, e, anorm, rcond, work, info) + @ccall libblastrampoline.sptcon_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function spteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.spteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sptrfs(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info) + @ccall libblastrampoline.sptrfs_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, df::Ptr{Float32}, ef::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function sptsv(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.sptsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info) + @ccall libblastrampoline.sptsvx_(fact::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, df::Ptr{Float32}, + ef::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function spttrf(n, d, e, info) + @ccall libblastrampoline.spttrf_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function spttrs(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.spttrs_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sptts2(n, nrhs, d, e, b, ldb) + @ccall libblastrampoline.sptts2_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt})::Cvoid +end + +function srscl(n, sa, sx, incx) + @ccall libblastrampoline.srscl_(n::Ref{BlasInt}, sa::Ref{Float32}, sx::Ptr{Float32}, + incx::Ref{BlasInt})::Cvoid +end + +function ssb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, + work) + @ccall libblastrampoline.ssb2st_kernels_(uplo::Ref{UInt8}, wantz::Ref{BlasInt}, + ttype::Ref{BlasInt}, + st::Ref{BlasInt}, ed::Ref{BlasInt}, + sweep::Ref{BlasInt}, + n::Ref{BlasInt}, nb::Ref{BlasInt}, + ib::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + v::Ptr{Float32}, + tau::Ptr{Float32}, ldvt::Ref{BlasInt}, + work::Ptr{Float32}, 1::Clong)::Cvoid +end + +function ssbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info) + @ccall libblastrampoline.ssbev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float32}, ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssbev_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, info) + @ccall libblastrampoline.ssbev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssbevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float32}, ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssbevd_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, + info) + @ccall libblastrampoline.ssbevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, + ldz, work, iwork, ifail, info) + @ccall libblastrampoline.ssbevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function ssbevx_2stage(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, + m, w, z, ldz, work, lwork, iwork, ifail, info) + @ccall libblastrampoline.ssbevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, + ldab::Ref{BlasInt}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info) + @ccall libblastrampoline.ssbgst_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, bb::Ptr{Float32}, + ldbb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ssbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info) + @ccall libblastrampoline.ssbgv_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, bb::Ptr{Float32}, + ldbb::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, + liwork, info) + @ccall libblastrampoline.ssbgvd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, bb::Ptr{Float32}, + ldbb::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, + abstol, m, w, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.ssbgvx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{Float32}, + ldab::Ref{BlasInt}, bb::Ptr{Float32}, + ldbb::Ref{BlasInt}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + @ccall libblastrampoline.ssbtrd_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{Float32}, ldab::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, q::Ptr{Float32}, + ldq::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + @ccall libblastrampoline.ssfrk_(transr::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, beta::Ref{Float32}, + c::Ptr{Float32}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sspcon(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.sspcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float32}, + rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sspev(jobz, uplo, n, ap, w, z, ldz, work, info) + @ccall libblastrampoline.sspev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sspevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.sspevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sspevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, + ifail, info) + @ccall libblastrampoline.sspevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function sspgst(itype, uplo, n, ap, bp, info) + @ccall libblastrampoline.sspgst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, bp::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sspgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info) + @ccall libblastrampoline.sspgv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, bp::Ptr{Float32}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sspgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.sspgvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, bp::Ptr{Float32}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sspgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, + work, iwork, ifail, info) + @ccall libblastrampoline.sspgvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + bp::Ptr{Float32}, vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, + m::Ref{BlasInt}, w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ssprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info) + @ccall libblastrampoline.ssprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, afp::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.sspsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.sspsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{Float32}, + afp::Ptr{Float32}, + ipiv::Ptr{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssptrd(uplo, n, ap, d, e, tau, info) + @ccall libblastrampoline.ssptrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + d::Ptr{Float32}, e::Ptr{Float32}, tau::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.ssptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.ssptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + ipiv::Ptr{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.ssptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{Float32}, ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sstebz(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, + work, iwork, info) + @ccall libblastrampoline.sstebz_(range::Ref{UInt8}, order::Ref{UInt8}, n::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + d::Ptr{Float32}, + e::Ptr{Float32}, m::Ref{BlasInt}, nsplit::Ref{BlasInt}, + w::Ptr{Float32}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function sstedc(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.sstedc_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.sstegr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.sstein_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function sstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.sstemr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + nzc::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + tryrac::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.ssteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssterf(n, d, e, info) + @ccall libblastrampoline.ssterf_(n::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + info::Ref{BlasInt})::Cvoid +end + +function sstev(jobz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.sstev_(jobz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function sstevd(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.sstevd_(jobz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function sstevr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.sstevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function sstevx(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, + ifail, info) + @ccall libblastrampoline.sstevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float32}, e::Ptr{Float32}, vl::Ref{Float32}, + vu::Ref{Float32}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float32}, m::Ref{BlasInt}, w::Ptr{Float32}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssycon(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.ssycon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssycon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.ssycon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info) + @ccall libblastrampoline.ssycon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float32}, + rcond::Ref{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssyconv(uplo, way, n, a, lda, ipiv, e, info) + @ccall libblastrampoline.ssyconv_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + e::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssyconvf(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.ssyconvf_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssyconvf_rook(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.ssyconvf_rook_(uplo::Ref{UInt8}, way::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function ssyequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.ssyequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, s::Ptr{Float32}, + scond::Ref{Float32}, + amax::Ref{Float32}, work::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssyev(jobz, uplo, n, a, lda, w, work, lwork, info) + @ccall libblastrampoline.ssyev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssyev_2stage(jobz, uplo, n, a, lda, w, work, lwork, info) + @ccall libblastrampoline.ssyev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssyevd(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssyevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssyevd_2stage(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssyevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssyevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssyevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssyevr_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + isuppz, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssyevr_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function ssyevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, + lwork, iwork, ifail, info) + @ccall libblastrampoline.ssyevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ssyevx_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + work, lwork, iwork, ifail, info) + @ccall libblastrampoline.ssyevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, + ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssygs2(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.ssygs2_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssygst(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.ssygst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssygv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + @ccall libblastrampoline.ssygv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssygv_2stage(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info) + @ccall libblastrampoline.ssygv_2stage_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssygvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ssygvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, w::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssygvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, + z, ldz, work, lwork, iwork, ifail, info) + @ccall libblastrampoline.ssygvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + vl::Ref{Float32}, vu::Ref{Float32}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float32}, + m::Ref{BlasInt}, + w::Ptr{Float32}, z::Ptr{Float32}, ldz::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ssyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.ssyrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, af::Ptr{Float32}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssyrfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + iwork, info) + @ccall libblastrampoline.ssyrfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float32}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.ssysv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.ssysv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssysv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.ssysv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + tb::Ptr{Float32}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.ssysv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.ssysv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, iwork, info) + @ccall libblastrampoline.ssysvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, rcond::Ref{Float32}, + ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ssysvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, iwork, info) + @ccall libblastrampoline.ssysvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + af::Ptr{Float32}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float32}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + rcond::Ref{Float32}, rpvgrw::Ref{Float32}, + berr::Ptr{Float32}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float32}, + err_bnds_comp::Ptr{Float32}, + nparams::Ref{BlasInt}, params::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssyswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.ssyswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytd2(uplo, n, a, lda, d, e, tau, info) + @ccall libblastrampoline.ssytd2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tau::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.ssytf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.ssytf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.ssytf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + @ccall libblastrampoline.ssytrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, d::Ptr{Float32}, e::Ptr{Float32}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytrd_2stage(vect, uplo, n, a, lda, d, e, tau, hous2, lhous2, work, lwork, info) + @ccall libblastrampoline.ssytrd_2stage_(vect::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + d::Ptr{Float32}, + e::Ptr{Float32}, tau::Ptr{Float32}, + hous2::Ptr{Float32}, lhous2::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ssytrd_sb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, + info) + @ccall libblastrampoline.ssytrd_sb2st_(stage1::Ref{UInt8}, vect::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{Float32}, + ldab::Ref{BlasInt}, d::Ptr{Float32}, + e::Ptr{Float32}, + hous::Ptr{Float32}, lhous::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ssytrd_sy2sb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) + @ccall libblastrampoline.ssytrd_sy2sb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ab::Ptr{Float32}, + ldab::Ref{BlasInt}, tau::Ptr{Float32}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.ssytrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, tb::Ptr{Float32}, + ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.ssytri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.ssytri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.ssytri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.ssytri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.ssytri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.ssytrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.ssytrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.ssytrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, e::Ptr{Float32}, + ipiv::Ptr{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ssytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.ssytrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.ssytrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + tb::Ptr{Float32}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ssytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.ssytrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function stbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info) + @ccall libblastrampoline.stbcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{Float32}, + ldab::Ref{BlasInt}, rcond::Ref{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function stbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, + iwork, info) + @ccall libblastrampoline.stbrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, x::Ptr{Float32}, ldx::Ref{BlasInt}, + ferr::Ptr{Float32}, berr::Ptr{Float32}, + work::Ptr{Float32}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function stbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.stbtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{Float32}, ldab::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function stfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + @ccall libblastrampoline.stfsm_(transr::Ref{UInt8}, side::Ref{UInt8}, uplo::Ref{UInt8}, + trans::Ref{UInt8}, diag::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, alpha::Ref{Float32}, a::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stftri(transr, uplo, diag, n, a, info) + @ccall libblastrampoline.stftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function stfttp(transr, uplo, n, arf, ap, info) + @ccall libblastrampoline.stfttp_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{Float32}, ap::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function stfttr(transr, uplo, n, arf, a, lda, info) + @ccall libblastrampoline.stfttr_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{Float32}, a::Ptr{Float32}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function stgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, + info) + @ccall libblastrampoline.stgevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, s::Ptr{Float32}, lds::Ref{BlasInt}, + p::Ptr{Float32}, ldp::Ref{BlasInt}, vl::Ptr{Float32}, + ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function stgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, + info) + @ccall libblastrampoline.stgex2_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, j1::Ref{BlasInt}, + n1::Ref{BlasInt}, n2::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function stgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, + info) + @ccall libblastrampoline.stgexc_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, ifst::Ref{BlasInt}, + ilst::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function stgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, beta, q, ldq, + z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.stgsen_(ijob::Ref{BlasInt}, wantq::Ref{BlasInt}, + wantz::Ref{BlasInt}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + alphar::Ptr{Float32}, alphai::Ptr{Float32}, + beta::Ptr{Float32}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + z::Ptr{Float32}, ldz::Ref{BlasInt}, m::Ref{BlasInt}, + pl::Ref{Float32}, pr::Ref{Float32}, dif::Ptr{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function stgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, + ldu, v, ldv, q, ldq, work, ncycle, info) + @ccall libblastrampoline.stgsja_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, tola::Ref{Float32}, + tolb::Ref{Float32}, alpha::Ptr{Float32}, + beta::Ptr{Float32}, + u::Ptr{Float32}, ldu::Ref{BlasInt}, v::Ptr{Float32}, + ldv::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + work::Ptr{Float32}, ncycle::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, + work, lwork, iwork, info) + @ccall libblastrampoline.stgsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, vl::Ptr{Float32}, + ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, + s::Ptr{Float32}, dif::Ptr{Float32}, mm::Ref{BlasInt}, + m::Ref{BlasInt}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function stgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + rdsum, rdscal, iwork, pq, info) + @ccall libblastrampoline.stgsy2_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, d::Ptr{Float32}, ldd::Ref{BlasInt}, + e::Ptr{Float32}, lde::Ref{BlasInt}, f::Ptr{Float32}, + ldf::Ref{BlasInt}, scale::Ref{Float32}, + rdsum::Ref{Float32}, + rdscal::Ref{Float32}, iwork::Ptr{BlasInt}, + pq::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function stgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + dif, work, lwork, iwork, info) + @ccall libblastrampoline.stgsyl_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, d::Ptr{Float32}, ldd::Ref{BlasInt}, + e::Ptr{Float32}, lde::Ref{BlasInt}, f::Ptr{Float32}, + ldf::Ref{BlasInt}, scale::Ref{Float32}, + dif::Ref{Float32}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function stpcon(norm, uplo, diag, n, ap, rcond, work, iwork, info) + @ccall libblastrampoline.stpcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{Float32}, rcond::Ref{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.stplqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function stplqt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.stplqt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function stpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.stpmlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function stpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.stpmqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + v::Ptr{Float32}, ldv::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function stpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.stpqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, b::Ptr{Float32}, + ldb::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt})::Cvoid +end + +function stpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.stpqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function stprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, + work, ldwork) + @ccall libblastrampoline.stprfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{Float32}, ldv::Ref{BlasInt}, + t::Ptr{Float32}, ldt::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + work::Ptr{Float32}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.stprfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, ap::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, x::Ptr{Float32}, + ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, + work::Ptr{Float32}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function stptri(uplo, diag, n, ap, info) + @ccall libblastrampoline.stptri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function stptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.stptrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, ap::Ptr{Float32}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function stpttf(transr, uplo, n, ap, arf, info) + @ccall libblastrampoline.stpttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{Float32}, arf::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function stpttr(uplo, n, ap, a, lda, info) + @ccall libblastrampoline.stpttr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{Float32}, + a::Ptr{Float32}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function strcon(norm, uplo, diag, n, a, lda, rcond, work, iwork, info) + @ccall libblastrampoline.strcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{Float32}, lda::Ref{BlasInt}, + rcond::Ref{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function strevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info) + @ccall libblastrampoline.strevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + vl::Ptr{Float32}, ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float32}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function strevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, + info) + @ccall libblastrampoline.strevc3_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + vl::Ptr{Float32}, ldvl::Ref{BlasInt}, + vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{Float32}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function strexc(compq, n, t, ldt, q, ldq, ifst, ilst, work, info) + @ccall libblastrampoline.strexc_(compq::Ref{UInt8}, n::Ref{BlasInt}, t::Ptr{Float32}, + ldt::Ref{BlasInt}, q::Ptr{Float32}, ldq::Ref{BlasInt}, + ifst::Ref{BlasInt}, ilst::Ref{BlasInt}, + work::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function strrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, + info) + @ccall libblastrampoline.strrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + x::Ptr{Float32}, ldx::Ref{BlasInt}, ferr::Ptr{Float32}, + berr::Ptr{Float32}, work::Ptr{Float32}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function strsen(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, + iwork, liwork, info) + @ccall libblastrampoline.strsen_(job::Ref{UInt8}, compq::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + q::Ptr{Float32}, ldq::Ref{BlasInt}, wr::Ptr{Float32}, + wi::Ptr{Float32}, m::Ref{BlasInt}, s::Ref{Float32}, + sep::Ref{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function strsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, + ldwork, iwork, info) + @ccall libblastrampoline.strsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{Float32}, ldt::Ref{BlasInt}, + vl::Ptr{Float32}, ldvl::Ref{BlasInt}, vr::Ptr{Float32}, + ldvr::Ref{BlasInt}, s::Ptr{Float32}, sep::Ptr{Float32}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, work::Ptr{Float32}, + ldwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function strsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + @ccall libblastrampoline.strsyl_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, scale::Ref{Float32}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function strsyl3(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, iwork, liwork, + swork, ldswork, info) + @ccall libblastrampoline.strsyl3_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + b::Ptr{Float32}, ldb::Ref{BlasInt}, c::Ptr{Float32}, + ldc::Ref{BlasInt}, scale::Ref{Float32}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, swork::Ptr{Float32}, + ldswork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function strti2(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.strti2_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function strtri(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.strtri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function strtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.strtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, b::Ptr{Float32}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function strttf(transr, uplo, n, a, lda, arf, info) + @ccall libblastrampoline.strttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{Float32}, lda::Ref{BlasInt}, arf::Ptr{Float32}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function strttp(uplo, n, a, lda, ap, info) + @ccall libblastrampoline.strttp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, ap::Ptr{Float32}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function stzrzf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.stzrzf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float32}, + lda::Ref{BlasInt}, + tau::Ptr{Float32}, work::Ptr{Float32}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zbbcsd(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, theta, phi, u1, ldu1, u2, + ldu2, v1t, ldv1t, v2t, ldv2t, b11d, b11e, b12d, b12e, b21d, b21e, b22d, + b22e, rwork, lrwork, info) + @ccall libblastrampoline.zbbcsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, theta::Ptr{Float64}, + phi::Ptr{Float64}, u1::Ptr{ComplexF64}, + ldu1::Ref{BlasInt}, + u2::Ptr{ComplexF64}, ldu2::Ref{BlasInt}, + v1t::Ptr{ComplexF64}, + ldv1t::Ref{BlasInt}, v2t::Ptr{ComplexF64}, + ldv2t::Ref{BlasInt}, + b11d::Ptr{Float64}, b11e::Ptr{Float64}, + b12d::Ptr{Float64}, + b12e::Ptr{Float64}, b21d::Ptr{Float64}, + b21e::Ptr{Float64}, + b22d::Ptr{Float64}, b22e::Ptr{Float64}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zbdsqr(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info) + @ccall libblastrampoline.zbdsqr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ncvt::Ref{BlasInt}, + nru::Ref{BlasInt}, ncc::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, vt::Ptr{ComplexF64}, + ldvt::Ref{BlasInt}, + u::Ptr{ComplexF64}, ldu::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zcgesv(n, nrhs, a, lda, ipiv, b, ldb, x, ldx, work, swork, rwork, iter, info) + @ccall libblastrampoline.zcgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + work::Ptr{ComplexF64}, swork::Ptr{ComplexF32}, + rwork::Ptr{Float64}, iter::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zcposv(uplo, n, nrhs, a, lda, b, ldb, x, ldx, work, swork, rwork, iter, info) + @ccall libblastrampoline.zcposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + work::Ptr{ComplexF64}, swork::Ptr{ComplexF32}, + rwork::Ptr{Float64}, iter::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zdrscl(n, sa, sx, incx) + @ccall libblastrampoline.zdrscl_(n::Ref{BlasInt}, sa::Ref{Float64}, sx::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Cvoid +end + +function zgbbrd(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, + rwork, info) + @ccall libblastrampoline.zgbbrd_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + ncc::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + pt::Ptr{ComplexF64}, + ldpt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgbcon(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.zgbcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgbequ(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.zgbequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgbequb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.zgbequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgbrfs(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, + berr, work, rwork, info) + @ccall libblastrampoline.zgbrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgbrfsx(trans, equed, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, r, c, b, ldb, x, + ldx, rcond, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.zgbrfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + r::Ptr{Float64}, + c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zgbsv(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.zgbsv_(n::Ref{BlasInt}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgbsvx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zgbsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgbsvxx(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, + ldb, x, ldx, rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, + nparams, params, work, rwork, info) + @ccall libblastrampoline.zgbsvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgbtf2(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.zgbtf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgbtrf(m, n, kl, ku, ab, ldab, ipiv, info) + @ccall libblastrampoline.zgbtrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgbtrs(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info) + @ccall libblastrampoline.zgbtrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zgebak(job, side, n, ilo, ihi, scale, m, v, ldv, info) + @ccall libblastrampoline.zgebak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float64}, + m::Ref{BlasInt}, v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zgebal(job, n, a, lda, ilo, ihi, scale, info) + @ccall libblastrampoline.zgebal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + scale::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgebd2(m, n, a, lda, d, e, tauq, taup, work, info) + @ccall libblastrampoline.zgebd2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tauq::Ptr{ComplexF64}, taup::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt})::Cvoid +end + +function zgebrd(m, n, a, lda, d, e, tauq, taup, work, lwork, info) + @ccall libblastrampoline.zgebrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tauq::Ptr{ComplexF64}, taup::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgecon(norm, n, a, lda, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.zgecon_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgeequ(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.zgeequ_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, r::Ptr{Float64}, c::Ptr{Float64}, + rowcnd::Ref{Float64}, colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgeequb(m, n, a, lda, r, c, rowcnd, colcnd, amax, info) + @ccall libblastrampoline.zgeequb_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, r::Ptr{Float64}, c::Ptr{Float64}, + rowcnd::Ref{Float64}, colcnd::Ref{Float64}, + amax::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgees(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, + info) + @ccall libblastrampoline.zgees_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + sdim::Ref{BlasInt}, w::Ptr{ComplexF64}, + vs::Ptr{ComplexF64}, + ldvs::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zgeesx(jobvs, sort, select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, + work, lwork, rwork, bwork, info) + @ccall libblastrampoline.zgeesx_(jobvs::Ref{UInt8}, sort::Ref{UInt8}, + select::Ref{BlasInt}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, sdim::Ref{BlasInt}, + w::Ptr{ComplexF64}, + vs::Ptr{ComplexF64}, ldvs::Ref{BlasInt}, + rconde::Ref{Float64}, + rcondv::Ref{Float64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zgeev(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info) + @ccall libblastrampoline.zgeev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + w::Ptr{ComplexF64}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgeevx(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, + scale, abnrm, rconde, rcondv, work, lwork, rwork, info) + @ccall libblastrampoline.zgeevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, w::Ptr{ComplexF64}, + vl::Ptr{ComplexF64}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + scale::Ptr{Float64}, + abnrm::Ref{Float64}, rconde::Ptr{Float64}, + rcondv::Ptr{Float64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgehd2(n, ilo, ihi, a, lda, tau, work, info) + @ccall libblastrampoline.zgehd2_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt})::Cvoid +end + +function zgehrd(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgehrd_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgejsv(joba, jobu, jobv, jobr, jobt, jobp, m, n, a, lda, sva, u, ldu, v, ldv, + cwork, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.zgejsv_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + jobr::Ptr{UInt8}, jobt::Ptr{UInt8}, jobp::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, sva::Ptr{Float64}, + u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, + cwork::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgelq(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.zgelq_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + tsize::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgelq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.zgelq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgelqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgelqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgelqt(m, n, mb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.zgelqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgelqt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.zgelqt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgels(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.zgels_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgelsd(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.zgelsd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, s::Ptr{Float64}, + rcond::Ref{Float64}, + rank::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgelss(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info) + @ccall libblastrampoline.zgelss_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, s::Ptr{Float64}, + rcond::Ref{Float64}, + rank::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgelst(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.zgelst_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgelsy(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info) + @ccall libblastrampoline.zgelsy_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + rcond::Ref{Float64}, + rank::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zgemlq(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.zgemlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + tsize::Ref{BlasInt}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgemlqt(side, trans, m, n, k, mb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.zgemlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgemqr(side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info) + @ccall libblastrampoline.zgemqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + tsize::Ref{BlasInt}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgemqrt(side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info) + @ccall libblastrampoline.zgemqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgeql2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.zgeql2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqlf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgeqlf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgeqp3(m, n, a, lda, jpvt, tau, work, lwork, rwork, info) + @ccall libblastrampoline.zgeqp3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, jpvt::Ptr{BlasInt}, + tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqp3rk(m, n, nrhs, kmax, abstol, reltol, a, lda, k, maxc2nrmk, relmaxc2nrmk, + jpiv, tau, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.zgeqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + kmax::Ref{BlasInt}, abstol::Ref{Float64}, + reltol::Ref{Float64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqr(m, n, a, lda, t, tsize, work, lwork, info) + @ccall libblastrampoline.zgeqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + tsize::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqr2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.zgeqr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqr2p(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.zgeqr2p_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqrf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgeqrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgeqrfp(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgeqrfp_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgeqrt(m, n, nb, a, lda, t, ldt, work, info) + @ccall libblastrampoline.zgeqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqrt2(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.zgeqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgeqrt3(m, n, a, lda, t, ldt, info) + @ccall libblastrampoline.zgeqrt3_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgerfs(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zgerfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgerfsx(trans, equed, n, nrhs, a, lda, af, ldaf, ipiv, r, c, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.zgerfsx_(trans::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + r::Ptr{Float64}, c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgerq2(m, n, a, lda, tau, work, info) + @ccall libblastrampoline.zgerq2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zgerqf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zgerqf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgesc2(n, a, lda, rhs, ipiv, jpiv, scale) + @ccall libblastrampoline.zgesc2_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + rhs::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt}, + scale::Ref{Float64})::Cvoid +end + +function zgesdd(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.zgesdd_(jobz::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, s::Ptr{Float64}, + u::Ptr{ComplexF64}, ldu::Ref{BlasInt}, + vt::Ptr{ComplexF64}, + ldvt::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgesv(n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zgesv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgesvd(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info) + @ccall libblastrampoline.zgesvd_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, u::Ptr{ComplexF64}, ldu::Ref{BlasInt}, + vt::Ptr{ComplexF64}, ldvt::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zgesvdq(joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, + iwork, liwork, cwork, lcwork, rwork, lrwork, info) + @ccall libblastrampoline.zgesvdq_(joba::Ref{UInt8}, jobp::Ref{UInt8}, jobr::Ref{UInt8}, + jobu::Ref{UInt8}, jobv::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + s::Ptr{Float64}, u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + numrank::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + cwork::Ptr{ComplexF64}, + lcwork::Ref{BlasInt}, rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zgesvdx(jobu, jobvt, range, m, n, a, lda, vl, vu, il, iu, ns, s, u, ldu, vt, ldvt, + work, lwork, rwork, iwork, info) + @ccall libblastrampoline.zgesvdx_(jobu::Ref{UInt8}, jobvt::Ref{UInt8}, + range::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, ns::Ref{BlasInt}, + s::Ptr{Float64}, u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, + vt::Ptr{ComplexF64}, ldvt::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zgesvj(joba, jobu, jobv, m, n, a, lda, sva, mv, v, ldv, cwork, lwork, rwork, + lrwork, info) + @ccall libblastrampoline.zgesvj_(joba::Ptr{UInt8}, jobu::Ptr{UInt8}, jobv::Ptr{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, sva::Ptr{Float64}, mv::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + cwork::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zgesvx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zgesvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float64}, c::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zgesvxx(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.zgesvxx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, r::Ptr{Float64}, c::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgetc2(n, a, lda, ipiv, jpiv, info) + @ccall libblastrampoline.zgetc2_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, jpiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgetf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.zgetf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgetrf(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.zgetrf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgetrf2(m, n, a, lda, ipiv, info) + @ccall libblastrampoline.zgetrf2_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgetri(n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zgetri_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgetrs(trans, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zgetrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgetsls(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info) + @ccall libblastrampoline.zgetsls_(trans::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgetsqrhrt(m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.zgetsqrhrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb1::Ref{BlasInt}, + nb1::Ref{BlasInt}, nb2::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zggbak(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info) + @ccall libblastrampoline.zggbak_(job::Ref{UInt8}, side::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float64}, + rscale::Ptr{Float64}, m::Ref{BlasInt}, + v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zggbal(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info) + @ccall libblastrampoline.zggbal_(job::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + lscale::Ptr{Float64}, + rscale::Ptr{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgges(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, + ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + @ccall libblastrampoline.zgges_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, vsl::Ptr{ComplexF64}, + ldvsl::Ref{BlasInt}, + vsr::Ptr{ComplexF64}, ldvsr::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgges3(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alpha, beta, vsl, + ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info) + @ccall libblastrampoline.zgges3_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + sdim::Ref{BlasInt}, alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, vsl::Ptr{ComplexF64}, + ldvsl::Ref{BlasInt}, vsr::Ptr{ComplexF64}, + ldvsr::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + bwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zggesx(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alpha, beta, + vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, + bwork, info) + @ccall libblastrampoline.zggesx_(jobvsl::Ref{UInt8}, jobvsr::Ref{UInt8}, + sort::Ref{UInt8}, + selctg::Ref{BlasInt}, sense::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, sdim::Ref{BlasInt}, + alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, vsl::Ptr{ComplexF64}, + ldvsl::Ref{BlasInt}, vsr::Ptr{ComplexF64}, + ldvsr::Ref{BlasInt}, + rconde::Ptr{Float64}, rcondv::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zggev(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, + lwork, rwork, info) + @ccall libblastrampoline.zggev_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zggev3(jobvl, jobvr, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, ldvr, work, + lwork, rwork, info) + @ccall libblastrampoline.zggev3_(jobvl::Ref{UInt8}, jobvr::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, vl::Ptr{ComplexF64}, + ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, ldvr::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zggevx(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alpha, beta, vl, ldvl, vr, + ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, + rwork, iwork, bwork, info) + @ccall libblastrampoline.zggevx_(balanc::Ref{UInt8}, jobvl::Ref{UInt8}, + jobvr::Ref{UInt8}, + sense::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + alpha::Ptr{ComplexF64}, beta::Ptr{ComplexF64}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, ilo::Ref{BlasInt}, + ihi::Ref{BlasInt}, + lscale::Ptr{Float64}, rscale::Ptr{Float64}, + abnrm::Ref{Float64}, bbnrm::Ref{Float64}, + rconde::Ptr{Float64}, rcondv::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, bwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zggglm(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info) + @ccall libblastrampoline.zggglm_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + d::Ptr{ComplexF64}, x::Ptr{ComplexF64}, + y::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgghd3(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, work, lwork, + info) + @ccall libblastrampoline.zgghd3_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zgghrd(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info) + @ccall libblastrampoline.zgghrd_(compq::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zgglse(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info) + @ccall libblastrampoline.zgglse_(m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, d::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zggqrf(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.zggqrf_(n::Ref{BlasInt}, m::Ref{BlasInt}, p::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, taua::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, taub::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zggrqf(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info) + @ccall libblastrampoline.zggrqf_(m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, taua::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, taub::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zggsvd3(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alpha, beta, u, ldu, v, + ldv, q, ldq, work, lwork, rwork, iwork, info) + @ccall libblastrampoline.zggsvd3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, p::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + alpha::Ptr{Float64}, + beta::Ptr{Float64}, u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zggsvp3(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, + ldv, q, ldq, iwork, rwork, tau, work, lwork, info) + @ccall libblastrampoline.zggsvp3_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, tola::Ref{Float64}, + tolb::Ref{Float64}, + k::Ref{BlasInt}, l::Ref{BlasInt}, u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + rwork::Ptr{Float64}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zgsvj0(jobv, m, n, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.zgsvj0_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + d::Ptr{ComplexF64}, + sva::Ptr{Float64}, mv::Ref{BlasInt}, + v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, eps::Ref{Float64}, + sfmin::Ref{Float64}, + tol::Ref{Float64}, nsweep::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgsvj1(jobv, m, n, n1, a, lda, d, sva, mv, v, ldv, eps, sfmin, tol, nsweep, work, + lwork, info) + @ccall libblastrampoline.zgsvj1_(jobv::Ptr{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + n1::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + d::Ptr{ComplexF64}, + sva::Ptr{Float64}, mv::Ref{BlasInt}, + v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, eps::Ref{Float64}, + sfmin::Ref{Float64}, + tol::Ref{Float64}, nsweep::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgtcon(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zgtcon_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, du::Ptr{ComplexF64}, + du2::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgtrfs(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, + berr, work, rwork, info) + @ccall libblastrampoline.zgtrfs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF64}, d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, + dlf::Ptr{ComplexF64}, df::Ptr{ComplexF64}, + duf::Ptr{ComplexF64}, du2::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zgtsv(n, nrhs, dl, d, du, b, ldb, info) + @ccall libblastrampoline.zgtsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, du::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zgtsvx(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zgtsvx_(fact::Ref{UInt8}, trans::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, dlf::Ptr{ComplexF64}, + df::Ptr{ComplexF64}, duf::Ptr{ComplexF64}, + du2::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zgttrf(n, dl, d, du, du2, ipiv, info) + @ccall libblastrampoline.zgttrf_(n::Ref{BlasInt}, dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, du2::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zgttrs(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info) + @ccall libblastrampoline.zgttrs_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF64}, d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, + du2::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zgtts2(itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb) + @ccall libblastrampoline.zgtts2_(itrans::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + dl::Ptr{ComplexF64}, d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, + du2::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt})::Cvoid +end + +function zhb2st_kernels(uplo, wantz, ttype, st, ed, sweep, n, nb, ib, a, lda, v, tau, ldvt, + work) + @ccall libblastrampoline.zhb2st_kernels_(uplo::Ref{UInt8}, wantz::Ref{BlasInt}, + ttype::Ref{BlasInt}, + st::Ref{BlasInt}, ed::Ref{BlasInt}, + sweep::Ref{BlasInt}, + n::Ref{BlasInt}, nb::Ref{BlasInt}, + ib::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + v::Ptr{ComplexF64}, tau::Ptr{ComplexF64}, + ldvt::Ref{BlasInt}, work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zhbev(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.zhbev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhbev_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, info) + @ccall libblastrampoline.zhbev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function zhbevd(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.zhbevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhbevd_2stage(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, + iwork, liwork, info) + @ccall libblastrampoline.zhbevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhbevx(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, + ldz, work, rwork, iwork, ifail, info) + @ccall libblastrampoline.zhbevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zhbevx_2stage(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, + m, w, z, ldz, work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.zhbevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zhbgst(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info) + @ccall libblastrampoline.zhbgst_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF64}, + ldbb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zhbgv(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.zhbgv_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF64}, + ldbb::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhbgvd(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, + lrwork, iwork, liwork, info) + @ccall libblastrampoline.zhbgvd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, bb::Ptr{ComplexF64}, + ldbb::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhbgvx(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, + abstol, m, w, z, ldz, work, rwork, iwork, ifail, info) + @ccall libblastrampoline.zhbgvx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ka::Ref{BlasInt}, kb::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + bb::Ptr{ComplexF64}, + ldbb::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zhbtrd(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info) + @ccall libblastrampoline.zhbtrd_(vect::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhecon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zhecon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhecon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zhecon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhecon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zhecon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zheequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.zheequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zheev(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + @ccall libblastrampoline.zheev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zheev_2stage(jobz, uplo, n, a, lda, w, work, lwork, rwork, info) + @ccall libblastrampoline.zheev_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function zheevd(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.zheevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zheevd_2stage(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, + info) + @ccall libblastrampoline.zheevd_2stage_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, liwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, + work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.zheevr_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zheevr_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + isuppz, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.zheevr_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zheevx(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, + lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.zheevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zheevx_2stage(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, + work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.zheevx_2stage_(jobz::Ref{UInt8}, range::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, + il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zhegs2(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.zhegs2_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhegst(itype, uplo, n, a, lda, b, ldb, info) + @ccall libblastrampoline.zhegst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhegv(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + @ccall libblastrampoline.zhegv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhegv_2stage(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info) + @ccall libblastrampoline.zhegv_2stage_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong, + 1::Clong)::Cvoid +end + +function zhegvd(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.zhegvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, w::Ptr{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhegvx(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, + z, ldz, work, lwork, rwork, iwork, ifail, info) + @ccall libblastrampoline.zhegvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + vl::Ref{Float64}, vu::Ref{Float64}, il::Ref{BlasInt}, + iu::Ref{BlasInt}, abstol::Ref{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zherfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zherfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zherfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.zherfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhesv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zhesv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhesv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zhesv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhesv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.zhesv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF64}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhesv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zhesv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhesv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zhesv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhesvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, rwork, info) + @ccall libblastrampoline.zhesvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zhesvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.zhesvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zheswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.zheswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetd2(uplo, n, a, lda, d, e, tau, info) + @ccall libblastrampoline.zhetd2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tau::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.zhetf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.zhetf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.zhetf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrd(uplo, n, a, lda, d, e, tau, work, lwork, info) + @ccall libblastrampoline.zhetrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + tau::Ptr{ComplexF64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrd_2stage(vect, uplo, n, a, lda, d, e, tau, hous2, lhous2, work, lwork, info) + @ccall libblastrampoline.zhetrd_2stage_(vect::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + d::Ptr{Float64}, + e::Ptr{Float64}, tau::Ptr{ComplexF64}, + hous2::Ptr{ComplexF64}, lhous2::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhetrd_hb2st(stage1, vect, uplo, n, kd, ab, ldab, d, e, hous, lhous, work, lwork, + info) + @ccall libblastrampoline.zhetrd_hb2st_(stage1::Ref{UInt8}, vect::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, + hous::Ptr{ComplexF64}, lhous::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zhetrd_he2hb(uplo, n, kd, a, lda, ab, ldab, tau, work, lwork, info) + @ccall libblastrampoline.zhetrd_he2hb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + tau::Ptr{ComplexF64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.zhetrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tb::Ptr{ComplexF64}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.zhetri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.zhetri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.zhetri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.zhetri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.zhetri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zhetrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.zhetrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.zhetrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zhetrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhetrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.zhetrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF64}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhetrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zhetrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhfrk(transr, uplo, trans, n, k, alpha, a, lda, beta, c) + @ccall libblastrampoline.zhfrk_(transr::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, alpha::Ref{Float64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + beta::Ref{Float64}, + c::Ptr{ComplexF64}, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zhgeqz(job, compq, compz, n, ilo, ihi, h, ldh, t, ldt, alpha, beta, q, ldq, z, ldz, + work, lwork, rwork, info) + @ccall libblastrampoline.zhgeqz_(job::Ref{UInt8}, compq::Ref{UInt8}, compz::Ref{UInt8}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF64}, ldh::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, alpha::Ptr{ComplexF64}, + beta::Ptr{ComplexF64}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zhpcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zhpcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhpev(jobz, uplo, n, ap, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.zhpev_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, w::Ptr{Float64}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhpevd(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, + info) + @ccall libblastrampoline.zhpevd_(jobz::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, w::Ptr{Float64}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zhpevx(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, + iwork, ifail, info) + @ccall libblastrampoline.zhpevx_(jobz::Ref{UInt8}, range::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zhpgst(itype, uplo, n, ap, bp, info) + @ccall libblastrampoline.zhpgst_(itype::Ref{BlasInt}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, bp::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhpgv(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info) + @ccall libblastrampoline.zhpgv_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + bp::Ptr{ComplexF64}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhpgvd(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, + liwork, info) + @ccall libblastrampoline.zhpgvd_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + uplo::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + bp::Ptr{ComplexF64}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zhpgvx(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, + work, rwork, iwork, ifail, info) + @ccall libblastrampoline.zhpgvx_(itype::Ref{BlasInt}, jobz::Ref{UInt8}, + range::Ref{UInt8}, + uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + bp::Ptr{ComplexF64}, vl::Ref{Float64}, + vu::Ref{Float64}, + il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, + m::Ref{BlasInt}, w::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zhprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zhprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, afp::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhpsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.zhpsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhpsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zhpsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF64}, + afp::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zhptrd(uplo, n, ap, d, e, tau, info) + @ccall libblastrampoline.zhptrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + d::Ptr{Float64}, e::Ptr{Float64}, tau::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.zhptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.zhptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zhptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.zhptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zhsein(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, + rwork, ifaill, ifailr, info) + @ccall libblastrampoline.zhsein_(side::Ref{UInt8}, eigsrc::Ref{UInt8}, + initv::Ref{UInt8}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF64}, + vl::Ptr{ComplexF64}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, ifaill::Ptr{BlasInt}, + ifailr::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zhseqr(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info) + @ccall libblastrampoline.zhseqr_(job::Ref{UInt8}, compz::Ref{UInt8}, n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF64}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zla_gbamv(trans, m, n, kl, ku, alpha, ab, ldab, x, incx, beta, y, incy) + @ccall libblastrampoline.zla_gbamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + kl::Ref{BlasInt}, ku::Ref{BlasInt}, + alpha::Ref{Float64}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function zla_gbrcond_c(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, + rwork) + @ccall libblastrampoline.zla_gbrcond_c_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float64}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_gbrcond_x(trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, x, info, work, rwork) + @ccall libblastrampoline.zla_gbrcond_x_(trans::Ref{UInt8}, n::Ref{BlasInt}, + kl::Ref{BlasInt}, + ku::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, ldafb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF64}, + info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_gbrfsx_extended(prec_type, trans_type, n, kl, ku, nrhs, ab, ldab, afb, ldafb, + ipiv, colequ, c, b, ldb, y, ldy, berr_out, n_norms, + err_bnds_norm, err_bnds_comp, res, ayb, dy, y_tail, rcond, + ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.zla_gbrfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + y::Ptr{ComplexF64}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{ComplexF64}, ayb::Ptr{Float64}, + dy::Ptr{ComplexF64}, + y_tail::Ptr{ComplexF64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zla_gbrpvgrw(n, kl, ku, ncols, ab, ldab, afb, ldafb) + @ccall libblastrampoline.zla_gbrpvgrw_(n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ncols::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt})::Float64 +end + +function zla_geamv(trans, m, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zla_geamv_(trans::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + alpha::Ref{Float64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + beta::Ref{Float64}, + y::Ptr{Float64}, incy::Ref{BlasInt})::Cvoid +end + +function zla_gercond_c(trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.zla_gercond_c_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float64}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_gercond_x(trans, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.zla_gercond_x_(trans::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF64}, + info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_gerfsx_extended(prec_type, trans_type, n, nrhs, a, lda, af, ldaf, ipiv, colequ, + c, b, ldb, y, ldy, berr_out, n_norms, errs_n, errs_c, res, ayb, + dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, info) + @ccall libblastrampoline.zla_gerfsx_extended_(prec_type::Ref{BlasInt}, + trans_type::Ref{BlasInt}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF64}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + errs_n::Ptr{Float64}, + errs_c::Ptr{Float64}, + res::Ptr{ComplexF64}, + ayb::Ptr{Float64}, dy::Ptr{ComplexF64}, + y_tail::Ptr{ComplexF64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zla_gerpvgrw(n, ncols, a, lda, af, ldaf) + @ccall libblastrampoline.zla_gerpvgrw_(n::Ref{BlasInt}, ncols::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt})::Float64 +end + +function zla_heamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zla_heamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function zla_hercond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.zla_hercond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float64}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_hercond_x(uplo, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.zla_hercond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF64}, + info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_herfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.zla_herfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF64}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{ComplexF64}, ayb::Ptr{Float64}, + dy::Ptr{ComplexF64}, + y_tail::Ptr{ComplexF64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zla_herpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.zla_herpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_lin_berr(n, nz, nrhs, res, ayb, berr) + @ccall libblastrampoline.zla_lin_berr_(n::Ref{BlasInt}, nz::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + res::Ptr{ComplexF64}, ayb::Ptr{Float64}, + berr::Ptr{Float64})::Cvoid +end + +function zla_porcond_c(uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork) + @ccall libblastrampoline.zla_porcond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + c::Ptr{Float64}, capply::Ref{BlasInt}, + info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_porcond_x(uplo, n, a, lda, af, ldaf, x, info, work, rwork) + @ccall libblastrampoline.zla_porcond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + x::Ptr{ComplexF64}, info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_porfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, colequ, c, b, ldb, + y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, res, + ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, ignore_cwise, + info) + @ccall libblastrampoline.zla_porfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + colequ::Ref{BlasInt}, c::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + y::Ptr{ComplexF64}, ldy::Ref{BlasInt}, + berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{ComplexF64}, ayb::Ptr{Float64}, + dy::Ptr{ComplexF64}, + y_tail::Ptr{ComplexF64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zla_porpvgrw(uplo, ncols, a, lda, af, ldaf, work) + @ccall libblastrampoline.zla_porpvgrw_(uplo::Ptr{UInt8}, ncols::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_syamv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zla_syamv_(uplo::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{Float64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, beta::Ref{Float64}, + y::Ptr{Float64}, + incy::Ref{BlasInt})::Cvoid +end + +function zla_syrcond_c(uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) + @ccall libblastrampoline.zla_syrcond_c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, c::Ptr{Float64}, + capply::Ref{BlasInt}, + info::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_syrcond_x(uplo, n, a, lda, af, ldaf, ipiv, x, info, work, rwork) + @ccall libblastrampoline.zla_syrcond_x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, x::Ptr{ComplexF64}, + info::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zla_syrfsx_extended(prec_type, uplo, n, nrhs, a, lda, af, ldaf, ipiv, colequ, c, b, + ldb, y, ldy, berr_out, n_norms, err_bnds_norm, err_bnds_comp, + res, ayb, dy, y_tail, rcond, ithresh, rthresh, dz_ub, + ignore_cwise, info) + @ccall libblastrampoline.zla_syrfsx_extended_(prec_type::Ref{BlasInt}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, colequ::Ref{BlasInt}, + c::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, y::Ptr{ComplexF64}, + ldy::Ref{BlasInt}, berr_out::Ptr{Float64}, + n_norms::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + res::Ptr{ComplexF64}, ayb::Ptr{Float64}, + dy::Ptr{ComplexF64}, + y_tail::Ptr{ComplexF64}, + rcond::Ref{Float64}, + ithresh::Ref{BlasInt}, + rthresh::Ref{Float64}, + dz_ub::Ref{Float64}, + ignore_cwise::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zla_syrpvgrw(uplo, n, info, a, lda, af, ldaf, ipiv, work) + @ccall libblastrampoline.zla_syrpvgrw_(uplo::Ptr{UInt8}, n::Ref{BlasInt}, + info::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + work::Ptr{Float64}, 1::Clong)::Float64 +end + +function zla_wwaddw(n, x, y, w) + @ccall libblastrampoline.zla_wwaddw_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + y::Ptr{ComplexF64}, + w::Ptr{ComplexF64})::Cvoid +end + +function zlabrd(m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy) + @ccall libblastrampoline.zlabrd_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, tauq::Ptr{ComplexF64}, + taup::Ptr{ComplexF64}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + y::Ptr{ComplexF64}, ldy::Ref{BlasInt})::Cvoid +end + +function zlacgv(n, x, incx) + @ccall libblastrampoline.zlacgv_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Cvoid +end + +function zlacn2(n, v, x, est, kase, isave) + @ccall libblastrampoline.zlacn2_(n::Ref{BlasInt}, v::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, + est::Ref{Float64}, kase::Ref{BlasInt}, + isave::Ptr{BlasInt})::Cvoid +end + +function zlacon(n, v, x, est, kase) + @ccall libblastrampoline.zlacon_(n::Ref{BlasInt}, v::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, + est::Ref{Float64}, kase::Ref{BlasInt})::Cvoid +end + +function zlacp2(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.zlacp2_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{Float64}, lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlacpy(uplo, m, n, a, lda, b, ldb) + @ccall libblastrampoline.zlacpy_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlacrm(m, n, a, lda, b, ldb, c, ldc, rwork) + @ccall libblastrampoline.zlacrm_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{Float64}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + rwork::Ptr{Float64})::Cvoid +end + +function zlacrt(n, cx, incx, cy, incy, c, s) + @ccall libblastrampoline.zlacrt_(n::Ref{BlasInt}, cx::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + cy::Ptr{ComplexF64}, incy::Ref{BlasInt}, + c::Ref{ComplexF64}, + s::Ref{ComplexF64})::Cvoid +end + +function zladiv(x, y) + @ccall libblastrampoline.zladiv_(x::Ref{ComplexF64}, y::Ref{ComplexF64})::ComplexF64 +end + +function zlaed0(qsiz, n, d, e, q, ldq, qstore, ldqs, rwork, iwork, info) + @ccall libblastrampoline.zlaed0_(qsiz::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + qstore::Ptr{ComplexF64}, ldqs::Ref{BlasInt}, + rwork::Ptr{Float64}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaed7(n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho, indxq, qstore, qptr, + prmptr, perm, givptr, givcol, givnum, work, rwork, iwork, info) + @ccall libblastrampoline.zlaed7_(n::Ref{BlasInt}, cutpnt::Ref{BlasInt}, + qsiz::Ref{BlasInt}, + tlvls::Ref{BlasInt}, curlvl::Ref{BlasInt}, + curpbm::Ref{BlasInt}, + d::Ptr{Float64}, q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + rho::Ref{Float64}, indxq::Ptr{BlasInt}, + qstore::Ptr{Float64}, + qptr::Ptr{BlasInt}, prmptr::Ptr{BlasInt}, + perm::Ptr{BlasInt}, + givptr::Ptr{BlasInt}, givcol::Ptr{BlasInt}, + givnum::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaed8(k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlambda, q2, ldq2, w, indxp, indx, + indxq, perm, givptr, givcol, givnum, info) + @ccall libblastrampoline.zlaed8_(k::Ref{BlasInt}, n::Ref{BlasInt}, qsiz::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, d::Ptr{Float64}, + rho::Ref{Float64}, cutpnt::Ref{BlasInt}, + z::Ptr{Float64}, + dlambda::Ptr{Float64}, q2::Ptr{ComplexF64}, + ldq2::Ref{BlasInt}, + w::Ptr{Float64}, indxp::Ptr{BlasInt}, + indx::Ptr{BlasInt}, + indxq::Ptr{BlasInt}, perm::Ptr{BlasInt}, + givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, givnum::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function zlaein(rightv, noinit, n, h, ldh, w, v, b, ldb, rwork, eps3, smlnum, info) + @ccall libblastrampoline.zlaein_(rightv::Ref{BlasInt}, noinit::Ref{BlasInt}, + n::Ref{BlasInt}, + h::Ptr{ComplexF64}, ldh::Ref{BlasInt}, + w::Ref{ComplexF64}, + v::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + rwork::Ptr{Float64}, eps3::Ref{Float64}, + smlnum::Ref{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zlaesy(a, b, c, rt1, rt2, evscal, cs1, sn1) + @ccall libblastrampoline.zlaesy_(a::Ref{ComplexF64}, b::Ref{ComplexF64}, + c::Ref{ComplexF64}, + rt1::Ref{ComplexF64}, rt2::Ref{ComplexF64}, + evscal::Ref{ComplexF64}, cs1::Ref{ComplexF64}, + sn1::Ref{ComplexF64})::Cvoid +end + +function zlaev2(a, b, c, rt1, rt2, cs1, sn1) + @ccall libblastrampoline.zlaev2_(a::Ref{ComplexF64}, b::Ref{ComplexF64}, + c::Ref{ComplexF64}, + rt1::Ref{Float64}, rt2::Ref{Float64}, + cs1::Ref{Float64}, + sn1::Ref{ComplexF64})::Cvoid +end + +function zlag2c(m, n, a, lda, sa, ldsa, info) + @ccall libblastrampoline.zlag2c_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, sa::Ptr{ComplexF32}, + ldsa::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlags2(upper, a1, a2, a3, b1, b2, b3, csu, snu, csv, snv, csq, snq) + @ccall libblastrampoline.zlags2_(upper::Ref{BlasInt}, a1::Ref{Float64}, + a2::Ref{ComplexF64}, + a3::Ref{Float64}, b1::Ref{Float64}, + b2::Ref{ComplexF64}, + b3::Ref{Float64}, csu::Ref{Float64}, + snu::Ref{ComplexF64}, + csv::Ref{Float64}, snv::Ref{ComplexF64}, + csq::Ref{Float64}, + snq::Ref{ComplexF64})::Cvoid +end + +function zlagtm(trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb) + @ccall libblastrampoline.zlagtm_(trans::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + alpha::Ref{Float64}, dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, + du::Ptr{ComplexF64}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + beta::Ref{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlahef(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.zlahef_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF64}, ldw::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlahef_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.zlahef_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, + work::Ptr{ComplexF64}, 1::Clong)::Cvoid +end + +function zlahef_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.zlahef_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF64}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlahef_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.zlahef_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{ComplexF64}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlahqr(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, info) + @ccall libblastrampoline.zlahqr_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF64}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlahr2(n, k, nb, a, lda, tau, t, ldt, y, ldy) + @ccall libblastrampoline.zlahr2_(n::Ref{BlasInt}, k::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + y::Ptr{ComplexF64}, + ldy::Ref{BlasInt})::Cvoid +end + +function zlaic1(job, j, x, sest, w, gamma, sestpr, s, c) + @ccall libblastrampoline.zlaic1_(job::Ref{BlasInt}, j::Ref{BlasInt}, x::Ptr{ComplexF64}, + sest::Ref{Float64}, w::Ptr{ComplexF64}, + gamma::Ref{ComplexF64}, sestpr::Ref{Float64}, + s::Ref{ComplexF64}, c::Ref{ComplexF64})::Cvoid +end + +function zlals0(icompq, nl, nr, sqre, nrhs, b, ldb, bx, ldbx, perm, givptr, givcol, ldgcol, + givnum, ldgnum, poles, difl, difr, z, k, c, s, rwork, info) + @ccall libblastrampoline.zlals0_(icompq::Ref{BlasInt}, nl::Ref{BlasInt}, + nr::Ref{BlasInt}, + sqre::Ref{BlasInt}, nrhs::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, bx::Ptr{ComplexF64}, + ldbx::Ref{BlasInt}, + perm::Ptr{BlasInt}, givptr::Ref{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, givnum::Ptr{Float64}, + ldgnum::Ref{BlasInt}, + poles::Ptr{Float64}, difl::Ptr{Float64}, + difr::Ptr{Float64}, + z::Ptr{Float64}, k::Ref{BlasInt}, c::Ref{Float64}, + s::Ref{Float64}, rwork::Ptr{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function zlalsa(icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx, u, ldu, vt, k, difl, difr, z, + poles, givptr, givcol, ldgcol, perm, givnum, c, s, rwork, iwork, info) + @ccall libblastrampoline.zlalsa_(icompq::Ref{BlasInt}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + bx::Ptr{ComplexF64}, ldbx::Ref{BlasInt}, + u::Ptr{Float64}, + ldu::Ref{BlasInt}, vt::Ptr{Float64}, k::Ptr{BlasInt}, + difl::Ptr{Float64}, difr::Ptr{Float64}, + z::Ptr{Float64}, + poles::Ptr{Float64}, givptr::Ptr{BlasInt}, + givcol::Ptr{BlasInt}, + ldgcol::Ref{BlasInt}, perm::Ptr{BlasInt}, + givnum::Ptr{Float64}, + c::Ptr{Float64}, s::Ptr{Float64}, rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zlalsd(uplo, smlsiz, n, nrhs, d, e, b, ldb, rcond, rank, work, rwork, iwork, info) + @ccall libblastrampoline.zlalsd_(uplo::Ref{UInt8}, smlsiz::Ref{BlasInt}, + n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + rcond::Ref{Float64}, + rank::Ref{BlasInt}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlamswlq(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.zlamswlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlamtsqr(side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info) + @ccall libblastrampoline.zlamtsqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlangb(norm, n, kl, ku, ab, ldab, work) + @ccall libblastrampoline.zlangb_(norm::Ref{UInt8}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zlange(norm, m, n, a, lda, work) + @ccall libblastrampoline.zlange_(norm::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zlangt(norm, n, dl, d, du) + @ccall libblastrampoline.zlangt_(norm::Ref{UInt8}, n::Ref{BlasInt}, dl::Ptr{ComplexF64}, + d::Ptr{ComplexF64}, du::Ptr{ComplexF64}, + 1::Clong)::Float64 +end + +function zlanhb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.zlanhb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong, 1::Clong)::Float64 +end + +function zlanhe(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.zlanhe_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong, 1::Clong)::Float64 +end + +function zlanhf(norm, transr, uplo, n, a, work) + @ccall libblastrampoline.zlanhf_(norm::Ref{UInt8}, transr::Ref{UInt8}, uplo::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + work::Ptr{Float64}, + 1::Clong, 1::Clong, 1::Clong)::Float64 +end + +function zlanhp(norm, uplo, n, ap, work) + @ccall libblastrampoline.zlanhp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, work::Ptr{Float64}, 1::Clong, + 1::Clong)::Float64 +end + +function zlanhs(norm, n, a, lda, work) + @ccall libblastrampoline.zlanhs_(norm::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, work::Ptr{Float64}, + 1::Clong)::Float64 +end + +function zlanht(norm, n, d, e) + @ccall libblastrampoline.zlanht_(norm::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{ComplexF64}, 1::Clong)::Float64 +end + +function zlansb(norm, uplo, n, k, ab, ldab, work) + @ccall libblastrampoline.zlansb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + k::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + work::Ptr{Float64}, 1::Clong, 1::Clong)::Float64 +end + +function zlansp(norm, uplo, n, ap, work) + @ccall libblastrampoline.zlansp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, work::Ptr{Float64}, 1::Clong, + 1::Clong)::Float64 +end + +function zlansy(norm, uplo, n, a, lda, work) + @ccall libblastrampoline.zlansy_(norm::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + work::Ptr{Float64}, + 1::Clong, 1::Clong)::Float64 +end + +function zlantb(norm, uplo, diag, n, k, ab, ldab, work) + @ccall libblastrampoline.zlantb_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, k::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong, + 1::Clong, + 1::Clong)::Float64 +end + +function zlantp(norm, uplo, diag, n, ap, work) + @ccall libblastrampoline.zlantp_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + work::Ptr{Float64}, + 1::Clong, 1::Clong, 1::Clong)::Float64 +end + +function zlantr(norm, uplo, diag, m, n, a, lda, work) + @ccall libblastrampoline.zlantr_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, work::Ptr{Float64}, 1::Clong, + 1::Clong, + 1::Clong)::Float64 +end + +function zlapll(n, x, incx, y, incy, ssmin) + @ccall libblastrampoline.zlapll_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, incy::Ref{BlasInt}, + ssmin::Ref{Float64})::Cvoid +end + +function zlapmr(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.zlapmr_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function zlapmt(forwrd, m, n, x, ldx, k) + @ccall libblastrampoline.zlapmt_(forwrd::Ref{BlasInt}, m::Ref{BlasInt}, n::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + k::Ptr{BlasInt})::Cvoid +end + +function zlaqgb(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.zlaqgb_(m::Ref{BlasInt}, n::Ref{BlasInt}, kl::Ref{BlasInt}, + ku::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + r::Ptr{Float64}, + c::Ptr{Float64}, rowcnd::Ref{Float64}, + colcnd::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function zlaqge(m, n, a, lda, r, c, rowcnd, colcnd, amax, equed) + @ccall libblastrampoline.zlaqge_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, r::Ptr{Float64}, c::Ptr{Float64}, + rowcnd::Ref{Float64}, colcnd::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong)::Cvoid +end + +function zlaqhb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.zlaqhb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + s::Ptr{Float64}, + scond::Ref{Float64}, amax::Ref{Float64}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlaqhe(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.zlaqhe_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function zlaqhp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.zlaqhp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function zlaqp2(m, n, offset, a, lda, jpvt, tau, vn1, vn2, work) + @ccall libblastrampoline.zlaqp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, + tau::Ptr{ComplexF64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + work::Ptr{ComplexF64})::Cvoid +end + +function zlaqp2rk(m, n, nrhs, ioffset, kmax, abstol, reltol, kp1, maxc2nrm, a, lda, k, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, work, info) + @ccall libblastrampoline.zlaqp2rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, kmax::Ref{BlasInt}, + abstol::Ref{Float64}, + reltol::Ref{Float64}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + k::Ref{BlasInt}, maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt})::Cvoid +end + +function zlaqp3rk(m, n, nrhs, ioffset, nb, abstol, reltol, kp1, maxc2nrm, a, lda, done, kb, + maxc2nrmk, relmaxc2nrmk, jpiv, tau, vn1, vn2, auxv, f, ldf, iwork, info) + @ccall libblastrampoline.zlaqp3rk_(m::Ref{BlasInt}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ioffset::Ref{BlasInt}, nb::Ref{BlasInt}, + abstol::Ref{Float64}, + reltol::Ref{Float64}, kp1::Ref{BlasInt}, + maxc2nrm::Ref{Float64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + done::Ref{BlasInt}, kb::Ref{BlasInt}, + maxc2nrmk::Ref{Float64}, + relmaxc2nrmk::Ref{Float64}, jpiv::Ptr{BlasInt}, + tau::Ptr{ComplexF64}, vn1::Ptr{Float64}, + vn2::Ptr{Float64}, + auxv::Ptr{ComplexF64}, f::Ptr{ComplexF64}, + ldf::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zlaqps(m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf) + @ccall libblastrampoline.zlaqps_(m::Ref{BlasInt}, n::Ref{BlasInt}, offset::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + jpvt::Ptr{BlasInt}, tau::Ptr{ComplexF64}, + vn1::Ptr{Float64}, + vn2::Ptr{Float64}, auxv::Ptr{ComplexF64}, + f::Ptr{ComplexF64}, + ldf::Ref{BlasInt})::Cvoid +end + +function zlaqr0(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + @ccall libblastrampoline.zlaqr0_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF64}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaqr1(n, h, ldh, s1, s2, v) + @ccall libblastrampoline.zlaqr1_(n::Ref{BlasInt}, h::Ptr{ComplexF64}, ldh::Ref{BlasInt}, + s1::Ref{ComplexF64}, s2::Ref{ComplexF64}, + v::Ptr{ComplexF64})::Cvoid +end + +function zlaqr2(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, + ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.zlaqr2_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{ComplexF64}, ldh::Ref{BlasInt}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, + sh::Ptr{ComplexF64}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, + wv::Ptr{ComplexF64}, ldwv::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt})::Cvoid +end + +function zlaqr3(wantt, wantz, n, ktop, kbot, nw, h, ldh, iloz, ihiz, z, ldz, ns, nd, sh, v, + ldv, nh, t, ldt, nv, wv, ldwv, work, lwork) + @ccall libblastrampoline.zlaqr3_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ktop::Ref{BlasInt}, kbot::Ref{BlasInt}, + nw::Ref{BlasInt}, + h::Ptr{ComplexF64}, ldh::Ref{BlasInt}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + ns::Ref{BlasInt}, nd::Ref{BlasInt}, + sh::Ptr{ComplexF64}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + nh::Ref{BlasInt}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + nv::Ref{BlasInt}, + wv::Ptr{ComplexF64}, ldwv::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt})::Cvoid +end + +function zlaqr4(wantt, wantz, n, ilo, ihi, h, ldh, w, iloz, ihiz, z, ldz, work, lwork, info) + @ccall libblastrampoline.zlaqr4_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, w::Ptr{ComplexF64}, + iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaqr5(wantt, wantz, kacc22, n, ktop, kbot, nshfts, s, h, ldh, iloz, ihiz, z, ldz, + v, ldv, u, ldu, nv, wv, ldwv, nh, wh, ldwh) + @ccall libblastrampoline.zlaqr5_(wantt::Ref{BlasInt}, wantz::Ref{BlasInt}, + kacc22::Ref{BlasInt}, + n::Ref{BlasInt}, ktop::Ref{BlasInt}, + kbot::Ref{BlasInt}, + nshfts::Ref{BlasInt}, s::Ptr{ComplexF64}, + h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, iloz::Ref{BlasInt}, + ihiz::Ref{BlasInt}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, u::Ptr{ComplexF64}, + ldu::Ref{BlasInt}, + nv::Ref{BlasInt}, wv::Ptr{ComplexF64}, + ldwv::Ref{BlasInt}, + nh::Ref{BlasInt}, wh::Ptr{ComplexF64}, + ldwh::Ref{BlasInt})::Cvoid +end + +function zlaqsb(uplo, n, kd, ab, ldab, s, scond, amax, equed) + @ccall libblastrampoline.zlaqsb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + s::Ptr{Float64}, + scond::Ref{Float64}, amax::Ref{Float64}, + equed::Ref{UInt8}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlaqsp(uplo, n, ap, s, scond, amax, equed) + @ccall libblastrampoline.zlaqsp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + equed::Ref{UInt8}, 1::Clong, 1::Clong)::Cvoid +end + +function zlaqsy(uplo, n, a, lda, s, scond, amax, equed) + @ccall libblastrampoline.zlaqsy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, equed::Ref{UInt8}, 1::Clong, + 1::Clong)::Cvoid +end + +function zlar1v(n, b1, bn, lambda, d, l, ld, lld, pivmin, gaptol, z, wantnc, negcnt, ztz, + mingma, r, isuppz, nrminv, resid, rqcorr, work) + @ccall libblastrampoline.zlar1v_(n::Ref{BlasInt}, b1::Ref{BlasInt}, bn::Ref{BlasInt}, + lambda::Ref{Float64}, d::Ptr{Float64}, l::Ptr{Float64}, + ld::Ptr{Float64}, lld::Ptr{Float64}, + pivmin::Ref{Float64}, + gaptol::Ref{Float64}, z::Ptr{ComplexF64}, + wantnc::Ref{BlasInt}, + negcnt::Ref{BlasInt}, ztz::Ref{Float64}, + mingma::Ref{Float64}, + r::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + nrminv::Ref{Float64}, + resid::Ref{Float64}, rqcorr::Ref{Float64}, + work::Ptr{Float64})::Cvoid +end + +function zlar2v(n, x, y, z, incx, c, s, incc) + @ccall libblastrampoline.zlar2v_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + y::Ptr{ComplexF64}, + z::Ptr{ComplexF64}, incx::Ref{BlasInt}, + c::Ptr{Float64}, + s::Ptr{ComplexF64}, incc::Ref{BlasInt})::Cvoid +end + +function zlarcm(m, n, a, lda, b, ldb, c, ldc, rwork) + @ccall libblastrampoline.zlarcm_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{Float64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, rwork::Ptr{Float64})::Cvoid +end + +function zlarf(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.zlarf_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF64}, incv::Ref{BlasInt}, + tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlarf1f(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.zlarf1f_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF64}, incv::Ref{BlasInt}, + tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlarf1l(side, m, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.zlarf1l_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF64}, incv::Ref{BlasInt}, + tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlarfb(side, trans, direct, storev, m, n, k, v, ldv, t, ldt, c, ldc, work, ldwork) + @ccall libblastrampoline.zlarfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zlarfb_gett(ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork) + @ccall libblastrampoline.zlarfb_gett_(ident::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, work::Ptr{ComplexF64}, + ldwork::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlarfg(n, alpha, x, incx, tau) + @ccall libblastrampoline.zlarfg_(n::Ref{BlasInt}, alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, tau::Ref{ComplexF64})::Cvoid +end + +function zlarfgp(n, alpha, x, incx, tau) + @ccall libblastrampoline.zlarfgp_(n::Ref{BlasInt}, alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, tau::Ref{ComplexF64})::Cvoid +end + +function zlarft(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.zlarft_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + tau::Ptr{ComplexF64}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlarfx(side, m, n, v, tau, c, ldc, work) + @ccall libblastrampoline.zlarfx_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + v::Ptr{ComplexF64}, tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlarfy(uplo, n, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.zlarfy_(uplo::Ref{UInt8}, n::Ref{BlasInt}, v::Ptr{ComplexF64}, + incv::Ref{BlasInt}, tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlargv(n, x, incx, y, incy, c, incc) + @ccall libblastrampoline.zlargv_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, incy::Ref{BlasInt}, + c::Ptr{Float64}, + incc::Ref{BlasInt})::Cvoid +end + +function zlarnv(idist, iseed, n, x) + @ccall libblastrampoline.zlarnv_(idist::Ref{BlasInt}, iseed::Ptr{BlasInt}, + n::Ref{BlasInt}, + x::Ptr{ComplexF64})::Cvoid +end + +function zlarrv(n, vl, vu, d, l, pivmin, isplit, m, dol, dou, minrgp, rtol1, rtol2, w, werr, + wgap, iblock, indexw, gers, z, ldz, isuppz, work, iwork, info) + @ccall libblastrampoline.zlarrv_(n::Ref{BlasInt}, vl::Ref{Float64}, vu::Ref{Float64}, + d::Ptr{Float64}, l::Ptr{Float64}, pivmin::Ref{Float64}, + isplit::Ptr{BlasInt}, m::Ref{BlasInt}, + dol::Ref{BlasInt}, + dou::Ref{BlasInt}, minrgp::Ref{Float64}, + rtol1::Ref{Float64}, + rtol2::Ref{Float64}, w::Ptr{Float64}, + werr::Ptr{Float64}, + wgap::Ptr{Float64}, iblock::Ptr{BlasInt}, + indexw::Ptr{BlasInt}, + gers::Ptr{Float64}, z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, work::Ptr{Float64}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlarscl2(m, n, d, x, ldx) + @ccall libblastrampoline.zlarscl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float64}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt})::Cvoid +end + +function zlartv(n, x, incx, y, incy, c, s, incc) + @ccall libblastrampoline.zlartv_(n::Ref{BlasInt}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + y::Ptr{ComplexF64}, incy::Ref{BlasInt}, + c::Ptr{Float64}, + s::Ptr{ComplexF64}, incc::Ref{BlasInt})::Cvoid +end + +function zlarz(side, m, n, l, v, incv, tau, c, ldc, work) + @ccall libblastrampoline.zlarz_(side::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + l::Ref{BlasInt}, + v::Ptr{ComplexF64}, incv::Ref{BlasInt}, + tau::Ref{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zlarzb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, + ldwork) + @ccall libblastrampoline.zlarzb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + ldwork::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zlarzt(direct, storev, n, k, v, ldv, tau, t, ldt) + @ccall libblastrampoline.zlarzt_(direct::Ref{UInt8}, storev::Ref{UInt8}, + n::Ref{BlasInt}, + k::Ref{BlasInt}, v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + tau::Ptr{ComplexF64}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zlascl(type, kl, ku, cfrom, cto, m, n, a, lda, info) + @ccall libblastrampoline.zlascl_(type::Ref{UInt8}, kl::Ref{BlasInt}, ku::Ref{BlasInt}, + cfrom::Ref{Float64}, cto::Ref{Float64}, + m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlascl2(m, n, d, x, ldx) + @ccall libblastrampoline.zlascl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, d::Ptr{Float64}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt})::Cvoid +end + +function zlaset(uplo, m, n, alpha, beta, a, lda) + @ccall libblastrampoline.zlaset_(uplo::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, beta::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlasr(side, pivot, direct, m, n, c, s, a, lda) + @ccall libblastrampoline.zlasr_(side::Ref{UInt8}, pivot::Ref{UInt8}, direct::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, c::Ptr{Float64}, + s::Ptr{Float64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function zlaswlq(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.zlaswlq_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaswp(n, a, lda, k1, k2, ipiv, incx) + @ccall libblastrampoline.zlaswp_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + k1::Ref{BlasInt}, k2::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + incx::Ref{BlasInt})::Cvoid +end + +function zlasyf(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.zlasyf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF64}, ldw::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlasyf_aa(uplo, j1, m, nb, a, lda, ipiv, h, ldh, work) + @ccall libblastrampoline.zlasyf_aa_(uplo::Ref{UInt8}, j1::Ref{BlasInt}, m::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, h::Ptr{ComplexF64}, + ldh::Ref{BlasInt}, + work::Ptr{ComplexF64}, 1::Clong)::Cvoid +end + +function zlasyf_rk(uplo, n, nb, kb, a, lda, e, ipiv, w, ldw, info) + @ccall libblastrampoline.zlasyf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + w::Ptr{ComplexF64}, + ldw::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlasyf_rook(uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) + @ccall libblastrampoline.zlasyf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nb::Ref{BlasInt}, + kb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, w::Ptr{ComplexF64}, + ldw::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlat2c(uplo, n, a, lda, sa, ldsa, info) + @ccall libblastrampoline.zlat2c_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, sa::Ptr{ComplexF32}, + ldsa::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlatbs(uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info) + @ccall libblastrampoline.zlatbs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + x::Ptr{ComplexF64}, + scale::Ref{Float64}, cnorm::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zlatdf(ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv) + @ccall libblastrampoline.zlatdf_(ijob::Ref{BlasInt}, n::Ref{BlasInt}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, rhs::Ptr{ComplexF64}, + rdsum::Ref{Float64}, + rdscal::Ref{Float64}, ipiv::Ptr{BlasInt}, + jpiv::Ptr{BlasInt})::Cvoid +end + +function zlatps(uplo, trans, diag, normin, n, ap, x, scale, cnorm, info) + @ccall libblastrampoline.zlatps_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, + x::Ptr{ComplexF64}, scale::Ref{Float64}, + cnorm::Ptr{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zlatrd(uplo, n, nb, a, lda, e, tau, w, ldw) + @ccall libblastrampoline.zlatrd_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, e::Ptr{Float64}, + tau::Ptr{ComplexF64}, w::Ptr{ComplexF64}, + ldw::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zlatrs(uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info) + @ccall libblastrampoline.zlatrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, x::Ptr{ComplexF64}, + scale::Ref{Float64}, + cnorm::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zlatrs3(uplo, trans, diag, normin, n, nrhs, a, lda, x, ldx, scale, cnorm, work, + lwork, info) + @ccall libblastrampoline.zlatrs3_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + normin::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, scale::Ptr{Float64}, + cnorm::Ptr{Float64}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zlatrz(m, n, l, a, lda, tau, work) + @ccall libblastrampoline.zlatrz_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64})::Cvoid +end + +function zlatsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.zlatsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zlaunhr_col_getrfnp(m, n, a, lda, d, info) + @ccall libblastrampoline.zlaunhr_col_getrfnp_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zlaunhr_col_getrfnp2(m, n, a, lda, d, info) + @ccall libblastrampoline.zlaunhr_col_getrfnp2_(m::Ref{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, d::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zlauu2(uplo, n, a, lda, info) + @ccall libblastrampoline.zlauu2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zlauum(uplo, n, a, lda, info) + @ccall libblastrampoline.zlauum_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpbcon(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.zpbcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbequ(uplo, n, kd, ab, ldab, s, scond, amax, info) + @ccall libblastrampoline.zpbequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + s::Ptr{Float64}, + scond::Ref{Float64}, amax::Ref{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbrfs(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zpbrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + afb::Ptr{ComplexF64}, ldafb::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbstf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.zpbstf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbsv(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.zpbsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbsvx(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, + rcond, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zpbsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, afb::Ptr{ComplexF64}, + ldafb::Ref{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zpbtf2(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.zpbtf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbtrf(uplo, n, kd, ab, ldab, info) + @ccall libblastrampoline.zpbtrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpbtrs(uplo, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.zpbtrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, kd::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpftrf(transr, uplo, n, a, info) + @ccall libblastrampoline.zpftrf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zpftri(transr, uplo, n, a, info) + @ccall libblastrampoline.zpftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zpftrs(transr, uplo, n, nrhs, a, b, ldb, info) + @ccall libblastrampoline.zpftrs_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zpocon(uplo, n, a, lda, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.zpocon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpoequ(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.zpoequ_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function zpoequb(n, a, lda, s, scond, amax, info) + @ccall libblastrampoline.zpoequb_(n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt})::Cvoid +end + +function zporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.zporfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zporfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, s, b, ldb, x, ldx, rcond, berr, + n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, rwork, + info) + @ccall libblastrampoline.zporfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + s::Ptr{Float64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zposv(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.zposv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zposvx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + ferr, berr, work, rwork, info) + @ccall libblastrampoline.zposvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float64}, b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zposvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, + rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, + work, rwork, info) + @ccall libblastrampoline.zposvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + equed::Ref{UInt8}, + s::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + rpvgrw::Ref{Float64}, berr::Ptr{Float64}, + n_err_bnds::Ref{BlasInt}, err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, nparams::Ref{BlasInt}, + params::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end + +function zpotf2(uplo, n, a, lda, info) + @ccall libblastrampoline.zpotf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpotrf(uplo, n, a, lda, info) + @ccall libblastrampoline.zpotrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpotrf2(uplo, n, a, lda, info) + @ccall libblastrampoline.zpotrf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpotri(uplo, n, a, lda, info) + @ccall libblastrampoline.zpotri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpotrs(uplo, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.zpotrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zppcon(uplo, n, ap, anorm, rcond, work, rwork, info) + @ccall libblastrampoline.zppcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zppequ(uplo, n, ap, s, scond, amax, info) + @ccall libblastrampoline.zppequ_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + s::Ptr{Float64}, scond::Ref{Float64}, + amax::Ref{Float64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpprfs(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zpprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, afp::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zppsv(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.zppsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zppsvx(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, + work, rwork, info) + @ccall libblastrampoline.zppsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF64}, + afp::Ptr{ComplexF64}, + equed::Ref{UInt8}, s::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zpptrf(uplo, n, ap, info) + @ccall libblastrampoline.zpptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpptri(uplo, n, ap, info) + @ccall libblastrampoline.zpptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpptrs(uplo, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.zpptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zpstf2(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.zpstf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpstrf(uplo, n, a, lda, piv, rank, tol, work, info) + @ccall libblastrampoline.zpstrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, piv::Ptr{BlasInt}, + rank::Ref{BlasInt}, + tol::Ref{Float64}, work::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zptcon(n, d, e, anorm, rcond, rwork, info) + @ccall libblastrampoline.zptcon_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{ComplexF64}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + rwork::Ptr{Float64}, info::Ref{BlasInt})::Cvoid +end + +function zpteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.zpteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zptrfs(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zptrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{ComplexF64}, df::Ptr{Float64}, + ef::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zptsv(n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.zptsv_(n::Ref{BlasInt}, nrhs::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zptsvx(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.zptsvx_(fact::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{ComplexF64}, df::Ptr{Float64}, + ef::Ptr{ComplexF64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zpttrf(n, d, e, info) + @ccall libblastrampoline.zpttrf_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zpttrs(uplo, n, nrhs, d, e, b, ldb, info) + @ccall libblastrampoline.zpttrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zptts2(iuplo, n, nrhs, d, e, b, ldb) + @ccall libblastrampoline.zptts2_(iuplo::Ref{BlasInt}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt})::Cvoid +end + +function zrot(n, cx, incx, cy, incy, c, s) + @ccall libblastrampoline.zrot_(n::Ref{BlasInt}, cx::Ptr{ComplexF64}, incx::Ref{BlasInt}, + cy::Ptr{ComplexF64}, incy::Ref{BlasInt}, c::Ref{Float64}, + s::Ref{ComplexF64})::Cvoid +end + +function zrscl(n, a, x, incx) + @ccall libblastrampoline.zrscl_(n::Ref{BlasInt}, a::Ref{ComplexF64}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt})::Cvoid +end + +function zspcon(uplo, n, ap, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zspcon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, anorm::Ref{Float64}, + rcond::Ref{Float64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zspmv(uplo, n, alpha, ap, x, incx, beta, y, incy) + @ccall libblastrampoline.zspmv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + ap::Ptr{ComplexF64}, x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, + beta::Ref{ComplexF64}, y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zspr(uplo, n, alpha, x, incx, ap) + @ccall libblastrampoline.zspr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + ap::Ptr{ComplexF64}, + 1::Clong)::Cvoid +end + +function zsprfs(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info) + @ccall libblastrampoline.zsprfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, afp::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zspsv(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.zspsv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zspsvx(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zspsvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, ap::Ptr{ComplexF64}, + afp::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zsptrf(uplo, n, ap, ipiv, info) + @ccall libblastrampoline.zsptrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsptri(uplo, n, ap, ipiv, work, info) + @ccall libblastrampoline.zsptri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsptrs(uplo, n, nrhs, ap, ipiv, b, ldb, info) + @ccall libblastrampoline.zsptrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zstedc(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info) + @ccall libblastrampoline.zstedc_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zstegr(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, + lwork, iwork, liwork, info) + @ccall libblastrampoline.zstegr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + abstol::Ref{Float64}, m::Ref{BlasInt}, w::Ptr{Float64}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + isuppz::Ptr{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zstein(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info) + @ccall libblastrampoline.zstein_(n::Ref{BlasInt}, d::Ptr{Float64}, e::Ptr{Float64}, + m::Ref{BlasInt}, + w::Ptr{Float64}, iblock::Ptr{BlasInt}, + isplit::Ptr{BlasInt}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, + iwork::Ptr{BlasInt}, ifail::Ptr{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zstemr(jobz, range, n, d, e, vl, vu, il, iu, m, w, z, ldz, nzc, isuppz, tryrac, + work, lwork, iwork, liwork, info) + @ccall libblastrampoline.zstemr_(jobz::Ref{UInt8}, range::Ref{UInt8}, n::Ref{BlasInt}, + d::Ptr{Float64}, e::Ptr{Float64}, vl::Ref{Float64}, + vu::Ref{Float64}, il::Ref{BlasInt}, iu::Ref{BlasInt}, + m::Ref{BlasInt}, + w::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + nzc::Ref{BlasInt}, isuppz::Ptr{BlasInt}, + tryrac::Ref{BlasInt}, + work::Ptr{Float64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zsteqr(compz, n, d, e, z, ldz, work, info) + @ccall libblastrampoline.zsteqr_(compz::Ref{UInt8}, n::Ref{BlasInt}, d::Ptr{Float64}, + e::Ptr{Float64}, z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + work::Ptr{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsycon(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zsycon_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsycon_3(uplo, n, a, lda, e, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zsycon_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, rcond::Ref{Float64}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsycon_rook(uplo, n, a, lda, ipiv, anorm, rcond, work, info) + @ccall libblastrampoline.zsycon_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + anorm::Ref{Float64}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsyconv(uplo, way, n, a, lda, ipiv, e, info) + @ccall libblastrampoline.zsyconv_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + e::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zsyconvf(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.zsyconvf_(uplo::Ref{UInt8}, way::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zsyconvf_rook(uplo, way, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.zsyconvf_rook_(uplo::Ref{UInt8}, way::Ref{UInt8}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zsyequb(uplo, n, a, lda, s, scond, amax, work, info) + @ccall libblastrampoline.zsyequb_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, s::Ptr{Float64}, + scond::Ref{Float64}, + amax::Ref{Float64}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsymv(uplo, n, alpha, a, lda, x, incx, beta, y, incy) + @ccall libblastrampoline.zsymv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + x::Ptr{ComplexF64}, + incx::Ref{BlasInt}, beta::Ref{ComplexF64}, + y::Ptr{ComplexF64}, + incy::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsyr(uplo, n, alpha, x, incx, a, lda) + @ccall libblastrampoline.zsyr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + alpha::Ref{ComplexF64}, + x::Ptr{ComplexF64}, incx::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsyrfs(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.zsyrfs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, + ldaf::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsyrfsx(uplo, equed, n, nrhs, a, lda, af, ldaf, ipiv, s, b, ldb, x, ldx, rcond, + berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, params, work, + rwork, info) + @ccall libblastrampoline.zsyrfsx_(uplo::Ref{UInt8}, equed::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + s::Ptr{Float64}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + rcond::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zsysv(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zsysv_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsysv_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zsysv_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsysv_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, work, lwork, + info) + @ccall libblastrampoline.zsysv_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF64}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsysv_rk(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zsysv_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsysv_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zsysv_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsysvx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, + berr, work, lwork, rwork, info) + @ccall libblastrampoline.zsysvx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, rcond::Ref{Float64}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zsysvxx(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, equed, s, b, ldb, x, ldx, + rcond, rpvgrw, berr, n_err_bnds, err_bnds_norm, err_bnds_comp, nparams, + params, work, rwork, info) + @ccall libblastrampoline.zsysvxx_(fact::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + af::Ptr{ComplexF64}, ldaf::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + equed::Ref{UInt8}, s::Ptr{Float64}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + rcond::Ref{Float64}, rpvgrw::Ref{Float64}, + berr::Ptr{Float64}, n_err_bnds::Ref{BlasInt}, + err_bnds_norm::Ptr{Float64}, + err_bnds_comp::Ptr{Float64}, + nparams::Ref{BlasInt}, params::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function zsyswapr(uplo, n, a, lda, i1, i2) + @ccall libblastrampoline.zsyswapr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, i1::Ref{BlasInt}, + i2::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytf2(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.zsytf2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytf2_rk(uplo, n, a, lda, e, ipiv, info) + @ccall libblastrampoline.zsytf2_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytf2_rook(uplo, n, a, lda, ipiv, info) + @ccall libblastrampoline.zsytf2_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrf(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytrf_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrf_aa(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytrf_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info) + @ccall libblastrampoline.zsytrf_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tb::Ptr{ComplexF64}, + ltb::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + ipiv2::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytrf_rk(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytrf_rk_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrf_rook(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytrf_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytri(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.zsytri_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytri2(uplo, n, a, lda, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytri2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytri2x(uplo, n, a, lda, ipiv, work, nb, info) + @ccall libblastrampoline.zsytri2x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + nb::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytri_3(uplo, n, a, lda, e, ipiv, work, lwork, info) + @ccall libblastrampoline.zsytri_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytri_3x(uplo, n, a, lda, e, ipiv, work, nb, info) + @ccall libblastrampoline.zsytri_3x_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, nb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytri_rook(uplo, n, a, lda, ipiv, work, info) + @ccall libblastrampoline.zsytri_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ipiv::Ptr{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytrs(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zsytrs_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrs2(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, info) + @ccall libblastrampoline.zsytrs2_(uplo::Ref{UInt8}, n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytrs_3(uplo, n, nrhs, a, lda, e, ipiv, b, ldb, info) + @ccall libblastrampoline.zsytrs_3_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + e::Ptr{ComplexF64}, + ipiv::Ptr{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytrs_aa(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info) + @ccall libblastrampoline.zsytrs_aa_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zsytrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info) + @ccall libblastrampoline.zsytrs_aa_2stage_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tb::Ptr{ComplexF64}, ltb::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, ipiv2::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function zsytrs_rook(uplo, n, nrhs, a, lda, ipiv, b, ldb, info) + @ccall libblastrampoline.zsytrs_rook_(uplo::Ref{UInt8}, n::Ref{BlasInt}, + nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + ipiv::Ptr{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ztbcon(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info) + @ccall libblastrampoline.ztbcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, ab::Ptr{ComplexF64}, + ldab::Ref{BlasInt}, rcond::Ref{Float64}, + work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztbrfs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, + rwork, info) + @ccall libblastrampoline.ztbrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztbtrs(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info) + @ccall libblastrampoline.ztbtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, kd::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ab::Ptr{ComplexF64}, ldab::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztfsm(transr, side, uplo, trans, diag, m, n, alpha, a, b, ldb) + @ccall libblastrampoline.ztfsm_(transr::Ref{UInt8}, side::Ref{UInt8}, uplo::Ref{UInt8}, + trans::Ref{UInt8}, diag::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, alpha::Ref{ComplexF64}, + a::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztftri(transr, uplo, diag, n, a, info) + @ccall libblastrampoline.ztftri_(transr::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztfttp(transr, uplo, n, arf, ap, info) + @ccall libblastrampoline.ztfttp_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{ComplexF64}, ap::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztfttr(transr, uplo, n, arf, a, lda, info) + @ccall libblastrampoline.ztfttr_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + arf::Ptr{ComplexF64}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ztgevc(side, howmny, select, n, s, lds, p, ldp, vl, ldvl, vr, ldvr, mm, m, work, + rwork, info) + @ccall libblastrampoline.ztgevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, s::Ptr{ComplexF64}, lds::Ref{BlasInt}, + p::Ptr{ComplexF64}, ldp::Ref{BlasInt}, + vl::Ptr{ComplexF64}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ztgex2(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info) + @ccall libblastrampoline.ztgex2_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + j1::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ztgexc(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info) + @ccall libblastrampoline.ztgexc_(wantq::Ref{BlasInt}, wantz::Ref{BlasInt}, + n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, ldz::Ref{BlasInt}, + ifst::Ref{BlasInt}, + ilst::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function ztgsen(ijob, wantq, wantz, select, n, a, lda, b, ldb, alpha, beta, q, ldq, z, ldz, + m, pl, pr, dif, work, lwork, iwork, liwork, info) + @ccall libblastrampoline.ztgsen_(ijob::Ref{BlasInt}, wantq::Ref{BlasInt}, + wantz::Ref{BlasInt}, + select::Ptr{BlasInt}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + alpha::Ptr{ComplexF64}, beta::Ptr{ComplexF64}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + z::Ptr{ComplexF64}, + ldz::Ref{BlasInt}, m::Ref{BlasInt}, pl::Ref{Float64}, + pr::Ref{Float64}, dif::Ptr{Float64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + liwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ztgsja(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alpha, beta, u, + ldu, v, ldv, q, ldq, work, ncycle, info) + @ccall libblastrampoline.ztgsja_(jobu::Ref{UInt8}, jobv::Ref{UInt8}, jobq::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + tola::Ref{Float64}, + tolb::Ref{Float64}, alpha::Ptr{Float64}, + beta::Ptr{Float64}, + u::Ptr{ComplexF64}, ldu::Ref{BlasInt}, + v::Ptr{ComplexF64}, + ldv::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + work::Ptr{ComplexF64}, ncycle::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztgsna(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, + work, lwork, iwork, info) + @ccall libblastrampoline.ztgsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + vl::Ptr{ComplexF64}, + ldvl::Ref{BlasInt}, vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, + s::Ptr{Float64}, dif::Ptr{Float64}, mm::Ref{BlasInt}, + m::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ztgsy2(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + rdsum, rdscal, info) + @ccall libblastrampoline.ztgsy2_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, d::Ptr{ComplexF64}, + ldd::Ref{BlasInt}, + e::Ptr{ComplexF64}, lde::Ref{BlasInt}, + f::Ptr{ComplexF64}, + ldf::Ref{BlasInt}, scale::Ref{Float64}, + rdsum::Ref{Float64}, + rdscal::Ref{Float64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ztgsyl(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, + dif, work, lwork, iwork, info) + @ccall libblastrampoline.ztgsyl_(trans::Ref{UInt8}, ijob::Ref{BlasInt}, m::Ref{BlasInt}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, d::Ptr{ComplexF64}, + ldd::Ref{BlasInt}, + e::Ptr{ComplexF64}, lde::Ref{BlasInt}, + f::Ptr{ComplexF64}, + ldf::Ref{BlasInt}, scale::Ref{Float64}, + dif::Ref{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong)::Cvoid +end + +function ztpcon(norm, uplo, diag, n, ap, rcond, work, rwork, info) + @ccall libblastrampoline.ztpcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + rcond::Ref{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztplqt(m, n, l, mb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.ztplqt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt})::Cvoid +end + +function ztplqt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.ztplqt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ztpmlqt(side, trans, m, n, k, l, mb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.ztpmlqt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + mb::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ztpmqrt(side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info) + @ccall libblastrampoline.ztpmqrt_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ztpqrt(m, n, l, nb, a, lda, b, ldb, t, ldt, work, info) + @ccall libblastrampoline.ztpqrt_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt})::Cvoid +end + +function ztpqrt2(m, n, l, a, lda, b, ldb, t, ldt, info) + @ccall libblastrampoline.ztpqrt2_(m::Ref{BlasInt}, n::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function ztprfb(side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, + work, ldwork) + @ccall libblastrampoline.ztprfb_(side::Ref{UInt8}, trans::Ref{UInt8}, + direct::Ref{UInt8}, + storev::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + l::Ref{BlasInt}, v::Ptr{ComplexF64}, ldv::Ref{BlasInt}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + work::Ptr{ComplexF64}, ldwork::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztprfs(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.ztprfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, + ldx::Ref{BlasInt}, ferr::Ptr{Float64}, + berr::Ptr{Float64}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztptri(uplo, diag, n, ap, info) + @ccall libblastrampoline.ztptri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function ztptrs(uplo, trans, diag, n, nrhs, ap, b, ldb, info) + @ccall libblastrampoline.ztptrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + ap::Ptr{ComplexF64}, + b::Ptr{ComplexF64}, ldb::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong)::Cvoid +end + +function ztpttf(transr, uplo, n, ap, arf, info) + @ccall libblastrampoline.ztpttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + ap::Ptr{ComplexF64}, arf::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztpttr(uplo, n, ap, a, lda, info) + @ccall libblastrampoline.ztpttr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ztrcon(norm, uplo, diag, n, a, lda, rcond, work, rwork, info) + @ccall libblastrampoline.ztrcon_(norm::Ref{UInt8}, uplo::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + rcond::Ref{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztrevc(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, + info) + @ccall libblastrampoline.ztrevc_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF64}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrevc3(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, lwork, + rwork, lrwork, info) + @ccall libblastrampoline.ztrevc3_(side::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrexc(compq, n, t, ldt, q, ldq, ifst, ilst, info) + @ccall libblastrampoline.ztrexc_(compq::Ref{UInt8}, n::Ref{BlasInt}, t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + ifst::Ref{BlasInt}, ilst::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ztrrfs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, + info) + @ccall libblastrampoline.ztrrfs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + x::Ptr{ComplexF64}, ldx::Ref{BlasInt}, + ferr::Ptr{Float64}, + berr::Ptr{Float64}, work::Ptr{ComplexF64}, + rwork::Ptr{Float64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, + 1::Clong)::Cvoid +end + +function ztrsen(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info) + @ccall libblastrampoline.ztrsen_(job::Ref{UInt8}, compq::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + w::Ptr{ComplexF64}, + m::Ref{BlasInt}, s::Ref{Float64}, sep::Ref{Float64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrsna(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, + ldwork, rwork, info) + @ccall libblastrampoline.ztrsna_(job::Ref{UInt8}, howmny::Ref{UInt8}, + select::Ptr{BlasInt}, + n::Ref{BlasInt}, t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + vl::Ptr{ComplexF64}, ldvl::Ref{BlasInt}, + vr::Ptr{ComplexF64}, + ldvr::Ref{BlasInt}, s::Ptr{Float64}, sep::Ptr{Float64}, + mm::Ref{BlasInt}, m::Ref{BlasInt}, + work::Ptr{ComplexF64}, + ldwork::Ref{BlasInt}, rwork::Ptr{Float64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrsyl(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info) + @ccall libblastrampoline.ztrsyl_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + scale::Ref{Float64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ztrsyl3(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, swork, ldswork, + info) + @ccall libblastrampoline.ztrsyl3_(trana::Ref{UInt8}, tranb::Ref{UInt8}, + isgn::Ref{BlasInt}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + scale::Ref{Float64}, + swork::Ptr{Float64}, ldswork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrti2(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.ztrti2_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrtri(uplo, diag, n, a, lda, info) + @ccall libblastrampoline.ztrtri_(uplo::Ref{UInt8}, diag::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function ztrtrs(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info) + @ccall libblastrampoline.ztrtrs_(uplo::Ref{UInt8}, trans::Ref{UInt8}, diag::Ref{UInt8}, + n::Ref{BlasInt}, nrhs::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, b::Ptr{ComplexF64}, + ldb::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function ztrttf(transr, uplo, n, a, lda, arf, info) + @ccall libblastrampoline.ztrttf_(transr::Ref{UInt8}, uplo::Ref{UInt8}, n::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + arf::Ptr{ComplexF64}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function ztrttp(uplo, n, a, lda, ap, info) + @ccall libblastrampoline.ztrttp_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, ap::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function ztzrzf(m, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.ztzrzf_(m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zunbdb(trans, signs, m, p, q, x11, ldx11, x12, ldx12, x21, ldx21, x22, ldx22, + theta, phi, taup1, taup2, tauq1, tauq2, work, lwork, info) + @ccall libblastrampoline.zunbdb_(trans::Ref{UInt8}, signs::Ref{UInt8}, m::Ref{BlasInt}, + p::Ref{BlasInt}, q::Ref{BlasInt}, x11::Ptr{ComplexF64}, + ldx11::Ref{BlasInt}, x12::Ptr{ComplexF64}, + ldx12::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + x22::Ptr{ComplexF64}, + ldx22::Ref{BlasInt}, theta::Ptr{Float64}, + phi::Ptr{Float64}, + taup1::Ptr{ComplexF64}, taup2::Ptr{ComplexF64}, + tauq1::Ptr{ComplexF64}, tauq2::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunbdb1(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.zunbdb1_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, + phi::Ptr{Float64}, taup1::Ptr{ComplexF64}, + taup2::Ptr{ComplexF64}, tauq1::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zunbdb2(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.zunbdb2_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, + phi::Ptr{Float64}, taup1::Ptr{ComplexF64}, + taup2::Ptr{ComplexF64}, tauq1::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zunbdb3(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, work, + lwork, info) + @ccall libblastrampoline.zunbdb3_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, + phi::Ptr{Float64}, taup1::Ptr{ComplexF64}, + taup2::Ptr{ComplexF64}, tauq1::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zunbdb4(m, p, q, x11, ldx11, x21, ldx21, theta, phi, taup1, taup2, tauq1, phantom, + work, lwork, info) + @ccall libblastrampoline.zunbdb4_(m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, + phi::Ptr{Float64}, taup1::Ptr{ComplexF64}, + taup2::Ptr{ComplexF64}, tauq1::Ptr{ComplexF64}, + phantom::Ptr{ComplexF64}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zunbdb5(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.zunbdb5_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{ComplexF64}, incx1::Ref{BlasInt}, + x2::Ptr{ComplexF64}, + incx2::Ref{BlasInt}, q1::Ptr{ComplexF64}, + ldq1::Ref{BlasInt}, + q2::Ptr{ComplexF64}, ldq2::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zunbdb6(m1, m2, n, x1, incx1, x2, incx2, q1, ldq1, q2, ldq2, work, lwork, info) + @ccall libblastrampoline.zunbdb6_(m1::Ref{BlasInt}, m2::Ref{BlasInt}, n::Ref{BlasInt}, + x1::Ptr{ComplexF64}, incx1::Ref{BlasInt}, + x2::Ptr{ComplexF64}, + incx2::Ref{BlasInt}, q1::Ptr{ComplexF64}, + ldq1::Ref{BlasInt}, + q2::Ptr{ComplexF64}, ldq2::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zuncsd(jobu1, jobu2, jobv1t, jobv2t, trans, signs, m, p, q, x11, ldx11, x12, ldx12, + x21, ldx21, x22, ldx22, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, v2t, ldv2t, + work, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.zuncsd_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + jobv2t::Ref{UInt8}, trans::Ref{UInt8}, + signs::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x12::Ptr{ComplexF64}, + ldx12::Ref{BlasInt}, x21::Ptr{ComplexF64}, + ldx21::Ref{BlasInt}, + x22::Ptr{ComplexF64}, ldx22::Ref{BlasInt}, + theta::Ptr{Float64}, + u1::Ptr{ComplexF64}, ldu1::Ref{BlasInt}, + u2::Ptr{ComplexF64}, + ldu2::Ref{BlasInt}, v1t::Ptr{ComplexF64}, + ldv1t::Ref{BlasInt}, + v2t::Ptr{ComplexF64}, ldv2t::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, + lrwork::Ref{BlasInt}, iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong, 1::Clong, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zuncsd2by1(jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21, ldx21, theta, u1, ldu1, + u2, ldu2, v1t, ldv1t, work, lwork, rwork, lrwork, iwork, info) + @ccall libblastrampoline.zuncsd2by1_(jobu1::Ref{UInt8}, jobu2::Ref{UInt8}, + jobv1t::Ref{UInt8}, + m::Ref{BlasInt}, p::Ref{BlasInt}, q::Ref{BlasInt}, + x11::Ptr{ComplexF64}, ldx11::Ref{BlasInt}, + x21::Ptr{ComplexF64}, ldx21::Ref{BlasInt}, + theta::Ptr{Float64}, u1::Ptr{ComplexF64}, + ldu1::Ref{BlasInt}, u2::Ptr{ComplexF64}, + ldu2::Ref{BlasInt}, + v1t::Ptr{ComplexF64}, ldv1t::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + rwork::Ptr{Float64}, lrwork::Ref{BlasInt}, + iwork::Ptr{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zung2l(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.zung2l_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zung2r(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.zung2r_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zungbr(vect, m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zungbr_(vect::Ref{UInt8}, m::Ref{BlasInt}, n::Ref{BlasInt}, + k::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zunghr(n, ilo, ihi, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zunghr_(n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zungl2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.zungl2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zunglq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zunglq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zungql(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zungql_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zungqr(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zungqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zungr2(m, n, k, a, lda, tau, work, info) + @ccall libblastrampoline.zungr2_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zungrq(m, n, k, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zungrq_(m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt})::Cvoid +end + +function zungtr(uplo, n, a, lda, tau, work, lwork, info) + @ccall libblastrampoline.zungtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zungtsqr(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.zungtsqr_(m::Ref{BlasInt}, n::Ref{BlasInt}, mb::Ref{BlasInt}, + nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zungtsqr_row(m, n, mb, nb, a, lda, t, ldt, work, lwork, info) + @ccall libblastrampoline.zungtsqr_row_(m::Ref{BlasInt}, n::Ref{BlasInt}, + mb::Ref{BlasInt}, + nb::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, ldt::Ref{BlasInt}, + work::Ptr{ComplexF64}, lwork::Ref{BlasInt}, + info::Ref{BlasInt})::Cvoid +end + +function zunhr_col(m, n, nb, a, lda, t, ldt, d, info) + @ccall libblastrampoline.zunhr_col_(m::Ref{BlasInt}, n::Ref{BlasInt}, nb::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + t::Ptr{ComplexF64}, + ldt::Ref{BlasInt}, d::Ptr{ComplexF64}, + info::Ref{BlasInt})::Cvoid +end + +function zunm22(side, trans, m, n, n1, n2, q, ldq, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunm22_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, n1::Ref{BlasInt}, n2::Ref{BlasInt}, + q::Ptr{ComplexF64}, ldq::Ref{BlasInt}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunm2l(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.zunm2l_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunm2r(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.zunm2r_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunmbr(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmbr_(vect::Ref{UInt8}, side::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, k::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zunmhr(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmhr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, ilo::Ref{BlasInt}, ihi::Ref{BlasInt}, + a::Ptr{ComplexF64}, lda::Ref{BlasInt}, + tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, info::Ref{BlasInt}, 1::Clong, + 1::Clong)::Cvoid +end + +function zunml2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.zunml2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunmlq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmlq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunmql(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmql_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunmqr(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmqr_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunmr2(side, trans, m, n, k, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.zunmr2_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunmr3(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) + @ccall libblastrampoline.zunmr3_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + info::Ref{BlasInt}, + 1::Clong, 1::Clong)::Cvoid +end + +function zunmrq(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmrq_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunmrz(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmrz_(side::Ref{UInt8}, trans::Ref{UInt8}, m::Ref{BlasInt}, + n::Ref{BlasInt}, k::Ref{BlasInt}, l::Ref{BlasInt}, + a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong)::Cvoid +end + +function zunmtr(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info) + @ccall libblastrampoline.zunmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, a::Ptr{ComplexF64}, + lda::Ref{BlasInt}, tau::Ptr{ComplexF64}, + c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, work::Ptr{ComplexF64}, + lwork::Ref{BlasInt}, + info::Ref{BlasInt}, 1::Clong, 1::Clong, + 1::Clong)::Cvoid +end + +function zupgtr(uplo, n, ap, tau, q, ldq, work, info) + @ccall libblastrampoline.zupgtr_(uplo::Ref{UInt8}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + tau::Ptr{ComplexF64}, q::Ptr{ComplexF64}, + ldq::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, + 1::Clong)::Cvoid +end + +function zupmtr(side, uplo, trans, m, n, ap, tau, c, ldc, work, info) + @ccall libblastrampoline.zupmtr_(side::Ref{UInt8}, uplo::Ref{UInt8}, trans::Ref{UInt8}, + m::Ref{BlasInt}, n::Ref{BlasInt}, ap::Ptr{ComplexF64}, + tau::Ptr{ComplexF64}, c::Ptr{ComplexF64}, + ldc::Ref{BlasInt}, + work::Ptr{ComplexF64}, info::Ref{BlasInt}, 1::Clong, + 1::Clong, 1::Clong)::Cvoid +end