lapack-inject 0.1.1

//! Fortran LAPACK symbol exports.
//!
//! This module exports Fortran-style LAPACK symbols (e.g., `dgesv_`) that call
//! the registered function pointers. This allows lapack-inject to be a drop-in
//! replacement for lapack-src.
//!
//! Auto-generated from lapack-sys plus supplemental Netlib LAPACK routines.

#![allow(non_snake_case)]
#![allow(clippy::too_many_arguments)]

use crate::backend::*;
use crate::lapackint;
use num_complex::{Complex32, Complex64};
use std::ffi::c_char;

/// Macro to export a Fortran LAPACK symbol that delegates to the registered function pointer.
macro_rules! export_fortran_symbol {
    ($func_name:ident, $( $param:ident : $param_ty:ty ),* $(,)?) => {
        paste::paste! {
            #[no_mangle]
            pub unsafe extern "C" fn [<$func_name _>](
                $( $param : $param_ty ),*
            ) {
                let f = [<get_ $func_name>]();
                f($( $param ),*);
            }
        }
    };
}

// BBCSD
export_fortran_symbol!(cbbcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    theta: *mut f32,
    phi: *mut f32,
    U1: *mut Complex32,
    ldu1: *const lapackint,
    U2: *mut Complex32,
    ldu2: *const lapackint,
    V1T: *mut Complex32,
    ldv1t: *const lapackint,
    V2T: *mut Complex32,
    ldv2t: *const lapackint,
    B11D: *mut f32,
    B11E: *mut f32,
    B12D: *mut f32,
    B12E: *mut f32,
    B21D: *mut f32,
    B21E: *mut f32,
    B22D: *mut f32,
    B22E: *mut f32,
    rwork: *mut f32,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dbbcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    theta: *mut f64,
    phi: *mut f64,
    U1: *mut f64,
    ldu1: *const lapackint,
    U2: *mut f64,
    ldu2: *const lapackint,
    V1T: *mut f64,
    ldv1t: *const lapackint,
    V2T: *mut f64,
    ldv2t: *const lapackint,
    B11D: *mut f64,
    B11E: *mut f64,
    B12D: *mut f64,
    B12E: *mut f64,
    b21d: *mut f64,
    b21e: *mut f64,
    b22d: *mut f64,
    b22e: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sbbcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    theta: *mut f32,
    phi: *mut f32,
    U1: *mut f32,
    ldu1: *const lapackint,
    U2: *mut f32,
    ldu2: *const lapackint,
    V1T: *mut f32,
    ldv1t: *const lapackint,
    V2T: *mut f32,
    ldv2t: *const lapackint,
    B11D: *mut f32,
    B11E: *mut f32,
    B12D: *mut f32,
    B12E: *mut f32,
    B21D: *mut f32,
    B21E: *mut f32,
    B22D: *mut f32,
    B22E: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zbbcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    theta: *mut f64,
    phi: *mut f64,
    U1: *mut Complex64,
    ldu1: *const lapackint,
    U2: *mut Complex64,
    ldu2: *const lapackint,
    V1T: *mut Complex64,
    ldv1t: *const lapackint,
    V2T: *mut Complex64,
    ldv2t: *const lapackint,
    B11D: *mut f64,
    B11E: *mut f64,
    B12D: *mut f64,
    B12E: *mut f64,
    B21D: *mut f64,
    B21E: *mut f64,
    B22D: *mut f64,
    B22E: *mut f64,
    rwork: *mut f64,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

// BDSDC
export_fortran_symbol!(dbdsdc,
    uplo: *const c_char,
    compq: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    VT: *mut f64,
    ldvt: *const lapackint,
    Q: *mut f64,
    IQ: *mut lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sbdsdc,
    uplo: *const c_char,
    compq: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    VT: *mut f32,
    ldvt: *const lapackint,
    Q: *mut f32,
    IQ: *mut lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// BDSQR
export_fortran_symbol!(cbdsqr,
    uplo: *const c_char,
    n: *const lapackint,
    ncvt: *const lapackint,
    nru: *const lapackint,
    ncc: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    VT: *mut Complex32,
    ldvt: *const lapackint,
    U: *mut Complex32,
    ldu: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dbdsqr,
    uplo: *const c_char,
    n: *const lapackint,
    ncvt: *const lapackint,
    nru: *const lapackint,
    ncc: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    VT: *mut f64,
    ldvt: *const lapackint,
    U: *mut f64,
    ldu: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sbdsqr,
    uplo: *const c_char,
    n: *const lapackint,
    ncvt: *const lapackint,
    nru: *const lapackint,
    ncc: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    VT: *mut f32,
    ldvt: *const lapackint,
    U: *mut f32,
    ldu: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zbdsqr,
    uplo: *const c_char,
    n: *const lapackint,
    ncvt: *const lapackint,
    nru: *const lapackint,
    ncc: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    VT: *mut Complex64,
    ldvt: *const lapackint,
    U: *mut Complex64,
    ldu: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// BDSVDX
export_fortran_symbol!(dbdsvdx,
    uplo: *const c_char,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sbdsvdx,
    uplo: *const c_char,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// CGESV
export_fortran_symbol!(zcgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    work: *mut Complex64,
    swork: *mut Complex32,
    rwork: *mut f64,
    iter: *mut lapackint,
    info: *mut lapackint,
);

// CPOSV
export_fortran_symbol!(zcposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    work: *mut Complex64,
    swork: *mut Complex32,
    rwork: *mut f64,
    iter: *mut lapackint,
    info: *mut lapackint,
);

// DISNA
export_fortran_symbol!(ddisna,
    job: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    D: *const f64,
    SEP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sdisna,
    job: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    D: *const f32,
    SEP: *mut f32,
    info: *mut lapackint,
);

// GBBRD
export_fortran_symbol!(cgbbrd,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ncc: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Q: *mut Complex32,
    ldq: *const lapackint,
    PT: *mut Complex32,
    ldpt: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbbrd,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ncc: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Q: *mut f64,
    ldq: *const lapackint,
    PT: *mut f64,
    ldpt: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbbrd,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ncc: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Q: *mut f32,
    ldq: *const lapackint,
    PT: *mut f32,
    ldpt: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbbrd,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ncc: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Q: *mut Complex64,
    ldq: *const lapackint,
    PT: *mut Complex64,
    ldpt: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBCON
export_fortran_symbol!(cgbcon,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbcon,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbcon,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbcon,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBEQU
export_fortran_symbol!(cgbequ,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbequ,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbequ,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbequ,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// GBEQUB
export_fortran_symbol!(cgbequb,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbequb,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbequb,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbequb,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// GBRFS
export_fortran_symbol!(cgbrfs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    AFB: *const Complex32,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbrfs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    AFB: *const f64,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbrfs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    AFB: *const f32,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbrfs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    AFB: *const Complex64,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBRFSX
export_fortran_symbol!(cgbrfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    AFB: *const Complex32,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbrfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    AFB: *const f64,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbrfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    AFB: *const f32,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbrfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    AFB: *const Complex64,
    ldafb: *const lapackint,
    ipiv: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBSV
export_fortran_symbol!(cgbsv,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbsv,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbsv,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbsv,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// GBSVX
export_fortran_symbol!(cgbsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    AFB: *mut Complex32,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    AFB: *mut f64,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    AFB: *mut f32,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    AFB: *mut Complex64,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBSVXX
export_fortran_symbol!(cgbsvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    AFB: *mut Complex32,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbsvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    AFB: *mut f64,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbsvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    AFB: *mut f32,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbsvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    AFB: *mut Complex64,
    ldafb: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GBTRF
export_fortran_symbol!(cgbtrf,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbtrf,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbtrf,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbtrf,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// GBTRS
export_fortran_symbol!(cgbtrs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgbtrs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgbtrs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgbtrs,
    trans: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// GEBAK
export_fortran_symbol!(cgebak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    scale: *const f32,
    m: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgebak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    scale: *const f64,
    m: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgebak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    scale: *const f32,
    m: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgebak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    scale: *const f64,
    m: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    info: *mut lapackint,
);

// GEBAL
export_fortran_symbol!(cgebal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgebal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgebal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgebal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f64,
    info: *mut lapackint,
);

// GEBRD
export_fortran_symbol!(cgebrd,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tauq: *mut Complex32,
    taup: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgebrd,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tauq: *mut f64,
    taup: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgebrd,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tauq: *mut f32,
    taup: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgebrd,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tauq: *mut Complex64,
    taup: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GECON
export_fortran_symbol!(cgecon,
    norm: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgecon,
    norm: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgecon,
    norm: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgecon,
    norm: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEEQU
export_fortran_symbol!(cgeequ,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeequ,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeequ,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeequ,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// GEEQUB
export_fortran_symbol!(cgeequb,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeequb,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeequb,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    R: *mut f32,
    C: *mut f32,
    rowcnd: *mut f32,
    colcnd: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeequb,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    R: *mut f64,
    C: *mut f64,
    rowcnd: *mut f64,
    colcnd: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// GEES
export_fortran_symbol!(cgees,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<CSelectFn1>,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    sdim: *mut lapackint,
    W: *mut Complex32,
    VS: *mut Complex32,
    ldvs: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgees,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<DSelectFn2>,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    sdim: *mut lapackint,
    WR: *mut f64,
    WI: *mut f64,
    VS: *mut f64,
    ldvs: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgees,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<SSelectFn2>,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    sdim: *mut lapackint,
    WR: *mut f32,
    WI: *mut f32,
    VS: *mut f32,
    ldvs: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgees,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<ZSelectFn1>,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    sdim: *mut lapackint,
    W: *mut Complex64,
    VS: *mut Complex64,
    ldvs: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GEESX
export_fortran_symbol!(cgeesx,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<CSelectFn1>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    sdim: *mut lapackint,
    W: *mut Complex32,
    VS: *mut Complex32,
    ldvs: *const lapackint,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeesx,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<DSelectFn2>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    sdim: *mut lapackint,
    WR: *mut f64,
    WI: *mut f64,
    VS: *mut f64,
    ldvs: *const lapackint,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeesx,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<SSelectFn2>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    sdim: *mut lapackint,
    WR: *mut f32,
    WI: *mut f32,
    VS: *mut f32,
    ldvs: *const lapackint,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeesx,
    jobvs: *const c_char,
    sort: *const c_char,
    select: Option<ZSelectFn1>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    sdim: *mut lapackint,
    W: *mut Complex64,
    VS: *mut Complex64,
    ldvs: *const lapackint,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GEEV
export_fortran_symbol!(cgeev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    WR: *mut f64,
    WI: *mut f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    WR: *mut f32,
    WI: *mut f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEEVX
export_fortran_symbol!(cgeevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f32,
    abnrm: *mut f32,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    WR: *mut f64,
    WI: *mut f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f64,
    abnrm: *mut f64,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    WR: *mut f32,
    WI: *mut f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f32,
    abnrm: *mut f32,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    scale: *mut f64,
    abnrm: *mut f64,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEHRD
export_fortran_symbol!(cgehrd,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgehrd,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgehrd,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgehrd,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEJSV
export_fortran_symbol!(cgejsv,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    jobr: *const c_char,
    jobt: *const c_char,
    jobp: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    SVA: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    cwork: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgejsv,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    jobr: *const c_char,
    jobt: *const c_char,
    jobp: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    SVA: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgejsv,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    jobr: *const c_char,
    jobt: *const c_char,
    jobp: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    SVA: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgejsv,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    jobr: *const c_char,
    jobt: *const c_char,
    jobp: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    SVA: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    cwork: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GELQ
export_fortran_symbol!(cgelq,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    tsize: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelq,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    tsize: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelq,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    tsize: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelq,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    tsize: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GELQ2
export_fortran_symbol!(cgelq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GELQF
export_fortran_symbol!(cgelqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GELS
export_fortran_symbol!(cgels,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgels,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
    arg1: usize,
);

export_fortran_symbol!(sgels,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgels,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GELSD
export_fortran_symbol!(cgelsd,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    S: *mut f32,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelsd,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    S: *mut f64,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelsd,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    S: *mut f32,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelsd,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    S: *mut f64,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GELSS
export_fortran_symbol!(cgelss,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    S: *mut f32,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelss,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    S: *mut f64,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelss,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    S: *mut f32,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelss,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    S: *mut f64,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GELSY
export_fortran_symbol!(cgelsy,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    JPVT: *mut lapackint,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgelsy,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    JPVT: *mut lapackint,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgelsy,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    JPVT: *mut lapackint,
    rcond: *const f32,
    rank: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgelsy,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    JPVT: *mut lapackint,
    rcond: *const f64,
    rank: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEMLQ
export_fortran_symbol!(cgemlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    T: *const Complex32,
    tsize: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgemlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    T: *const f64,
    tsize: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgemlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    T: *const f32,
    tsize: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgemlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    T: *const Complex64,
    tsize: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEMQR
export_fortran_symbol!(cgemqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    T: *const Complex32,
    tsize: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgemqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    T: *const f64,
    tsize: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgemqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    T: *const f32,
    tsize: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgemqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    T: *const Complex64,
    tsize: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEMQRT
export_fortran_symbol!(cgemqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    nb: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgemqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    nb: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgemqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    nb: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgemqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    nb: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GEQL2
export_fortran_symbol!(cgeql2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeql2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeql2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeql2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GEQLF
export_fortran_symbol!(cgeqlf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqlf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqlf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqlf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEQP3
export_fortran_symbol!(cgeqp3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    JPVT: *mut lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqp3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    JPVT: *mut lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqp3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    JPVT: *mut lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqp3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    JPVT: *mut lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEQPF
export_fortran_symbol!(cgeqpf,
    m: *mut lapackint,
    n: *mut lapackint,
    a: *mut Complex32,
    lda: *mut lapackint,
    jpvt: *mut lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqpf,
    m: *mut lapackint,
    n: *mut lapackint,
    a: *mut f64,
    lda: *mut lapackint,
    jpvt: *mut lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqpf,
    m: *mut lapackint,
    n: *mut lapackint,
    a: *mut f32,
    lda: *mut lapackint,
    jpvt: *mut lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqpf,
    m: *mut lapackint,
    n: *mut lapackint,
    a: *mut Complex64,
    lda: *mut lapackint,
    jpvt: *mut lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GEQR
export_fortran_symbol!(cgeqr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    tsize: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    tsize: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    tsize: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    tsize: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEQR2
export_fortran_symbol!(cgeqr2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqr2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqr2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqr2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GEQRF
export_fortran_symbol!(cgeqrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEQRFP
export_fortran_symbol!(cgeqrfp,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqrfp,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqrfp,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqrfp,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GEQRT
export_fortran_symbol!(cgeqrt,
    m: *const lapackint,
    n: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqrt,
    m: *const lapackint,
    n: *const lapackint,
    nb: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqrt,
    m: *const lapackint,
    n: *const lapackint,
    nb: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqrt,
    m: *const lapackint,
    n: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GEQRT2
export_fortran_symbol!(cgeqrt2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqrt2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqrt2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqrt2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

// GEQRT3
export_fortran_symbol!(cgeqrt3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgeqrt3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgeqrt3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgeqrt3,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

// GERFS
export_fortran_symbol!(cgerfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgerfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgerfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgerfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GERFSX
export_fortran_symbol!(cgerfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    R: *const f32,
    C: *const f32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgerfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    R: *const f64,
    C: *const f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgerfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    R: *const f32,
    C: *const f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgerfsx,
    trans: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    R: *const f64,
    C: *const f64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GERQ2
export_fortran_symbol!(cgerq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgerq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sgerq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zgerq2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GERQF
export_fortran_symbol!(cgerqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgerqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgerqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgerqf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GESC2
export_fortran_symbol!(cgesc2,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    rhs: *mut Complex32,
    ipiv: *const lapackint,
    jpiv: *const lapackint,
    scale: *mut f32,
);

export_fortran_symbol!(dgesc2,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    rhs: *mut f64,
    ipiv: *const lapackint,
    jpiv: *const lapackint,
    scale: *mut f64,
);

export_fortran_symbol!(sgesc2,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    rhs: *mut f32,
    ipiv: *const lapackint,
    jpiv: *const lapackint,
    scale: *mut f32,
);

export_fortran_symbol!(zgesc2,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    rhs: *mut Complex64,
    ipiv: *const lapackint,
    jpiv: *const lapackint,
    scale: *mut f64,
);

// GESDD
export_fortran_symbol!(cgesdd,
    jobz: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    VT: *mut Complex32,
    ldvt: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesdd,
    jobz: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    VT: *mut f64,
    ldvt: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesdd,
    jobz: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    VT: *mut f32,
    ldvt: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesdd,
    jobz: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    VT: *mut Complex64,
    ldvt: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GESV
export_fortran_symbol!(cgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// GESVD
export_fortran_symbol!(cgesvd,
    jobu: *const c_char,
    jobvt: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    VT: *mut Complex32,
    ldvt: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvd,
    jobu: *const c_char,
    jobvt: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    VT: *mut f64,
    ldvt: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvd,
    jobu: *const c_char,
    jobvt: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    VT: *mut f32,
    ldvt: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvd,
    jobu: *const c_char,
    jobvt: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    VT: *mut Complex64,
    ldvt: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GESVDQ
export_fortran_symbol!(cgesvdq,
    joba: *const c_char,
    jobp: *const c_char,
    jobr: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    numrank: *mut lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    cwork: *mut Complex32,
    lcwork: *mut lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvdq,
    joba: *const c_char,
    jobp: *const c_char,
    jobr: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    numrank: *mut lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    work: *mut f64,
    lwork: *mut lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvdq,
    joba: *const c_char,
    jobp: *const c_char,
    jobr: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    S: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    numrank: *mut lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    work: *mut f32,
    lwork: *mut lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvdq,
    joba: *const c_char,
    jobp: *const c_char,
    jobr: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    S: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    numrank: *mut lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    cwork: *mut Complex64,
    lcwork: *mut lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

// GESVDX
export_fortran_symbol!(cgesvdx,
    jobu: *const c_char,
    jobvt: *const c_char,
    range: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    VT: *mut Complex32,
    ldvt: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvdx,
    jobu: *const c_char,
    jobvt: *const c_char,
    range: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    VT: *mut f64,
    ldvt: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvdx,
    jobu: *const c_char,
    jobvt: *const c_char,
    range: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    VT: *mut f32,
    ldvt: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvdx,
    jobu: *const c_char,
    jobvt: *const c_char,
    range: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    ns: *mut lapackint,
    S: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    VT: *mut Complex64,
    ldvt: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GESVJ
export_fortran_symbol!(cgesvj,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    SVA: *mut f32,
    mv: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    cwork: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvj,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    SVA: *mut f64,
    mv: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvj,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    SVA: *mut f32,
    mv: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvj,
    joba: *const c_char,
    jobu: *const c_char,
    jobv: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    SVA: *mut f64,
    mv: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    cwork: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

// GESVX
export_fortran_symbol!(cgesvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GESVXX
export_fortran_symbol!(cgesvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgesvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgesvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f32,
    C: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgesvxx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    R: *mut f64,
    C: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GETC2
export_fortran_symbol!(cgetc2,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    jpiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetc2,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    jpiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetc2,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    jpiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetc2,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    jpiv: *mut lapackint,
    info: *mut lapackint,
);

// GETF2
export_fortran_symbol!(cgetf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// GETRF
export_fortran_symbol!(cgetrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetrf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// GETRF2
export_fortran_symbol!(cgetrf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetrf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetrf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetrf2,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// GETRI
export_fortran_symbol!(cgetri,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetri,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetri,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetri,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GETRS
export_fortran_symbol!(cgetrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// GETSLS
export_fortran_symbol!(cgetsls,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetsls,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetsls,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetsls,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GETSQRHRT
export_fortran_symbol!(cgetsqrhrt,
    m: *const lapackint,
    n: *const lapackint,
    mb1: *const lapackint,
    nb1: *const lapackint,
    nb2: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgetsqrhrt,
    m: *const lapackint,
    n: *const lapackint,
    mb1: *const lapackint,
    nb1: *const lapackint,
    nb2: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgetsqrhrt,
    m: *const lapackint,
    n: *const lapackint,
    mb1: *const lapackint,
    nb1: *const lapackint,
    nb2: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgetsqrhrt,
    m: *const lapackint,
    n: *const lapackint,
    mb1: *const lapackint,
    nb1: *const lapackint,
    nb2: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGBAK
export_fortran_symbol!(cggbak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    lscale: *const f32,
    rscale: *const f32,
    m: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggbak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    lscale: *const f64,
    rscale: *const f64,
    m: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggbak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    lscale: *const f32,
    rscale: *const f32,
    m: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggbak,
    job: *const c_char,
    side: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    lscale: *const f64,
    rscale: *const f64,
    m: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    info: *mut lapackint,
);

// GGBAL
export_fortran_symbol!(cggbal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f32,
    rscale: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dggbal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f64,
    rscale: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sggbal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f32,
    rscale: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zggbal,
    job: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f64,
    rscale: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

// GGES
export_fortran_symbol!(cgges,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<CSelectFn2>,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VSL: *mut Complex32,
    ldvsl: *const lapackint,
    VSR: *mut Complex32,
    ldvsr: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgges,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<DSelectFn3>,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VSL: *mut f64,
    ldvsl: *const lapackint,
    VSR: *mut f64,
    ldvsr: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgges,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<SSelectFn3>,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VSL: *mut f32,
    ldvsl: *const lapackint,
    VSR: *mut f32,
    ldvsr: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgges,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<ZSelectFn2>,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VSL: *mut Complex64,
    ldvsl: *const lapackint,
    VSR: *mut Complex64,
    ldvsr: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GGES3
export_fortran_symbol!(cgges3,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<CSelectFn2>,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VSL: *mut Complex32,
    ldvsl: *const lapackint,
    VSR: *mut Complex32,
    ldvsr: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgges3,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<DSelectFn3>,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VSL: *mut f64,
    ldvsl: *const lapackint,
    VSR: *mut f64,
    ldvsr: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgges3,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<SSelectFn3>,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VSL: *mut f32,
    ldvsl: *const lapackint,
    VSR: *mut f32,
    ldvsr: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgges3,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<ZSelectFn2>,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VSL: *mut Complex64,
    ldvsl: *const lapackint,
    VSR: *mut Complex64,
    ldvsr: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GGESX
export_fortran_symbol!(cggesx,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<CSelectFn2>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VSL: *mut Complex32,
    ldvsl: *const lapackint,
    VSR: *mut Complex32,
    ldvsr: *const lapackint,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggesx,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<DSelectFn3>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VSL: *mut f64,
    ldvsl: *const lapackint,
    VSR: *mut f64,
    ldvsr: *const lapackint,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggesx,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<SSelectFn3>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VSL: *mut f32,
    ldvsl: *const lapackint,
    VSR: *mut f32,
    ldvsr: *const lapackint,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggesx,
    jobvsl: *const c_char,
    jobvsr: *const c_char,
    sort: *const c_char,
    selctg: Option<ZSelectFn2>,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    sdim: *mut lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VSL: *mut Complex64,
    ldvsl: *const lapackint,
    VSR: *mut Complex64,
    ldvsr: *const lapackint,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GGEV
export_fortran_symbol!(cggev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dggev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggev,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GGEV3
export_fortran_symbol!(cggev3,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dggev3,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggev3,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggev3,
    jobvl: *const c_char,
    jobvr: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GGEVX
export_fortran_symbol!(cggevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f32,
    rscale: *mut f32,
    abnrm: *mut f32,
    bbnrm: *mut f32,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f64,
    rscale: *mut f64,
    abnrm: *mut f64,
    bbnrm: *mut f64,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f32,
    rscale: *mut f32,
    abnrm: *mut f32,
    bbnrm: *mut f32,
    rconde: *mut f32,
    rcondv: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggevx,
    balanc: *const c_char,
    jobvl: *const c_char,
    jobvr: *const c_char,
    sense: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    ilo: *mut lapackint,
    ihi: *mut lapackint,
    lscale: *mut f64,
    rscale: *mut f64,
    abnrm: *mut f64,
    bbnrm: *mut f64,
    rconde: *mut f64,
    rcondv: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    BWORK: *mut lapackint,
    info: *mut lapackint,
);

// GGGLM
export_fortran_symbol!(cggglm,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    D: *mut Complex32,
    X: *mut Complex32,
    Y: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggglm,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    D: *mut f64,
    X: *mut f64,
    Y: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggglm,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    D: *mut f32,
    X: *mut f32,
    Y: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggglm,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    D: *mut Complex64,
    X: *mut Complex64,
    Y: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGHD3
export_fortran_symbol!(cgghd3,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgghd3,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgghd3,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgghd3,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGHRD
export_fortran_symbol!(cgghrd,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgghrd,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgghrd,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgghrd,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    info: *mut lapackint,
);

// GGLSE
export_fortran_symbol!(cgglse,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    C: *mut Complex32,
    D: *mut Complex32,
    X: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgglse,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    C: *mut f64,
    D: *mut f64,
    X: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgglse,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    C: *mut f32,
    D: *mut f32,
    X: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgglse,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    C: *mut Complex64,
    D: *mut Complex64,
    X: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGQRF
export_fortran_symbol!(cggqrf,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    taua: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    taub: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggqrf,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    taua: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    taub: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggqrf,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    taua: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    taub: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggqrf,
    n: *const lapackint,
    m: *const lapackint,
    p: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    taua: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    taub: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGRQF
export_fortran_symbol!(cggrqf,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    taua: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    taub: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggrqf,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    taua: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    taub: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggrqf,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    taua: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    taub: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggrqf,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    taua: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    taub: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GGSVD
export_fortran_symbol!(cggsvd,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    a: *mut Complex32,
    lda: *const lapackint,
    b: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut f32,
    beta: *mut f32,
    u: *mut Complex32,
    ldu: *const lapackint,
    v: *mut Complex32,
    ldv: *const lapackint,
    q: *mut Complex32,
    ldq: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggsvd,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    a: *mut f64,
    lda: *const lapackint,
    b: *mut f64,
    ldb: *const lapackint,
    alpha: *mut f64,
    beta: *mut f64,
    u: *mut f64,
    ldu: *const lapackint,
    v: *mut f64,
    ldv: *const lapackint,
    q: *mut f64,
    ldq: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggsvd,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    a: *mut f32,
    lda: *const lapackint,
    b: *mut f32,
    ldb: *const lapackint,
    alpha: *mut f32,
    beta: *mut f32,
    u: *mut f32,
    ldu: *const lapackint,
    v: *mut f32,
    ldv: *const lapackint,
    q: *mut f32,
    ldq: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggsvd,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    a: *mut Complex64,
    lda: *const lapackint,
    b: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut f64,
    beta: *mut f64,
    u: *mut Complex64,
    ldu: *const lapackint,
    v: *mut Complex64,
    ldv: *const lapackint,
    q: *mut Complex64,
    ldq: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GGSVD3
export_fortran_symbol!(cggsvd3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut f32,
    beta: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggsvd3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    alpha: *mut f64,
    beta: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggsvd3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    alpha: *mut f32,
    beta: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggsvd3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    p: *const lapackint,
    k: *mut lapackint,
    l: *mut lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut f64,
    beta: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// GGSVP
export_fortran_symbol!(cggsvp,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    a: *mut Complex32,
    lda: *const lapackint,
    b: *mut Complex32,
    ldb: *const lapackint,
    tola: *mut f32,
    tolb: *mut f32,
    k: *mut lapackint,
    l: *mut lapackint,
    u: *mut Complex32,
    ldu: *const lapackint,
    v: *mut Complex32,
    ldv: *const lapackint,
    q: *mut Complex32,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    rwork: *mut f32,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dggsvp,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    a: *mut f64,
    lda: *const lapackint,
    b: *mut f64,
    ldb: *const lapackint,
    tola: *mut f64,
    tolb: *mut f64,
    k: *mut lapackint,
    l: *mut lapackint,
    u: *mut f64,
    ldu: *const lapackint,
    v: *mut f64,
    ldv: *const lapackint,
    q: *mut f64,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    tau: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sggsvp,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    a: *mut f32,
    lda: *const lapackint,
    b: *mut f32,
    ldb: *const lapackint,
    tola: *mut f32,
    tolb: *mut f32,
    k: *mut lapackint,
    l: *mut lapackint,
    u: *mut f32,
    ldu: *const lapackint,
    v: *mut f32,
    ldv: *const lapackint,
    q: *mut f32,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    tau: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zggsvp,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    a: *mut Complex64,
    lda: *const lapackint,
    b: *mut Complex64,
    ldb: *const lapackint,
    tola: *mut f64,
    tolb: *mut f64,
    k: *mut lapackint,
    l: *mut lapackint,
    u: *mut Complex64,
    ldu: *const lapackint,
    v: *mut Complex64,
    ldv: *const lapackint,
    q: *mut Complex64,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    rwork: *mut f64,
    tau: *mut Complex64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GGSVP3
export_fortran_symbol!(cggsvp3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    tola: *const f32,
    tolb: *const f32,
    k: *mut lapackint,
    l: *mut lapackint,
    U: *mut Complex32,
    ldu: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    rwork: *mut f32,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dggsvp3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    tola: *const f64,
    tolb: *const f64,
    k: *mut lapackint,
    l: *mut lapackint,
    U: *mut f64,
    ldu: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sggsvp3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    tola: *const f32,
    tolb: *const f32,
    k: *mut lapackint,
    l: *mut lapackint,
    U: *mut f32,
    ldu: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zggsvp3,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    tola: *const f64,
    tolb: *const f64,
    k: *mut lapackint,
    l: *mut lapackint,
    U: *mut Complex64,
    ldu: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    iwork: *mut lapackint,
    rwork: *mut f64,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// GTCON
export_fortran_symbol!(cgtcon,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const Complex32,
    D: *const Complex32,
    DU: *const Complex32,
    DU2: *const Complex32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgtcon,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const f64,
    D: *const f64,
    DU: *const f64,
    DU2: *const f64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgtcon,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const f32,
    D: *const f32,
    DU: *const f32,
    DU2: *const f32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgtcon,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const Complex64,
    D: *const Complex64,
    DU: *const Complex64,
    DU2: *const Complex64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// GTRFS
export_fortran_symbol!(cgtrfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex32,
    D: *const Complex32,
    DU: *const Complex32,
    DLF: *const Complex32,
    DF: *const Complex32,
    DUF: *const Complex32,
    DU2: *const Complex32,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgtrfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f64,
    D: *const f64,
    DU: *const f64,
    DLF: *const f64,
    DF: *const f64,
    DUF: *const f64,
    DU2: *const f64,
    ipiv: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgtrfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f32,
    D: *const f32,
    DU: *const f32,
    DLF: *const f32,
    DF: *const f32,
    DUF: *const f32,
    DU2: *const f32,
    ipiv: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgtrfs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex64,
    D: *const Complex64,
    DU: *const Complex64,
    DLF: *const Complex64,
    DF: *const Complex64,
    DUF: *const Complex64,
    DU2: *const Complex64,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GTSV
export_fortran_symbol!(cgtsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *mut Complex32,
    D: *mut Complex32,
    DU: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgtsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *mut f64,
    D: *mut f64,
    DU: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgtsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *mut f32,
    D: *mut f32,
    DU: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgtsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *mut Complex64,
    D: *mut Complex64,
    DU: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// GTSVX
export_fortran_symbol!(cgtsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex32,
    D: *const Complex32,
    DU: *const Complex32,
    DLF: *mut Complex32,
    DF: *mut Complex32,
    DUF: *mut Complex32,
    DU2: *mut Complex32,
    ipiv: *mut lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dgtsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f64,
    D: *const f64,
    DU: *const f64,
    DLF: *mut f64,
    DF: *mut f64,
    DUF: *mut f64,
    DU2: *mut f64,
    ipiv: *mut lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgtsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f32,
    D: *const f32,
    DU: *const f32,
    DLF: *mut f32,
    DF: *mut f32,
    DUF: *mut f32,
    DU2: *mut f32,
    ipiv: *mut lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgtsvx,
    fact: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex64,
    D: *const Complex64,
    DU: *const Complex64,
    DLF: *mut Complex64,
    DF: *mut Complex64,
    DUF: *mut Complex64,
    DU2: *mut Complex64,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// GTTRF
export_fortran_symbol!(cgttrf,
    n: *const lapackint,
    DL: *mut Complex32,
    D: *mut Complex32,
    DU: *mut Complex32,
    DU2: *mut Complex32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgttrf,
    n: *const lapackint,
    DL: *mut f64,
    D: *mut f64,
    DU: *mut f64,
    DU2: *mut f64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgttrf,
    n: *const lapackint,
    DL: *mut f32,
    D: *mut f32,
    DU: *mut f32,
    DU2: *mut f32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgttrf,
    n: *const lapackint,
    DL: *mut Complex64,
    D: *mut Complex64,
    DU: *mut Complex64,
    DU2: *mut Complex64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// GTTRS
export_fortran_symbol!(cgttrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex32,
    D: *const Complex32,
    DU: *const Complex32,
    DU2: *const Complex32,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dgttrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f64,
    D: *const f64,
    DU: *const f64,
    DU2: *const f64,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sgttrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const f32,
    D: *const f32,
    DU: *const f32,
    DU2: *const f32,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zgttrs,
    trans: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *const Complex64,
    D: *const Complex64,
    DU: *const Complex64,
    DU2: *const Complex64,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HBEV
export_fortran_symbol!(chbev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HBEV_2STAGE
export_fortran_symbol!(chbev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HBEVD
export_fortran_symbol!(chbevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HBEVD_2STAGE
export_fortran_symbol!(chbevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HBEVX
export_fortran_symbol!(chbevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HBEVX_2STAGE
export_fortran_symbol!(chbevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HBGST
export_fortran_symbol!(chbgst,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    BB: *const Complex32,
    ldbb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbgst,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    BB: *const Complex64,
    ldbb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HBGV
export_fortran_symbol!(chbgv,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    BB: *mut Complex32,
    ldbb: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbgv,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    BB: *mut Complex64,
    ldbb: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HBGVD
export_fortran_symbol!(chbgvd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    BB: *mut Complex32,
    ldbb: *const lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbgvd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    BB: *mut Complex64,
    ldbb: *const lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HBGVX
export_fortran_symbol!(chbgvx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    BB: *mut Complex32,
    ldbb: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbgvx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    BB: *mut Complex64,
    ldbb: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HBTRD
export_fortran_symbol!(chbtrd,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Q: *mut Complex32,
    ldq: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhbtrd,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Q: *mut Complex64,
    ldq: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HECON
export_fortran_symbol!(checon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhecon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HECON_3
export_fortran_symbol!(checon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhecon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HEEQUB
export_fortran_symbol!(cheequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zheequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HEEV
export_fortran_symbol!(cheev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zheev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HEEV_2STAGE
export_fortran_symbol!(cheev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zheev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HEEVD
export_fortran_symbol!(cheevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HEEVD_2STAGE
export_fortran_symbol!(cheevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HEEVR
export_fortran_symbol!(cheevr,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevr,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HEEVR_2STAGE
export_fortran_symbol!(cheevr_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevr_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HEEVX
export_fortran_symbol!(cheevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HEEVX_2STAGE
export_fortran_symbol!(cheevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zheevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HEGST
export_fortran_symbol!(chegst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhegst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HEGV
export_fortran_symbol!(chegv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhegv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HEGV_2STAGE
export_fortran_symbol!(chegv_2stage,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhegv_2stage,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HEGVD
export_fortran_symbol!(chegvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhegvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HEGVX
export_fortran_symbol!(chegvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhegvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HERFS
export_fortran_symbol!(cherfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zherfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HERFSX
export_fortran_symbol!(cherfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zherfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HESV
export_fortran_symbol!(chesv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HESV_AA
export_fortran_symbol!(chesv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HESV_AA_2STAGE
export_fortran_symbol!(chesv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HESV_RK
export_fortran_symbol!(chesv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *mut Complex32,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *mut Complex64,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HESV_ROOK
export_fortran_symbol!(chesv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HESVX
export_fortran_symbol!(chesvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HESVXX
export_fortran_symbol!(chesvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhesvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HESWAPR
export_fortran_symbol!(cheswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

export_fortran_symbol!(zheswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

// HETRD
export_fortran_symbol!(chetrd,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrd,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRD_2STAGE
export_fortran_symbol!(chetrd_2stage,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tau: *mut Complex32,
    HOUS2: *mut Complex32,
    lhous2: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrd_2stage,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tau: *mut Complex64,
    HOUS2: *mut Complex64,
    lhous2: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRF
export_fortran_symbol!(chetrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRF_AA
export_fortran_symbol!(chetrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRF_AA_2STAGE
export_fortran_symbol!(chetrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRF_RK
export_fortran_symbol!(chetrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *mut Complex32,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *mut Complex64,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRF_ROOK
export_fortran_symbol!(chetrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRI
export_fortran_symbol!(chetri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HETRI2
export_fortran_symbol!(chetri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRI2X
export_fortran_symbol!(chetri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    nb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    nb: *const lapackint,
    info: *mut lapackint,
);

// HETRI_3
export_fortran_symbol!(chetri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRS
export_fortran_symbol!(chetrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HETRS2
export_fortran_symbol!(chetrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HETRS_3
export_fortran_symbol!(chetrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HETRS_AA
export_fortran_symbol!(chetrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// HETRS_AA_2STAGE
export_fortran_symbol!(chetrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HETRS_ROOK
export_fortran_symbol!(chetrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhetrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HFRK
export_fortran_symbol!(chfrk,
    transr: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    alpha: *const f32,
    A: *const Complex32,
    lda: *const lapackint,
    beta: *const f32,
    C: *mut Complex32,
);

export_fortran_symbol!(zhfrk,
    transr: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    alpha: *const f64,
    A: *const Complex64,
    lda: *const lapackint,
    beta: *const f64,
    C: *mut Complex64,
);

// HGEQZ
export_fortran_symbol!(chgeqz,
    job: *const c_char,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut Complex32,
    ldh: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    Q: *mut Complex32,
    ldq: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dhgeqz,
    job: *const c_char,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut f64,
    ldh: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    Q: *mut f64,
    ldq: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(shgeqz,
    job: *const c_char,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut f32,
    ldh: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    Q: *mut f32,
    ldq: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhgeqz,
    job: *const c_char,
    compq: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut Complex64,
    ldh: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    Q: *mut Complex64,
    ldq: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HPCON
export_fortran_symbol!(chpcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HPEV
export_fortran_symbol!(chpev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HPEVD
export_fortran_symbol!(chpevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HPEVX
export_fortran_symbol!(chpevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HPGST
export_fortran_symbol!(chpgst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    BP: *const Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpgst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    BP: *const Complex64,
    info: *mut lapackint,
);

// HPGV
export_fortran_symbol!(chpgv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    BP: *mut Complex32,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpgv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    BP: *mut Complex64,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HPGVD
export_fortran_symbol!(chpgvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    BP: *mut Complex32,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpgvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    BP: *mut Complex64,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// HPGVX
export_fortran_symbol!(chpgvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    BP: *mut Complex32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpgvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    BP: *mut Complex64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// HPRFS
export_fortran_symbol!(chprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    AFP: *const Complex32,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    AFP: *const Complex64,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HPSV
export_fortran_symbol!(chpsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex32,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex64,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HPSVX
export_fortran_symbol!(chpsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    AFP: *mut Complex32,
    ipiv: *mut lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhpsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    AFP: *mut Complex64,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// HPTRD
export_fortran_symbol!(chptrd,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    D: *mut f32,
    E: *mut f32,
    tau: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhptrd,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    D: *mut f64,
    E: *mut f64,
    tau: *mut Complex64,
    info: *mut lapackint,
);

// HPTRF
export_fortran_symbol!(chptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// HPTRI
export_fortran_symbol!(chptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zhptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// HPTRS
export_fortran_symbol!(chptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// HSEIN
export_fortran_symbol!(chsein,
    side: *const c_char,
    eigsrc: *const c_char,
    initv: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    H: *const Complex32,
    ldh: *const lapackint,
    W: *mut Complex32,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    IFAILL: *mut lapackint,
    IFAILR: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dhsein,
    side: *const c_char,
    eigsrc: *const c_char,
    initv: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    H: *const f64,
    ldh: *const lapackint,
    WR: *mut f64,
    WI: *const f64,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    IFAILL: *mut lapackint,
    IFAILR: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(shsein,
    side: *const c_char,
    eigsrc: *const c_char,
    initv: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    H: *const f32,
    ldh: *const lapackint,
    WR: *mut f32,
    WI: *const f32,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    IFAILL: *mut lapackint,
    IFAILR: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhsein,
    side: *const c_char,
    eigsrc: *const c_char,
    initv: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    H: *const Complex64,
    ldh: *const lapackint,
    W: *mut Complex64,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    IFAILL: *mut lapackint,
    IFAILR: *mut lapackint,
    info: *mut lapackint,
);

// HSEQR
export_fortran_symbol!(chseqr,
    job: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut Complex32,
    ldh: *const lapackint,
    W: *mut Complex32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dhseqr,
    job: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut f64,
    ldh: *const lapackint,
    WR: *mut f64,
    WI: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(shseqr,
    job: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut f32,
    ldh: *const lapackint,
    WR: *mut f32,
    WI: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zhseqr,
    job: *const c_char,
    compz: *const c_char,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    H: *mut Complex64,
    ldh: *const lapackint,
    W: *mut Complex64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ILAVER
export_fortran_symbol!(ilaver,
    vers_major: *mut lapackint,
    vers_minor: *mut lapackint,
    vers_patch: *mut lapackint,
);

// LACGV
export_fortran_symbol!(clacgv,
    n: *const lapackint,
    X: *mut Complex32,
    incx: *const lapackint,
);

export_fortran_symbol!(zlacgv,
    n: *const lapackint,
    X: *mut Complex64,
    incx: *const lapackint,
);

// LACN2
export_fortran_symbol!(clacn2,
    n: *const lapackint,
    V: *mut Complex32,
    X: *mut Complex32,
    est: *mut f32,
    kase: *mut lapackint,
    ISAVE: *mut lapackint,
);

export_fortran_symbol!(dlacn2,
    n: *const lapackint,
    V: *mut f64,
    X: *mut f64,
    ISGN: *mut lapackint,
    est: *mut f64,
    kase: *mut lapackint,
    ISAVE: *mut lapackint,
);

export_fortran_symbol!(slacn2,
    n: *const lapackint,
    V: *mut f32,
    X: *mut f32,
    ISGN: *mut lapackint,
    est: *mut f32,
    kase: *mut lapackint,
    ISAVE: *mut lapackint,
);

export_fortran_symbol!(zlacn2,
    n: *const lapackint,
    V: *mut Complex64,
    X: *mut Complex64,
    est: *mut f64,
    kase: *mut lapackint,
    ISAVE: *mut lapackint,
);

// LACP2
export_fortran_symbol!(clacp2,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
);

export_fortran_symbol!(zlacp2,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
);

// LACPY
export_fortran_symbol!(clacpy,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
);

export_fortran_symbol!(dlacpy,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
);

export_fortran_symbol!(slacpy,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
);

export_fortran_symbol!(zlacpy,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
);

// LACRM
export_fortran_symbol!(clacrm,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    rwork: *mut f32,
);

export_fortran_symbol!(zlacrm,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    rwork: *mut f64,
);

// LAG2C
export_fortran_symbol!(zlag2c,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    SA: *mut Complex32,
    ldsa: *const lapackint,
    info: *mut lapackint,
);

// LAG2D
export_fortran_symbol!(slag2d,
    m: *const lapackint,
    n: *const lapackint,
    SA: *const f32,
    ldsa: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// LAG2S
export_fortran_symbol!(dlag2s,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    SA: *mut f32,
    ldsa: *const lapackint,
    info: *mut lapackint,
);

// LAG2Z
export_fortran_symbol!(clag2z,
    m: *const lapackint,
    n: *const lapackint,
    SA: *const Complex32,
    ldsa: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// LAGGE
export_fortran_symbol!(clagge,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    D: *const f32,
    A: *mut Complex32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dlagge,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    D: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(slagge,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    D: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zlagge,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    D: *const f64,
    A: *mut Complex64,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// LAGHE
export_fortran_symbol!(claghe,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f32,
    A: *mut Complex32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zlaghe,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f64,
    A: *mut Complex64,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// LAGSY
export_fortran_symbol!(clagsy,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f32,
    A: *mut Complex32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dlagsy,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(slagsy,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zlagsy,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f64,
    A: *mut Complex64,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// LAMCH
export_fortran_symbol!(dlamch,
    cmach: *const c_char,
);

export_fortran_symbol!(slamch,
    cmach: *const c_char,
);

// LANGB
export_fortran_symbol!(clangb,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlangb,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slangb,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlangb,
    norm: *const c_char,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    work: *mut f64,
);

// LANGE
export_fortran_symbol!(clange,
    norm: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlange,
    norm: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slange,
    norm: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlange,
    norm: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    work: *mut f64,
);

// LANGT
export_fortran_symbol!(clangt,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const Complex32,
    D: *const Complex32,
    DU: *const Complex32,
);

export_fortran_symbol!(dlangt,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const f64,
    D: *const f64,
    DU: *const f64,
);

export_fortran_symbol!(slangt,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const f32,
    D: *const f32,
    DU: *const f32,
);

export_fortran_symbol!(zlangt,
    norm: *const c_char,
    n: *const lapackint,
    DL: *const Complex64,
    D: *const Complex64,
    DU: *const Complex64,
);

// LANHB
export_fortran_symbol!(clanhb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlanhb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    work: *mut f64,
);

// LANHE
export_fortran_symbol!(clanhe,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlanhe,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    work: *mut f64,
);

// LANHP
export_fortran_symbol!(clanhp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    work: *mut f32,
);

export_fortran_symbol!(zlanhp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    work: *mut f64,
);

// LANHS
export_fortran_symbol!(clanhs,
    norm: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlanhs,
    norm: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slanhs,
    norm: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlanhs,
    norm: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    work: *mut f64,
);

// LANHT
export_fortran_symbol!(clanht,
    norm: *const c_char,
    n: *const lapackint,
    D: *const f32,
    E: *const Complex32,
);

export_fortran_symbol!(zlanht,
    norm: *const c_char,
    n: *const lapackint,
    D: *const f64,
    E: *const Complex64,
);

// LANSB
export_fortran_symbol!(clansb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlansb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slansb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlansb,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    work: *mut f64,
);

// LANSP
export_fortran_symbol!(clansp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    work: *mut f32,
);

export_fortran_symbol!(dlansp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    work: *mut f64,
);

export_fortran_symbol!(slansp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    work: *mut f32,
);

export_fortran_symbol!(zlansp,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    work: *mut f64,
);

// LANST
export_fortran_symbol!(dlanst,
    norm: *const c_char,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
);

export_fortran_symbol!(slanst,
    norm: *const c_char,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
);

// LANSY
export_fortran_symbol!(clansy,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlansy,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slansy,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlansy,
    norm: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    work: *mut f64,
);

// LANTB
export_fortran_symbol!(clantb,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlantb,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slantb,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlantb,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    work: *mut f64,
);

// LANTP
export_fortran_symbol!(clantp,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    work: *mut f32,
);

export_fortran_symbol!(dlantp,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    work: *mut f64,
);

export_fortran_symbol!(slantp,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    work: *mut f32,
);

export_fortran_symbol!(zlantp,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    work: *mut f64,
);

// LANTR
export_fortran_symbol!(clantr,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(dlantr,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slantr,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlantr,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    work: *mut f64,
);

// LAPMR
export_fortran_symbol!(clapmr,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(dlapmr,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(slapmr,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(zlapmr,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    K: *mut lapackint,
);

// LAPMT
export_fortran_symbol!(clapmt,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(dlapmt,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(slapmt,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    K: *mut lapackint,
);

export_fortran_symbol!(zlapmt,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    K: *mut lapackint,
);

// LAPY2
export_fortran_symbol!(dlapy2,
    x: *const f64,
    y: *const f64,
);

export_fortran_symbol!(slapy2,
    x: *const f32,
    y: *const f32,
);

// LAPY3
export_fortran_symbol!(dlapy3,
    x: *const f64,
    y: *const f64,
    z: *const f64,
);

export_fortran_symbol!(slapy3,
    x: *const f32,
    y: *const f32,
    z: *const f32,
);

// LARCM
export_fortran_symbol!(clarcm,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    rwork: *mut f32,
);

export_fortran_symbol!(zlarcm,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    rwork: *mut f64,
);

// LARF
export_fortran_symbol!(clarf,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const Complex32,
    incv: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
);

export_fortran_symbol!(dlarf,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const f64,
    incv: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slarf,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const f32,
    incv: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlarf,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const Complex64,
    incv: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
);

// LARFB
export_fortran_symbol!(clarfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    ldwork: *const lapackint,
);

export_fortran_symbol!(dlarfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    ldwork: *const lapackint,
);

export_fortran_symbol!(slarfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    ldwork: *const lapackint,
);

export_fortran_symbol!(zlarfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    ldwork: *const lapackint,
);

// LARFG
export_fortran_symbol!(clarfg,
    n: *const lapackint,
    alpha: *mut Complex32,
    X: *mut Complex32,
    incx: *const lapackint,
    tau: *mut Complex32,
);

export_fortran_symbol!(dlarfg,
    n: *const lapackint,
    alpha: *mut f64,
    X: *mut f64,
    incx: *const lapackint,
    tau: *mut f64,
);

export_fortran_symbol!(slarfg,
    n: *const lapackint,
    alpha: *mut f32,
    X: *mut f32,
    incx: *const lapackint,
    tau: *mut f32,
);

export_fortran_symbol!(zlarfg,
    n: *const lapackint,
    alpha: *mut Complex64,
    X: *mut Complex64,
    incx: *const lapackint,
    tau: *mut Complex64,
);

// LARFT
export_fortran_symbol!(clarft,
    direct: *const c_char,
    storev: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    tau: *const Complex32,
    T: *mut Complex32,
    ldt: *const lapackint,
);

export_fortran_symbol!(dlarft,
    direct: *const c_char,
    storev: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    tau: *const f64,
    T: *mut f64,
    ldt: *const lapackint,
);

export_fortran_symbol!(slarft,
    direct: *const c_char,
    storev: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    tau: *const f32,
    T: *mut f32,
    ldt: *const lapackint,
);

export_fortran_symbol!(zlarft,
    direct: *const c_char,
    storev: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    tau: *const Complex64,
    T: *mut Complex64,
    ldt: *const lapackint,
);

// LARFX
export_fortran_symbol!(clarfx,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const Complex32,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
);

export_fortran_symbol!(dlarfx,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const f64,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
);

export_fortran_symbol!(slarfx,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const f32,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
);

export_fortran_symbol!(zlarfx,
    side: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    V: *const Complex64,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
);

// LARNV
export_fortran_symbol!(clarnv,
    idist: *const lapackint,
    iseed: *mut lapackint,
    n: *const lapackint,
    X: *mut Complex32,
);

export_fortran_symbol!(dlarnv,
    idist: *const lapackint,
    iseed: *mut lapackint,
    n: *const lapackint,
    X: *mut f64,
);

export_fortran_symbol!(slarnv,
    idist: *const lapackint,
    iseed: *mut lapackint,
    n: *const lapackint,
    X: *mut f32,
);

export_fortran_symbol!(zlarnv,
    idist: *const lapackint,
    iseed: *mut lapackint,
    n: *const lapackint,
    X: *mut Complex64,
);

// LARTGP
export_fortran_symbol!(dlartgp,
    f: *const f64,
    g: *const f64,
    cs: *mut f64,
    sn: *mut f64,
    r: *mut f64,
);

export_fortran_symbol!(slartgp,
    f: *const f32,
    g: *const f32,
    cs: *mut f32,
    sn: *mut f32,
    r: *mut f32,
);

// LARTGS
export_fortran_symbol!(dlartgs,
    x: *const f64,
    y: *const f64,
    sigma: *const f64,
    cs: *mut f64,
    sn: *mut f64,
);

export_fortran_symbol!(slartgs,
    x: *const f32,
    y: *const f32,
    sigma: *const f32,
    cs: *mut f32,
    sn: *mut f32,
);

// LASCL
export_fortran_symbol!(clascl,
    type_: *const c_char,
    kl: *const lapackint,
    ku: *const lapackint,
    cfrom: *const f32,
    cto: *const f32,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dlascl,
    type_: *const c_char,
    kl: *const lapackint,
    ku: *const lapackint,
    cfrom: *const f64,
    cto: *const f64,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(slascl,
    type_: *const c_char,
    kl: *const lapackint,
    ku: *const lapackint,
    cfrom: *const f32,
    cto: *const f32,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zlascl,
    type_: *const c_char,
    kl: *const lapackint,
    ku: *const lapackint,
    cfrom: *const f64,
    cto: *const f64,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// LASET
export_fortran_symbol!(claset,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const Complex32,
    beta: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
);

export_fortran_symbol!(dlaset,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const f64,
    beta: *const f64,
    A: *mut f64,
    lda: *const lapackint,
);

export_fortran_symbol!(slaset,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const f32,
    beta: *const f32,
    A: *mut f32,
    lda: *const lapackint,
);

export_fortran_symbol!(zlaset,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const Complex64,
    beta: *const Complex64,
    A: *mut Complex64,
    lda: *const lapackint,
);

// LASRT
export_fortran_symbol!(dlasrt,
    id: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(slasrt,
    id: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    info: *mut lapackint,
);

// LASSQ
export_fortran_symbol!(classq,
    n: *const lapackint,
    X: *const Complex32,
    incx: *const lapackint,
    scale: *mut f32,
    sumsq: *mut f32,
);

export_fortran_symbol!(dlassq,
    n: *const lapackint,
    X: *const f64,
    incx: *const lapackint,
    scale: *mut f64,
    sumsq: *mut f64,
);

export_fortran_symbol!(slassq,
    n: *const lapackint,
    X: *const f32,
    incx: *const lapackint,
    scale: *mut f32,
    sumsq: *mut f32,
);

export_fortran_symbol!(zlassq,
    n: *const lapackint,
    X: *const Complex64,
    incx: *const lapackint,
    scale: *mut f64,
    sumsq: *mut f64,
);

// LASWP
export_fortran_symbol!(claswp,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    k1: *const lapackint,
    k2: *const lapackint,
    ipiv: *const lapackint,
    incx: *const lapackint,
);

export_fortran_symbol!(dlaswp,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    k1: *const lapackint,
    k2: *const lapackint,
    ipiv: *const lapackint,
    incx: *const lapackint,
);

export_fortran_symbol!(slaswp,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    k1: *const lapackint,
    k2: *const lapackint,
    ipiv: *const lapackint,
    incx: *const lapackint,
);

export_fortran_symbol!(zlaswp,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    k1: *const lapackint,
    k2: *const lapackint,
    ipiv: *const lapackint,
    incx: *const lapackint,
);

// LATMS
export_fortran_symbol!(clatms,
    m: *const lapackint,
    n: *const lapackint,
    dist: *const c_char,
    iseed: *mut lapackint,
    sym: *const c_char,
    D: *mut f32,
    mode: *const lapackint,
    cond: *const f32,
    dmax: *const f32,
    kl: *const lapackint,
    ku: *const lapackint,
    pack: *const c_char,
    A: *mut Complex32,
    lda: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dlatms,
    m: *const lapackint,
    n: *const lapackint,
    dist: *const c_char,
    iseed: *mut lapackint,
    sym: *const c_char,
    D: *mut f64,
    mode: *const lapackint,
    cond: *const f64,
    dmax: *const f64,
    kl: *const lapackint,
    ku: *const lapackint,
    pack: *const c_char,
    A: *mut f64,
    lda: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(slatms,
    m: *const lapackint,
    n: *const lapackint,
    dist: *const c_char,
    iseed: *mut lapackint,
    sym: *const c_char,
    D: *mut f32,
    mode: *const lapackint,
    cond: *const f32,
    dmax: *const f32,
    kl: *const lapackint,
    ku: *const lapackint,
    pack: *const c_char,
    A: *mut f32,
    lda: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zlatms,
    m: *const lapackint,
    n: *const lapackint,
    dist: *const c_char,
    iseed: *mut lapackint,
    sym: *const c_char,
    D: *mut f64,
    mode: *const lapackint,
    cond: *const f64,
    dmax: *const f64,
    kl: *const lapackint,
    ku: *const lapackint,
    pack: *const c_char,
    A: *mut Complex64,
    lda: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// LAUUM
export_fortran_symbol!(clauum,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dlauum,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(slauum,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zlauum,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// OPGTR
export_fortran_symbol!(dopgtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    tau: *const f64,
    Q: *mut f64,
    ldq: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sopgtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    tau: *const f32,
    Q: *mut f32,
    ldq: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// OPMTR
export_fortran_symbol!(dopmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    AP: *const f64,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sopmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    AP: *const f32,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// ORBDB
export_fortran_symbol!(dorbdb,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f64,
    ldx11: *const lapackint,
    X12: *mut f64,
    ldx12: *const lapackint,
    X21: *mut f64,
    ldx21: *const lapackint,
    X22: *mut f64,
    ldx22: *const lapackint,
    theta: *mut f64,
    phi: *mut f64,
    TAUP1: *mut f64,
    TAUP2: *mut f64,
    TAUQ1: *mut f64,
    TAUQ2: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorbdb,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f32,
    ldx11: *const lapackint,
    X12: *mut f32,
    ldx12: *const lapackint,
    X21: *mut f32,
    ldx21: *const lapackint,
    X22: *mut f32,
    ldx22: *const lapackint,
    theta: *mut f32,
    phi: *mut f32,
    TAUP1: *mut f32,
    TAUP2: *mut f32,
    TAUQ1: *mut f32,
    TAUQ2: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORCSD
export_fortran_symbol!(dorcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f64,
    ldx11: *const lapackint,
    X12: *mut f64,
    ldx12: *const lapackint,
    X21: *mut f64,
    ldx21: *const lapackint,
    X22: *mut f64,
    ldx22: *const lapackint,
    theta: *mut f64,
    U1: *mut f64,
    ldu1: *const lapackint,
    U2: *mut f64,
    ldu2: *const lapackint,
    V1T: *mut f64,
    ldv1t: *const lapackint,
    V2T: *mut f64,
    ldv2t: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorcsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f32,
    ldx11: *const lapackint,
    X12: *mut f32,
    ldx12: *const lapackint,
    X21: *mut f32,
    ldx21: *const lapackint,
    X22: *mut f32,
    ldx22: *const lapackint,
    theta: *mut f32,
    U1: *mut f32,
    ldu1: *const lapackint,
    U2: *mut f32,
    ldu2: *const lapackint,
    V1T: *mut f32,
    ldv1t: *const lapackint,
    V2T: *mut f32,
    ldv2t: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// ORCSD2BY1
export_fortran_symbol!(dorcsd2by1,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f64,
    ldx11: *const lapackint,
    X21: *mut f64,
    ldx21: *const lapackint,
    theta: *mut f64,
    U1: *mut f64,
    ldu1: *const lapackint,
    U2: *mut f64,
    ldu2: *const lapackint,
    V1T: *mut f64,
    ldv1t: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorcsd2by1,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut f32,
    ldx11: *const lapackint,
    X21: *mut f32,
    ldx21: *const lapackint,
    theta: *mut f32,
    U1: *mut f32,
    ldu1: *const lapackint,
    U2: *mut f32,
    ldu2: *const lapackint,
    V1T: *mut f32,
    ldv1t: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// ORGBR
export_fortran_symbol!(dorgbr,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgbr,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGHR
export_fortran_symbol!(dorghr,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorghr,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGLQ
export_fortran_symbol!(dorglq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorglq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGQL
export_fortran_symbol!(dorgql,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgql,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGQR
export_fortran_symbol!(dorgqr,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgqr,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGRQ
export_fortran_symbol!(dorgrq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgrq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGTR
export_fortran_symbol!(dorgtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *const f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *const f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORGTSQR_ROW
export_fortran_symbol!(dorgtsqr_row,
    m: *const lapackint,
    n: *const lapackint,
    mb: *const lapackint,
    nb: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sorgtsqr_row,
    m: *const lapackint,
    n: *const lapackint,
    mb: *const lapackint,
    nb: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMBR
export_fortran_symbol!(dormbr,
    vect: *const c_char,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormbr,
    vect: *const c_char,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMHR
export_fortran_symbol!(dormhr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormhr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMLQ
export_fortran_symbol!(dormlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMQL
export_fortran_symbol!(dormql,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormql,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMQR
export_fortran_symbol!(dormqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMRQ
export_fortran_symbol!(dormrq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormrq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMRZ
export_fortran_symbol!(dormrz,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormrz,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// ORMTR
export_fortran_symbol!(dormtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    tau: *const f64,
    C: *mut f64,
    ldc: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sormtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    tau: *const f32,
    C: *mut f32,
    ldc: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// PBCON
export_fortran_symbol!(cpbcon,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbcon,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbcon,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbcon,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PBEQU
export_fortran_symbol!(cpbequ,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbequ,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spbequ,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbequ,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// PBRFS
export_fortran_symbol!(cpbrfs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    AFB: *const Complex32,
    ldafb: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbrfs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    AFB: *const f64,
    ldafb: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbrfs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    AFB: *const f32,
    ldafb: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbrfs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    AFB: *const Complex64,
    ldafb: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PBSTF
export_fortran_symbol!(cpbstf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbstf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbstf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbstf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    info: *mut lapackint,
);

// PBSV
export_fortran_symbol!(cpbsv,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbsv,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbsv,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbsv,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PBSVX
export_fortran_symbol!(cpbsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    AFB: *mut Complex32,
    ldafb: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    AFB: *mut f64,
    ldafb: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    AFB: *mut f32,
    ldafb: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    AFB: *mut Complex64,
    ldafb: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PBTRF
export_fortran_symbol!(cpbtrf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbtrf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbtrf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbtrf,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex64,
    ldab: *const lapackint,
    info: *mut lapackint,
);

// PBTRS
export_fortran_symbol!(cpbtrs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpbtrs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spbtrs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpbtrs,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PFTRF
export_fortran_symbol!(cpftrf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpftrf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spftrf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpftrf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    info: *mut lapackint,
);

// PFTRI
export_fortran_symbol!(cpftri,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpftri,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spftri,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpftri,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    info: *mut lapackint,
);

// PFTRS
export_fortran_symbol!(cpftrs,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpftrs,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spftrs,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpftrs,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// POCON
export_fortran_symbol!(cpocon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpocon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spocon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpocon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// POEQU
export_fortran_symbol!(cpoequ,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpoequ,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spoequ,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpoequ,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// POEQUB
export_fortran_symbol!(cpoequb,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpoequb,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spoequb,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpoequb,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// PORFS
export_fortran_symbol!(cporfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dporfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sporfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zporfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PORFSX
export_fortran_symbol!(cporfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    S: *mut f32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dporfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    S: *mut f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sporfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    S: *mut f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zporfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    S: *mut f64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// POSV
export_fortran_symbol!(cposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// POSVX
export_fortran_symbol!(cposvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dposvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sposvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zposvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// POSVXX
export_fortran_symbol!(cposvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dposvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sposvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zposvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// POTF2
export_fortran_symbol!(cpotf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpotf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spotf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpotf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRF
export_fortran_symbol!(cpotrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpotrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spotrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpotrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRF2
export_fortran_symbol!(cpotrf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpotrf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spotrf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpotrf2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRI
export_fortran_symbol!(cpotri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpotri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spotri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpotri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRS
export_fortran_symbol!(cpotrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpotrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spotrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpotrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PPCON
export_fortran_symbol!(cppcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dppcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sppcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zppcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PPEQU
export_fortran_symbol!(cppequ,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dppequ,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sppequ,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zppequ,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// PPRFS
export_fortran_symbol!(cpprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    AFP: *const Complex32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    AFP: *const f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    AFP: *const f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    AFP: *const Complex64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PPSV
export_fortran_symbol!(cppsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dppsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sppsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zppsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PPSVX
export_fortran_symbol!(cppsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex32,
    AFP: *mut Complex32,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dppsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f64,
    AFP: *mut f64,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sppsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f32,
    AFP: *mut f32,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zppsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex64,
    AFP: *mut Complex64,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PPTRF
export_fortran_symbol!(cpptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// PPTRI
export_fortran_symbol!(cpptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// PPTRS
export_fortran_symbol!(cpptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PSTRF
export_fortran_symbol!(cpstrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    piv: *mut lapackint,
    rank: *mut lapackint,
    tol: *const f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpstrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    piv: *mut lapackint,
    rank: *mut lapackint,
    tol: *const f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spstrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    piv: *mut lapackint,
    rank: *mut lapackint,
    tol: *const f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpstrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    piv: *mut lapackint,
    rank: *mut lapackint,
    tol: *const f64,
    work: *mut f64,
    info: *mut lapackint,
);

// PTCON
export_fortran_symbol!(cptcon,
    n: *const lapackint,
    D: *const f32,
    E: *const Complex32,
    anorm: *const f32,
    rcond: *mut f32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dptcon,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sptcon,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zptcon,
    n: *const lapackint,
    D: *const f64,
    E: *const Complex64,
    anorm: *const f64,
    rcond: *mut f64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PTEQR
export_fortran_symbol!(cpteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

// PTRFS
export_fortran_symbol!(cptrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const Complex32,
    DF: *const f32,
    EF: *const Complex32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dptrfs,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const f64,
    DF: *const f64,
    EF: *const f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sptrfs,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const f32,
    DF: *const f32,
    EF: *const f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zptrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const Complex64,
    DF: *const f64,
    EF: *const Complex64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PTSV
export_fortran_symbol!(cptsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f32,
    E: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dptsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sptsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zptsv,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f64,
    E: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PTSVX
export_fortran_symbol!(cptsvx,
    fact: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const Complex32,
    DF: *mut f32,
    EF: *mut Complex32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dptsvx,
    fact: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const f64,
    DF: *mut f64,
    EF: *mut f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sptsvx,
    fact: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const f32,
    DF: *mut f32,
    EF: *mut f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zptsvx,
    fact: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const Complex64,
    DF: *mut f64,
    EF: *mut Complex64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PTTRF
export_fortran_symbol!(cpttrf,
    n: *const lapackint,
    D: *mut f32,
    E: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dpttrf,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(spttrf,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zpttrf,
    n: *const lapackint,
    D: *mut f64,
    E: *mut Complex64,
    info: *mut lapackint,
);

// PTTRS
export_fortran_symbol!(cpttrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dpttrs,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(spttrs,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zpttrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SBEV
export_fortran_symbol!(dsbev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SBEV_2STAGE
export_fortran_symbol!(dsbev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SBEVD
export_fortran_symbol!(dsbevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SBEVD_2STAGE
export_fortran_symbol!(dsbevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SBEVX
export_fortran_symbol!(dsbevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SBEVX_2STAGE
export_fortran_symbol!(dsbevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SBGST
export_fortran_symbol!(dsbgst,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    BB: *const f64,
    ldbb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbgst,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    BB: *const f32,
    ldbb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SBGV
export_fortran_symbol!(dsbgv,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    BB: *mut f64,
    ldbb: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbgv,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    BB: *mut f32,
    ldbb: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SBGVD
export_fortran_symbol!(dsbgvd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    BB: *mut f64,
    ldbb: *const lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbgvd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    BB: *mut f32,
    ldbb: *const lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SBGVX
export_fortran_symbol!(dsbgvx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    BB: *mut f64,
    ldbb: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbgvx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ka: *const lapackint,
    kb: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    BB: *mut f32,
    ldbb: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SBTRD
export_fortran_symbol!(dsbtrd,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f64,
    ldab: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Q: *mut f64,
    ldq: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssbtrd,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut f32,
    ldab: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Q: *mut f32,
    ldq: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SFRK
export_fortran_symbol!(dsfrk,
    transr: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    alpha: *const f64,
    A: *const f64,
    lda: *const lapackint,
    beta: *const f64,
    C: *mut f64,
);

export_fortran_symbol!(ssfrk,
    transr: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    n: *const lapackint,
    k: *const lapackint,
    alpha: *const f32,
    A: *const f32,
    lda: *const lapackint,
    beta: *const f32,
    C: *mut f32,
);

// SGESV
export_fortran_symbol!(dsgesv,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    work: *mut f64,
    swork: *mut f32,
    iter: *mut lapackint,
    info: *mut lapackint,
);

// SPCON
export_fortran_symbol!(cspcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dspcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zspcon,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SPEV
export_fortran_symbol!(dspev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sspev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SPEVD
export_fortran_symbol!(dspevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SPEVX
export_fortran_symbol!(dspevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SPGST
export_fortran_symbol!(dspgst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    BP: *const f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sspgst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    BP: *const f32,
    info: *mut lapackint,
);

// SPGV
export_fortran_symbol!(dspgv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    BP: *mut f64,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sspgv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    BP: *mut f32,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// SPGVD
export_fortran_symbol!(dspgvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    BP: *mut f64,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspgvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    BP: *mut f32,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SPGVX
export_fortran_symbol!(dspgvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    BP: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspgvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    BP: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SPOSV
export_fortran_symbol!(dsposv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    work: *mut f64,
    swork: *mut f32,
    iter: *mut lapackint,
    info: *mut lapackint,
);

// SPRFS
export_fortran_symbol!(csprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    AFP: *const Complex32,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    AFP: *const f64,
    ipiv: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    AFP: *const f32,
    ipiv: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsprfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    AFP: *const Complex64,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SPSV
export_fortran_symbol!(cspsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex32,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dspsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f64,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f32,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zspsv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex64,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SPSVX
export_fortran_symbol!(cspsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    AFP: *mut Complex32,
    ipiv: *mut lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dspsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    AFP: *mut f64,
    ipiv: *mut lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sspsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    AFP: *mut f32,
    ipiv: *mut lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zspsvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    AFP: *mut Complex64,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SPTRD
export_fortran_symbol!(dsptrd,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    D: *mut f64,
    E: *mut f64,
    tau: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssptrd,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    D: *mut f32,
    E: *mut f32,
    tau: *mut f32,
    info: *mut lapackint,
);

// SPTRF
export_fortran_symbol!(csptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsptrf,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// SPTRI
export_fortran_symbol!(csptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    ipiv: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    ipiv: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsptri,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SPTRS
export_fortran_symbol!(csptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsptrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// STEBZ
export_fortran_symbol!(dstebz,
    range: *const c_char,
    order: *const c_char,
    n: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    D: *const f64,
    E: *const f64,
    m: *mut lapackint,
    nsplit: *mut lapackint,
    W: *mut f64,
    IBLOCK: *mut lapackint,
    ISPLIT: *mut lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstebz,
    range: *const c_char,
    order: *const c_char,
    n: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    D: *const f32,
    E: *const f32,
    m: *mut lapackint,
    nsplit: *mut lapackint,
    W: *mut f32,
    IBLOCK: *mut lapackint,
    ISPLIT: *mut lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// STEDC
export_fortran_symbol!(cstedc,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dstedc,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstedc,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zstedc,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// STEGR
export_fortran_symbol!(cstegr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dstegr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstegr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zstegr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// STEIN
export_fortran_symbol!(cstein,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
    m: *const lapackint,
    W: *const f32,
    IBLOCK: *const lapackint,
    ISPLIT: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dstein,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
    m: *const lapackint,
    W: *const f64,
    IBLOCK: *const lapackint,
    ISPLIT: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstein,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
    m: *const lapackint,
    W: *const f32,
    IBLOCK: *const lapackint,
    ISPLIT: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zstein,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
    m: *const lapackint,
    W: *const f64,
    IBLOCK: *const lapackint,
    ISPLIT: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// STEMR
export_fortran_symbol!(cstemr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    nzc: *const lapackint,
    ISUPPZ: *mut lapackint,
    tryrac: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dstemr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    nzc: *const lapackint,
    ISUPPZ: *mut lapackint,
    tryrac: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstemr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    nzc: *const lapackint,
    ISUPPZ: *mut lapackint,
    tryrac: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zstemr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    nzc: *const lapackint,
    ISUPPZ: *mut lapackint,
    tryrac: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// STEQR
export_fortran_symbol!(csteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut Complex32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsteqr,
    compz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut Complex64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

// STERF
export_fortran_symbol!(dsterf,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssterf,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    info: *mut lapackint,
);

// STEV
export_fortran_symbol!(dstev,
    jobz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(sstev,
    jobz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

// STEVD
export_fortran_symbol!(dstevd,
    jobz: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstevd,
    jobz: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// STEVR
export_fortran_symbol!(dstevr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstevr,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// STEVX
export_fortran_symbol!(dstevx,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(sstevx,
    jobz: *const c_char,
    range: *const c_char,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SYCON
export_fortran_symbol!(csycon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsycon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssycon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsycon,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYCON_3
export_fortran_symbol!(csycon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsycon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    E: *const f64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssycon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    E: *const f32,
    ipiv: *const lapackint,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsycon_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYCONV
export_fortran_symbol!(csyconv,
    uplo: *const c_char,
    way: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    E: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsyconv,
    uplo: *const c_char,
    way: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    E: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyconv,
    uplo: *const c_char,
    way: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    E: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsyconv,
    uplo: *const c_char,
    way: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    E: *mut Complex64,
    info: *mut lapackint,
);

// SYEQUB
export_fortran_symbol!(csyequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsyequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsyequb,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYEV
export_fortran_symbol!(dsyev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyev,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYEV_2STAGE
export_fortran_symbol!(dsyev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyev_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYEVD
export_fortran_symbol!(dsyevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevd,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SYEVD_2STAGE
export_fortran_symbol!(dsyevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevd_2stage,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SYEVR
export_fortran_symbol!(dsyevr,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevr,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SYEVR_2STAGE
export_fortran_symbol!(dsyevr_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevr_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    ISUPPZ: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SYEVX
export_fortran_symbol!(dsyevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevx,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SYEVX_2STAGE
export_fortran_symbol!(dsyevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyevx_2stage,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SYGST
export_fortran_symbol!(dsygst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssygst,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SYGV
export_fortran_symbol!(dsygv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssygv,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYGV_2STAGE
export_fortran_symbol!(dsygv_2stage,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssygv_2stage,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYGVD
export_fortran_symbol!(dsygvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    W: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssygvd,
    itype: *const lapackint,
    jobz: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    W: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// SYGVX
export_fortran_symbol!(dsygvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    vl: *const f64,
    vu: *const f64,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f64,
    m: *mut lapackint,
    W: *mut f64,
    Z: *mut f64,
    ldz: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssygvx,
    itype: *const lapackint,
    jobz: *const c_char,
    range: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    vl: *const f32,
    vu: *const f32,
    il: *const lapackint,
    iu: *const lapackint,
    abstol: *const f32,
    m: *mut lapackint,
    W: *mut f32,
    Z: *mut f32,
    ldz: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    IFAIL: *mut lapackint,
    info: *mut lapackint,
);

// SYR
export_fortran_symbol!(csyr,
    uplo: *const c_char,
    n: *const lapackint,
    alpha: *const Complex32,
    X: *const Complex32,
    incx: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
);

export_fortran_symbol!(zsyr,
    uplo: *const c_char,
    n: *const lapackint,
    alpha: *const Complex64,
    X: *const Complex64,
    incx: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
);

// SYRFS
export_fortran_symbol!(csyrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsyrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsyrfs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SYRFSX
export_fortran_symbol!(csyrfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *const Complex32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsyrfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *const f64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssyrfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *const f32,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsyrfsx,
    uplo: *const c_char,
    equed: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *const Complex64,
    ldaf: *const lapackint,
    ipiv: *const lapackint,
    S: *mut f64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SYSV
export_fortran_symbol!(csysv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysv,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYSV_AA
export_fortran_symbol!(csysv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysv_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYSV_AA_2STAGE
export_fortran_symbol!(csysv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    TB: *mut f64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    TB: *mut f32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysv_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYSV_RK
export_fortran_symbol!(csysv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *mut Complex32,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    E: *mut f64,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    E: *mut f32,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysv_rk,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *mut Complex64,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYSV_ROOK
export_fortran_symbol!(csysv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysv_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYSVX
export_fortran_symbol!(csysvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysvx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SYSVXX
export_fortran_symbol!(csysvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    AF: *mut Complex32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut Complex32,
    ldb: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsysvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    AF: *mut f64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    X: *mut f64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssysvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    AF: *mut f32,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    X: *mut f32,
    ldx: *const lapackint,
    rcond: *mut f32,
    rpvgrw: *mut f32,
    berr: *mut f32,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f32,
    err_bnds_comp: *mut f32,
    nparams: *const lapackint,
    params: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsysvxx,
    fact: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    AF: *mut Complex64,
    ldaf: *const lapackint,
    ipiv: *mut lapackint,
    equed: *mut c_char,
    S: *mut f64,
    B: *mut Complex64,
    ldb: *const lapackint,
    X: *mut Complex64,
    ldx: *const lapackint,
    rcond: *mut f64,
    rpvgrw: *mut f64,
    berr: *mut f64,
    n_err_bnds: *const lapackint,
    err_bnds_norm: *mut f64,
    err_bnds_comp: *mut f64,
    nparams: *const lapackint,
    params: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// SYSWAPR
export_fortran_symbol!(csyswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

export_fortran_symbol!(dsyswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

export_fortran_symbol!(ssyswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

export_fortran_symbol!(zsyswapr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

// SYTRD
export_fortran_symbol!(dsytrd,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrd,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRD_2STAGE
export_fortran_symbol!(dsytrd_2stage,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    tau: *mut f64,
    HOUS2: *mut f64,
    lhous2: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrd_2stage,
    vect: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    tau: *mut f32,
    HOUS2: *mut f32,
    lhous2: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRF
export_fortran_symbol!(csytrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrf,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRF_AA
export_fortran_symbol!(csytrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrf_aa,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRF_AA_2STAGE
export_fortran_symbol!(csytrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    TB: *mut f64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    TB: *mut f32,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrf_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *mut lapackint,
    ipiv2: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRF_RK
export_fortran_symbol!(csytrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *mut Complex32,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    E: *mut f64,
    ipiv: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    E: *mut f32,
    ipiv: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrf_rk,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *mut Complex64,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRF_ROOK
export_fortran_symbol!(csytrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrf_rook,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRI
export_fortran_symbol!(csytri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytri,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYTRI2
export_fortran_symbol!(csytri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytri2,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRI2X
export_fortran_symbol!(csytri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    nb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f64,
    nb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f32,
    nb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytri2x,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    nb: *const lapackint,
    info: *mut lapackint,
);

// SYTRI_3
export_fortran_symbol!(csytri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    E: *const f64,
    ipiv: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    E: *const f32,
    ipiv: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytri_3,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRS
export_fortran_symbol!(csytrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SYTRS2
export_fortran_symbol!(csytrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs2,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYTRS_3
export_fortran_symbol!(csytrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    E: *const Complex32,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    E: *const f64,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    E: *const f32,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs_3,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    E: *const Complex64,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SYTRS_AA
export_fortran_symbol!(csytrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs_aa,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// SYTRS_AA_2STAGE
export_fortran_symbol!(csytrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    TB: *mut Complex32,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    TB: *mut f64,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    TB: *mut f32,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs_aa_2stage,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    TB: *mut Complex64,
    ltb: *const lapackint,
    ipiv: *const lapackint,
    ipiv2: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// SYTRS_ROOK
export_fortran_symbol!(csytrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dsytrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ssytrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zsytrs_rook,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// TBCON
export_fortran_symbol!(ctbcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtbcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stbcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztbcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TBRFS
export_fortran_symbol!(ctbrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *const Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtbrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *const f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stbrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *const f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztbrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *const Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TBTRS
export_fortran_symbol!(ctbtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex32,
    ldab: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtbtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f64,
    ldab: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stbtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const f32,
    ldab: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztbtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    nrhs: *const lapackint,
    AB: *const Complex64,
    ldab: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// TFSM
export_fortran_symbol!(ctfsm,
    transr: *const c_char,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const Complex32,
    A: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
);

export_fortran_symbol!(dtfsm,
    transr: *const c_char,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const f64,
    A: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
);

export_fortran_symbol!(stfsm,
    transr: *const c_char,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const f32,
    A: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
);

export_fortran_symbol!(ztfsm,
    transr: *const c_char,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const Complex64,
    A: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
);

// TFTRI
export_fortran_symbol!(ctftri,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtftri,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stftri,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztftri,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    info: *mut lapackint,
);

// TFTTP
export_fortran_symbol!(ctfttp,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex32,
    AP: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtfttp,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f64,
    AP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stfttp,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f32,
    AP: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztfttp,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex64,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TFTTR
export_fortran_symbol!(ctfttr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtfttr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stfttr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztfttr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex64,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TGEVC
export_fortran_symbol!(ctgevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    S: *const Complex32,
    lds: *const lapackint,
    P: *const Complex32,
    ldp: *const lapackint,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    S: *const f64,
    lds: *const lapackint,
    P: *const f64,
    ldp: *const lapackint,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stgevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    S: *const f32,
    lds: *const lapackint,
    P: *const f32,
    ldp: *const lapackint,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    S: *const Complex64,
    lds: *const lapackint,
    P: *const Complex64,
    ldp: *const lapackint,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TGEXC
export_fortran_symbol!(ctgexc,
    wantq: *const lapackint,
    wantz: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    ifst: *const lapackint,
    ilst: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgexc,
    wantq: *const lapackint,
    wantz: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    ifst: *mut lapackint,
    ilst: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stgexc,
    wantq: *const lapackint,
    wantz: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    ifst: *mut lapackint,
    ilst: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgexc,
    wantq: *const lapackint,
    wantz: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    ifst: *const lapackint,
    ilst: *mut lapackint,
    info: *mut lapackint,
);

// TGSEN
export_fortran_symbol!(ctgsen,
    ijob: *const lapackint,
    wantq: *const lapackint,
    wantz: *const lapackint,
    select: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    alpha: *mut Complex32,
    beta: *mut Complex32,
    Q: *mut Complex32,
    ldq: *const lapackint,
    Z: *mut Complex32,
    ldz: *const lapackint,
    m: *mut lapackint,
    pl: *mut f32,
    pr: *mut f32,
    DIF: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgsen,
    ijob: *const lapackint,
    wantq: *const lapackint,
    wantz: *const lapackint,
    select: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    alphar: *mut f64,
    alphai: *mut f64,
    beta: *mut f64,
    Q: *mut f64,
    ldq: *const lapackint,
    Z: *mut f64,
    ldz: *const lapackint,
    m: *mut lapackint,
    pl: *mut f64,
    pr: *mut f64,
    DIF: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stgsen,
    ijob: *const lapackint,
    wantq: *const lapackint,
    wantz: *const lapackint,
    select: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    alphar: *mut f32,
    alphai: *mut f32,
    beta: *mut f32,
    Q: *mut f32,
    ldq: *const lapackint,
    Z: *mut f32,
    ldz: *const lapackint,
    m: *mut lapackint,
    pl: *mut f32,
    pr: *mut f32,
    DIF: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgsen,
    ijob: *const lapackint,
    wantq: *const lapackint,
    wantz: *const lapackint,
    select: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    alpha: *mut Complex64,
    beta: *mut Complex64,
    Q: *mut Complex64,
    ldq: *const lapackint,
    Z: *mut Complex64,
    ldz: *const lapackint,
    m: *mut lapackint,
    pl: *mut f64,
    pr: *mut f64,
    DIF: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

// TGSJA
export_fortran_symbol!(ctgsja,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    tola: *const f32,
    tolb: *const f32,
    alpha: *mut f32,
    beta: *mut f32,
    U: *mut Complex32,
    ldu: *const lapackint,
    V: *mut Complex32,
    ldv: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    work: *mut Complex32,
    ncycle: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgsja,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    tola: *const f64,
    tolb: *const f64,
    alpha: *mut f64,
    beta: *mut f64,
    U: *mut f64,
    ldu: *const lapackint,
    V: *mut f64,
    ldv: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    work: *mut f64,
    ncycle: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stgsja,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    tola: *const f32,
    tolb: *const f32,
    alpha: *mut f32,
    beta: *mut f32,
    U: *mut f32,
    ldu: *const lapackint,
    V: *mut f32,
    ldv: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    work: *mut f32,
    ncycle: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgsja,
    jobu: *const c_char,
    jobv: *const c_char,
    jobq: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    tola: *const f64,
    tolb: *const f64,
    alpha: *mut f64,
    beta: *mut f64,
    U: *mut Complex64,
    ldu: *const lapackint,
    V: *mut Complex64,
    ldv: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    work: *mut Complex64,
    ncycle: *mut lapackint,
    info: *mut lapackint,
);

// TGSNA
export_fortran_symbol!(ctgsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    VL: *const Complex32,
    ldvl: *const lapackint,
    VR: *const Complex32,
    ldvr: *const lapackint,
    S: *mut f32,
    DIF: *mut f32,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    VL: *const f64,
    ldvl: *const lapackint,
    VR: *const f64,
    ldvr: *const lapackint,
    S: *mut f64,
    DIF: *mut f64,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stgsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    VL: *const f32,
    ldvl: *const lapackint,
    VR: *const f32,
    ldvr: *const lapackint,
    S: *mut f32,
    DIF: *mut f32,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    VL: *const Complex64,
    ldvl: *const lapackint,
    VR: *const Complex64,
    ldvr: *const lapackint,
    S: *mut f64,
    DIF: *mut f64,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// TGSYL
export_fortran_symbol!(ctgsyl,
    trans: *const c_char,
    ijob: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    D: *const Complex32,
    ldd: *const lapackint,
    E: *const Complex32,
    lde: *const lapackint,
    F: *mut Complex32,
    ldf: *const lapackint,
    dif: *mut f32,
    scale: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtgsyl,
    trans: *const c_char,
    ijob: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    D: *const f64,
    ldd: *const lapackint,
    E: *const f64,
    lde: *const lapackint,
    F: *mut f64,
    ldf: *const lapackint,
    dif: *mut f64,
    scale: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stgsyl,
    trans: *const c_char,
    ijob: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    D: *const f32,
    ldd: *const lapackint,
    E: *const f32,
    lde: *const lapackint,
    F: *mut f32,
    ldf: *const lapackint,
    dif: *mut f32,
    scale: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztgsyl,
    trans: *const c_char,
    ijob: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    D: *const Complex64,
    ldd: *const lapackint,
    E: *const Complex64,
    lde: *const lapackint,
    F: *mut Complex64,
    ldf: *const lapackint,
    dif: *mut f64,
    scale: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// TPCON
export_fortran_symbol!(ctpcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stpcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TPLQT
export_fortran_symbol!(ctplqt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtplqt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stplqt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztplqt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// TPLQT2
export_fortran_symbol!(ctplqt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtplqt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stplqt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztplqt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

// TPMLQT
export_fortran_symbol!(ctpmlqt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpmlqt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stpmlqt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpmlqt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    mb: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// TPMQRT
export_fortran_symbol!(ctpmqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpmqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stpmqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpmqrt,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// TPQRT
export_fortran_symbol!(ctpqrt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpqrt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stpqrt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpqrt,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// TPQRT2
export_fortran_symbol!(ctpqrt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpqrt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stpqrt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpqrt2,
    m: *const lapackint,
    n: *const lapackint,
    l: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    info: *mut lapackint,
);

// TPRFB
export_fortran_symbol!(ctprfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    V: *const Complex32,
    ldv: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    work: *mut Complex32,
    ldwork: *const lapackint,
);

export_fortran_symbol!(dtprfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    V: *const f64,
    ldv: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    work: *mut f64,
    ldwork: *const lapackint,
);

export_fortran_symbol!(stprfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    V: *const f32,
    ldv: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    work: *mut f32,
    ldwork: *const lapackint,
);

export_fortran_symbol!(ztprfb,
    side: *const c_char,
    trans: *const c_char,
    direct: *const c_char,
    storev: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    V: *const Complex64,
    ldv: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    work: *mut Complex64,
    ldwork: *const lapackint,
);

// TPRFS
export_fortran_symbol!(ctprfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *const Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtprfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    B: *const f64,
    ldb: *const lapackint,
    X: *const f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stprfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    B: *const f32,
    ldb: *const lapackint,
    X: *const f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztprfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *const Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TPTRI
export_fortran_symbol!(ctptri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtptri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stptri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztptri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TPTRS
export_fortran_symbol!(ctptrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtptrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stptrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztptrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// TPTTF
export_fortran_symbol!(ctpttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    ARF: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    ARF: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(stpttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    ARF: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    ARF: *mut Complex64,
    info: *mut lapackint,
);

// TPTTR
export_fortran_symbol!(ctpttr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtpttr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stpttr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztpttr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TRCON
export_fortran_symbol!(ctrcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    rcond: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    rcond: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    rcond: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrcon,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    rcond: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TREVC
export_fortran_symbol!(ctrevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(strevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrevc,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TREVC3
export_fortran_symbol!(ctrevc3,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    VL: *mut Complex32,
    ldvl: *const lapackint,
    VR: *mut Complex32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrevc3,
    side: *const c_char,
    howmny: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    VL: *mut f64,
    ldvl: *const lapackint,
    VR: *mut f64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strevc3,
    side: *const c_char,
    howmny: *const c_char,
    select: *mut lapackint,
    n: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    VL: *mut f32,
    ldvl: *const lapackint,
    VR: *mut f32,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrevc3,
    side: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    VL: *mut Complex64,
    ldvl: *const lapackint,
    VR: *mut Complex64,
    ldvr: *const lapackint,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    info: *mut lapackint,
);

// TREXC
export_fortran_symbol!(ctrexc,
    compq: *const c_char,
    n: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    ifst: *const lapackint,
    ilst: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrexc,
    compq: *const c_char,
    n: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    ifst: *mut lapackint,
    ilst: *mut lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(strexc,
    compq: *const c_char,
    n: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    ifst: *mut lapackint,
    ilst: *mut lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrexc,
    compq: *const c_char,
    n: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    ifst: *const lapackint,
    ilst: *const lapackint,
    info: *mut lapackint,
);

// TRRFS
export_fortran_symbol!(ctrrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    X: *const Complex32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut Complex32,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    X: *const f64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut f64,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    X: *const f32,
    ldx: *const lapackint,
    ferr: *mut f32,
    berr: *mut f32,
    work: *mut f32,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrrfs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    X: *const Complex64,
    ldx: *const lapackint,
    ferr: *mut f64,
    berr: *mut f64,
    work: *mut Complex64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TRSEN
export_fortran_symbol!(ctrsen,
    job: *const c_char,
    compq: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    Q: *mut Complex32,
    ldq: *const lapackint,
    W: *mut Complex32,
    m: *mut lapackint,
    s: *mut f32,
    sep: *mut f32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrsen,
    job: *const c_char,
    compq: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut f64,
    ldt: *const lapackint,
    Q: *mut f64,
    ldq: *const lapackint,
    WR: *mut f64,
    WI: *mut f64,
    m: *mut lapackint,
    s: *mut f64,
    sep: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strsen,
    job: *const c_char,
    compq: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut f32,
    ldt: *const lapackint,
    Q: *mut f32,
    ldq: *const lapackint,
    WR: *mut f32,
    WI: *mut f32,
    m: *mut lapackint,
    s: *mut f32,
    sep: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    iwork: *mut lapackint,
    liwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrsen,
    job: *const c_char,
    compq: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *mut Complex64,
    ldt: *const lapackint,
    Q: *mut Complex64,
    ldq: *const lapackint,
    W: *mut Complex64,
    m: *mut lapackint,
    s: *mut f64,
    sep: *mut f64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// TRSNA
export_fortran_symbol!(ctrsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    VL: *const Complex32,
    ldvl: *const lapackint,
    VR: *const Complex32,
    ldvr: *const lapackint,
    S: *mut f32,
    SEP: *mut f32,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex32,
    ldwork: *const lapackint,
    rwork: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *const f64,
    ldt: *const lapackint,
    VL: *const f64,
    ldvl: *const lapackint,
    VR: *const f64,
    ldvr: *const lapackint,
    S: *mut f64,
    SEP: *mut f64,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f64,
    ldwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *const f32,
    ldt: *const lapackint,
    VL: *const f32,
    ldvl: *const lapackint,
    VR: *const f32,
    ldvr: *const lapackint,
    S: *mut f32,
    SEP: *mut f32,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut f32,
    ldwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrsna,
    job: *const c_char,
    howmny: *const c_char,
    select: *const lapackint,
    n: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    VL: *const Complex64,
    ldvl: *const lapackint,
    VR: *const Complex64,
    ldvr: *const lapackint,
    S: *mut f64,
    SEP: *mut f64,
    mm: *const lapackint,
    m: *mut lapackint,
    work: *mut Complex64,
    ldwork: *const lapackint,
    rwork: *mut f64,
    info: *mut lapackint,
);

// TRSYL
export_fortran_symbol!(ctrsyl,
    trana: *const c_char,
    tranb: *const c_char,
    isgn: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *const Complex32,
    ldb: *const lapackint,
    C: *mut Complex32,
    ldc: *const lapackint,
    scale: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrsyl,
    trana: *const c_char,
    tranb: *const c_char,
    isgn: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *const f64,
    ldb: *const lapackint,
    C: *mut f64,
    ldc: *const lapackint,
    scale: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(strsyl,
    trana: *const c_char,
    tranb: *const c_char,
    isgn: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *const f32,
    ldb: *const lapackint,
    C: *mut f32,
    ldc: *const lapackint,
    scale: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrsyl,
    trana: *const c_char,
    tranb: *const c_char,
    isgn: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *const Complex64,
    ldb: *const lapackint,
    C: *mut Complex64,
    ldc: *const lapackint,
    scale: *mut f64,
    info: *mut lapackint,
);

// TRTRI
export_fortran_symbol!(ctrtri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrtri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strtri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrtri,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TRTRS
export_fortran_symbol!(ctrtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(strtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrtrs,
    uplo: *const c_char,
    trans: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// TRTTF
export_fortran_symbol!(ctrttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ARF: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ARF: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(strttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ARF: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrttf,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ARF: *mut Complex64,
    info: *mut lapackint,
);

// TRTTP
export_fortran_symbol!(ctrttp,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(dtrttp,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

export_fortran_symbol!(strttp,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

export_fortran_symbol!(ztrttp,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TZRZF
export_fortran_symbol!(ctzrzf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(dtzrzf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(stzrzf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(ztzrzf,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNBDB
export_fortran_symbol!(cunbdb,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex32,
    ldx11: *const lapackint,
    X12: *mut Complex32,
    ldx12: *const lapackint,
    X21: *mut Complex32,
    ldx21: *const lapackint,
    X22: *mut Complex32,
    ldx22: *const lapackint,
    theta: *mut f32,
    phi: *mut f32,
    TAUP1: *mut Complex32,
    TAUP2: *mut Complex32,
    TAUQ1: *mut Complex32,
    TAUQ2: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunbdb,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex64,
    ldx11: *const lapackint,
    X12: *mut Complex64,
    ldx12: *const lapackint,
    X21: *mut Complex64,
    ldx21: *const lapackint,
    X22: *mut Complex64,
    ldx22: *const lapackint,
    theta: *mut f64,
    phi: *mut f64,
    TAUP1: *mut Complex64,
    TAUP2: *mut Complex64,
    TAUQ1: *mut Complex64,
    TAUQ2: *mut Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNCSD
export_fortran_symbol!(cuncsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex32,
    ldx11: *const lapackint,
    X12: *mut Complex32,
    ldx12: *const lapackint,
    X21: *mut Complex32,
    ldx21: *const lapackint,
    X22: *mut Complex32,
    ldx22: *const lapackint,
    theta: *mut f32,
    U1: *mut Complex32,
    ldu1: *const lapackint,
    U2: *mut Complex32,
    ldu2: *const lapackint,
    V1T: *mut Complex32,
    ldv1t: *const lapackint,
    V2T: *mut Complex32,
    ldv2t: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zuncsd,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    jobv2t: *const c_char,
    trans: *const c_char,
    signs: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex64,
    ldx11: *const lapackint,
    X12: *mut Complex64,
    ldx12: *const lapackint,
    X21: *mut Complex64,
    ldx21: *const lapackint,
    X22: *mut Complex64,
    ldx22: *const lapackint,
    theta: *mut f64,
    U1: *mut Complex64,
    ldu1: *const lapackint,
    U2: *mut Complex64,
    ldu2: *const lapackint,
    V1T: *mut Complex64,
    ldv1t: *const lapackint,
    V2T: *mut Complex64,
    ldv2t: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// UNCSD2BY1
export_fortran_symbol!(cuncsd2by1,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex32,
    ldx11: *const lapackint,
    X21: *mut Complex32,
    ldx21: *const lapackint,
    theta: *mut f32,
    U1: *mut Complex32,
    ldu1: *const lapackint,
    U2: *mut Complex32,
    ldu2: *const lapackint,
    V1T: *mut Complex32,
    ldv1t: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    rwork: *mut f32,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zuncsd2by1,
    jobu1: *const c_char,
    jobu2: *const c_char,
    jobv1t: *const c_char,
    m: *const lapackint,
    p: *const lapackint,
    q: *const lapackint,
    X11: *mut Complex64,
    ldx11: *const lapackint,
    X21: *mut Complex64,
    ldx21: *const lapackint,
    theta: *mut f64,
    U1: *mut Complex64,
    ldu1: *const lapackint,
    U2: *mut Complex64,
    ldu2: *const lapackint,
    V1T: *mut Complex64,
    ldv1t: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    rwork: *mut f64,
    lrwork: *const lapackint,
    iwork: *mut lapackint,
    info: *mut lapackint,
);

// UNGBR
export_fortran_symbol!(cungbr,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungbr,
    vect: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGHR
export_fortran_symbol!(cunghr,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunghr,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGLQ
export_fortran_symbol!(cunglq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunglq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGQL
export_fortran_symbol!(cungql,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungql,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGQR
export_fortran_symbol!(cungqr,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungqr,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGRQ
export_fortran_symbol!(cungrq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungrq,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGTR
export_fortran_symbol!(cungtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNGTSQR_ROW
export_fortran_symbol!(cungtsqr_row,
    m: *const lapackint,
    n: *const lapackint,
    mb: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *const Complex32,
    ldt: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zungtsqr_row,
    m: *const lapackint,
    n: *const lapackint,
    mb: *const lapackint,
    nb: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    T: *const Complex64,
    ldt: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMBR
export_fortran_symbol!(cunmbr,
    vect: *const c_char,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmbr,
    vect: *const c_char,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMHR
export_fortran_symbol!(cunmhr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmhr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    ilo: *const lapackint,
    ihi: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMLQ
export_fortran_symbol!(cunmlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmlq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMQL
export_fortran_symbol!(cunmql,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmql,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMQR
export_fortran_symbol!(cunmqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmqr,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMRQ
export_fortran_symbol!(cunmrq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmrq,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMRZ
export_fortran_symbol!(cunmrz,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmrz,
    side: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    k: *const lapackint,
    l: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UNMTR
export_fortran_symbol!(cunmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

export_fortran_symbol!(zunmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

// UPGTR
export_fortran_symbol!(cupgtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    tau: *const Complex32,
    Q: *mut Complex32,
    ldq: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zupgtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    tau: *const Complex64,
    Q: *mut Complex64,
    ldq: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// UPMTR
export_fortran_symbol!(cupmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    AP: *const Complex32,
    tau: *const Complex32,
    C: *mut Complex32,
    ldc: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

export_fortran_symbol!(zupmtr,
    side: *const c_char,
    uplo: *const c_char,
    trans: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    AP: *const Complex64,
    tau: *const Complex64,
    C: *mut Complex64,
    ldc: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);