lapack-inject 0.1.1

//! Fortran LAPACK function pointer registration.
//!
//! This module provides the infrastructure for registering Fortran LAPACK
//! function pointers at runtime. Each function has its own `OnceLock` to allow
//! partial registration (only register the functions you need).
//!
//! Auto-generated from lapack-sys plus supplemental Netlib LAPACK routines.

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

use std::ffi::c_char;
use std::sync::OnceLock;

use num_complex::{Complex32, Complex64};

use crate::lapackint;

// =============================================================================
// Select function types for eigenvalue routines
// =============================================================================

/// Select function type for real GEES (single)
pub type SSelectFn2 = unsafe extern "C" fn(ar: *const f32, ai: *const f32) -> lapackint;
/// Select function type for real GEES (double)
pub type DSelectFn2 = unsafe extern "C" fn(ar: *const f64, ai: *const f64) -> lapackint;
/// Select function type for real (single) with 3 args
pub type SSelectFn3 = unsafe extern "C" fn(ar: *const f32, ai: *const f32, b: *const f32) -> lapackint;
/// Select function type for real (double) with 3 args
pub type DSelectFn3 = unsafe extern "C" fn(ar: *const f64, ai: *const f64, b: *const f64) -> lapackint;
/// Select function type for complex GEES (single)
pub type CSelectFn1 = unsafe extern "C" fn(w: *const Complex32) -> lapackint;
/// Select function type for complex GEES (double)
pub type ZSelectFn1 = unsafe extern "C" fn(w: *const Complex64) -> lapackint;
/// Select function type for complex (single) with 2 args
pub type CSelectFn2 = unsafe extern "C" fn(a: *const Complex32, b: *const Complex32) -> lapackint;
/// Select function type for complex (double) with 2 args
pub type ZSelectFn2 = unsafe extern "C" fn(a: *const Complex64, b: *const Complex64) -> lapackint;

// =============================================================================
// Macro for defining LAPACK function types, storage, and registration
// =============================================================================

/// Macro to define a LAPACK function pointer type, OnceLock storage,
/// registration function, and getter function.
macro_rules! define_lapack_ffi {
    ($func_name:ident, $type_name:ident, $( $param:ident : $param_ty:ty ),* $(,)?) => {
        paste::paste! {
            /// Fortran function pointer type
            pub type $type_name = unsafe extern "C" fn( $( $param : $param_ty ),* );

            static [<$func_name:upper>]: OnceLock<$type_name> = OnceLock::new();

            #[doc = concat!("Register the Fortran ", stringify!($func_name), " function pointer.")]
            #[no_mangle]
            pub unsafe extern "C" fn [<register_ $func_name>](f: $type_name) {
                let _ = [<$func_name:upper>].set(f);
            }

            #[doc = concat!("Get the registered ", stringify!($func_name), " function pointer.")]
            #[allow(dead_code)]
            pub(crate) fn [<get_ $func_name>]() -> $type_name {
                *[<$func_name:upper>].get().expect(concat!(stringify!($func_name), " not registered"))
            }
        }
    };
}

// BBCSD
define_lapack_ffi!(cbbcsd, CbbcsdFnPtr,
    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,
);

define_lapack_ffi!(dbbcsd, DbbcsdFnPtr,
    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,
);

define_lapack_ffi!(sbbcsd, SbbcsdFnPtr,
    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,
);

define_lapack_ffi!(zbbcsd, ZbbcsdFnPtr,
    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
define_lapack_ffi!(dbdsdc, DbdsdcFnPtr,
    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,
);

define_lapack_ffi!(sbdsdc, SbdsdcFnPtr,
    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
define_lapack_ffi!(cbdsqr, CbdsqrFnPtr,
    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,
);

define_lapack_ffi!(dbdsqr, DbdsqrFnPtr,
    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,
);

define_lapack_ffi!(sbdsqr, SbdsqrFnPtr,
    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,
);

define_lapack_ffi!(zbdsqr, ZbdsqrFnPtr,
    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
define_lapack_ffi!(dbdsvdx, DbdsvdxFnPtr,
    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,
);

define_lapack_ffi!(sbdsvdx, SbdsvdxFnPtr,
    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
define_lapack_ffi!(zcgesv, ZcgesvFnPtr,
    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
define_lapack_ffi!(zcposv, ZcposvFnPtr,
    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
define_lapack_ffi!(ddisna, DdisnaFnPtr,
    job: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    D: *const f64,
    SEP: *mut f64,
    info: *mut lapackint,
);

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

// GBBRD
define_lapack_ffi!(cgbbrd, CgbbrdFnPtr,
    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,
);

define_lapack_ffi!(dgbbrd, DgbbrdFnPtr,
    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,
);

define_lapack_ffi!(sgbbrd, SgbbrdFnPtr,
    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,
);

define_lapack_ffi!(zgbbrd, ZgbbrdFnPtr,
    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
define_lapack_ffi!(cgbcon, CgbconFnPtr,
    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,
);

define_lapack_ffi!(dgbcon, DgbconFnPtr,
    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,
);

define_lapack_ffi!(sgbcon, SgbconFnPtr,
    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,
);

define_lapack_ffi!(zgbcon, ZgbconFnPtr,
    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
define_lapack_ffi!(cgbequ, CgbequFnPtr,
    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,
);

define_lapack_ffi!(dgbequ, DgbequFnPtr,
    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,
);

define_lapack_ffi!(sgbequ, SgbequFnPtr,
    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,
);

define_lapack_ffi!(zgbequ, ZgbequFnPtr,
    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
define_lapack_ffi!(cgbequb, CgbequbFnPtr,
    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,
);

define_lapack_ffi!(dgbequb, DgbequbFnPtr,
    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,
);

define_lapack_ffi!(sgbequb, SgbequbFnPtr,
    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,
);

define_lapack_ffi!(zgbequb, ZgbequbFnPtr,
    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
define_lapack_ffi!(cgbrfs, CgbrfsFnPtr,
    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,
);

define_lapack_ffi!(dgbrfs, DgbrfsFnPtr,
    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,
);

define_lapack_ffi!(sgbrfs, SgbrfsFnPtr,
    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,
);

define_lapack_ffi!(zgbrfs, ZgbrfsFnPtr,
    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
define_lapack_ffi!(cgbrfsx, CgbrfsxFnPtr,
    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,
);

define_lapack_ffi!(dgbrfsx, DgbrfsxFnPtr,
    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,
);

define_lapack_ffi!(sgbrfsx, SgbrfsxFnPtr,
    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,
);

define_lapack_ffi!(zgbrfsx, ZgbrfsxFnPtr,
    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
define_lapack_ffi!(cgbsv, CgbsvFnPtr,
    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,
);

define_lapack_ffi!(dgbsv, DgbsvFnPtr,
    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,
);

define_lapack_ffi!(sgbsv, SgbsvFnPtr,
    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,
);

define_lapack_ffi!(zgbsv, ZgbsvFnPtr,
    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
define_lapack_ffi!(cgbsvx, CgbsvxFnPtr,
    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,
);

define_lapack_ffi!(dgbsvx, DgbsvxFnPtr,
    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,
);

define_lapack_ffi!(sgbsvx, SgbsvxFnPtr,
    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,
);

define_lapack_ffi!(zgbsvx, ZgbsvxFnPtr,
    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
define_lapack_ffi!(cgbsvxx, CgbsvxxFnPtr,
    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,
);

define_lapack_ffi!(dgbsvxx, DgbsvxxFnPtr,
    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,
);

define_lapack_ffi!(sgbsvxx, SgbsvxxFnPtr,
    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,
);

define_lapack_ffi!(zgbsvxx, ZgbsvxxFnPtr,
    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
define_lapack_ffi!(cgbtrf, CgbtrfFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    kl: *const lapackint,
    ku: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

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

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

define_lapack_ffi!(zgbtrf, ZgbtrfFnPtr,
    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
define_lapack_ffi!(cgbtrs, CgbtrsFnPtr,
    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,
);

define_lapack_ffi!(dgbtrs, DgbtrsFnPtr,
    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,
);

define_lapack_ffi!(sgbtrs, SgbtrsFnPtr,
    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,
);

define_lapack_ffi!(zgbtrs, ZgbtrsFnPtr,
    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
define_lapack_ffi!(cgebak, CgebakFnPtr,
    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,
);

define_lapack_ffi!(dgebak, DgebakFnPtr,
    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,
);

define_lapack_ffi!(sgebak, SgebakFnPtr,
    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,
);

define_lapack_ffi!(zgebak, ZgebakFnPtr,
    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
define_lapack_ffi!(cgebal, CgebalFnPtr,
    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,
);

define_lapack_ffi!(dgebal, DgebalFnPtr,
    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,
);

define_lapack_ffi!(sgebal, SgebalFnPtr,
    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,
);

define_lapack_ffi!(zgebal, ZgebalFnPtr,
    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
define_lapack_ffi!(cgebrd, CgebrdFnPtr,
    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,
);

define_lapack_ffi!(dgebrd, DgebrdFnPtr,
    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,
);

define_lapack_ffi!(sgebrd, SgebrdFnPtr,
    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,
);

define_lapack_ffi!(zgebrd, ZgebrdFnPtr,
    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
define_lapack_ffi!(cgecon, CgeconFnPtr,
    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,
);

define_lapack_ffi!(dgecon, DgeconFnPtr,
    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,
);

define_lapack_ffi!(sgecon, SgeconFnPtr,
    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,
);

define_lapack_ffi!(zgecon, ZgeconFnPtr,
    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
define_lapack_ffi!(cgeequ, CgeequFnPtr,
    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,
);

define_lapack_ffi!(dgeequ, DgeequFnPtr,
    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,
);

define_lapack_ffi!(sgeequ, SgeequFnPtr,
    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,
);

define_lapack_ffi!(zgeequ, ZgeequFnPtr,
    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
define_lapack_ffi!(cgeequb, CgeequbFnPtr,
    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,
);

define_lapack_ffi!(dgeequb, DgeequbFnPtr,
    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,
);

define_lapack_ffi!(sgeequb, SgeequbFnPtr,
    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,
);

define_lapack_ffi!(zgeequb, ZgeequbFnPtr,
    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
define_lapack_ffi!(cgees, CgeesFnPtr,
    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,
);

define_lapack_ffi!(dgees, DgeesFnPtr,
    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,
);

define_lapack_ffi!(sgees, SgeesFnPtr,
    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,
);

define_lapack_ffi!(zgees, ZgeesFnPtr,
    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
define_lapack_ffi!(cgeesx, CgeesxFnPtr,
    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,
);

define_lapack_ffi!(dgeesx, DgeesxFnPtr,
    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,
);

define_lapack_ffi!(sgeesx, SgeesxFnPtr,
    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,
);

define_lapack_ffi!(zgeesx, ZgeesxFnPtr,
    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
define_lapack_ffi!(cgeev, CgeevFnPtr,
    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,
);

define_lapack_ffi!(dgeev, DgeevFnPtr,
    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,
);

define_lapack_ffi!(sgeev, SgeevFnPtr,
    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,
);

define_lapack_ffi!(zgeev, ZgeevFnPtr,
    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
define_lapack_ffi!(cgeevx, CgeevxFnPtr,
    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,
);

define_lapack_ffi!(dgeevx, DgeevxFnPtr,
    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,
);

define_lapack_ffi!(sgeevx, SgeevxFnPtr,
    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,
);

define_lapack_ffi!(zgeevx, ZgeevxFnPtr,
    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
define_lapack_ffi!(cgehrd, CgehrdFnPtr,
    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,
);

define_lapack_ffi!(dgehrd, DgehrdFnPtr,
    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,
);

define_lapack_ffi!(sgehrd, SgehrdFnPtr,
    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,
);

define_lapack_ffi!(zgehrd, ZgehrdFnPtr,
    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
define_lapack_ffi!(cgejsv, CgejsvFnPtr,
    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,
);

define_lapack_ffi!(dgejsv, DgejsvFnPtr,
    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,
);

define_lapack_ffi!(sgejsv, SgejsvFnPtr,
    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,
);

define_lapack_ffi!(zgejsv, ZgejsvFnPtr,
    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
define_lapack_ffi!(cgelq, CgelqFnPtr,
    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,
);

define_lapack_ffi!(dgelq, DgelqFnPtr,
    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,
);

define_lapack_ffi!(sgelq, SgelqFnPtr,
    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,
);

define_lapack_ffi!(zgelq, ZgelqFnPtr,
    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
define_lapack_ffi!(cgelq2, Cgelq2FnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

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

define_lapack_ffi!(zgelqf, ZgelqfFnPtr,
    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
define_lapack_ffi!(cgels, CgelsFnPtr,
    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,
);

define_lapack_ffi!(dgels, DgelsFnPtr,
    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,
);

define_lapack_ffi!(sgels, SgelsFnPtr,
    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,
);

define_lapack_ffi!(zgels, ZgelsFnPtr,
    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
define_lapack_ffi!(cgelsd, CgelsdFnPtr,
    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,
);

define_lapack_ffi!(dgelsd, DgelsdFnPtr,
    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,
);

define_lapack_ffi!(sgelsd, SgelsdFnPtr,
    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,
);

define_lapack_ffi!(zgelsd, ZgelsdFnPtr,
    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
define_lapack_ffi!(cgelss, CgelssFnPtr,
    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,
);

define_lapack_ffi!(dgelss, DgelssFnPtr,
    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,
);

define_lapack_ffi!(sgelss, SgelssFnPtr,
    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,
);

define_lapack_ffi!(zgelss, ZgelssFnPtr,
    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
define_lapack_ffi!(cgelsy, CgelsyFnPtr,
    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,
);

define_lapack_ffi!(dgelsy, DgelsyFnPtr,
    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,
);

define_lapack_ffi!(sgelsy, SgelsyFnPtr,
    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,
);

define_lapack_ffi!(zgelsy, ZgelsyFnPtr,
    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
define_lapack_ffi!(cgemlq, CgemlqFnPtr,
    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,
);

define_lapack_ffi!(dgemlq, DgemlqFnPtr,
    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,
);

define_lapack_ffi!(sgemlq, SgemlqFnPtr,
    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,
);

define_lapack_ffi!(zgemlq, ZgemlqFnPtr,
    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
define_lapack_ffi!(cgemqr, CgemqrFnPtr,
    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,
);

define_lapack_ffi!(dgemqr, DgemqrFnPtr,
    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,
);

define_lapack_ffi!(sgemqr, SgemqrFnPtr,
    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,
);

define_lapack_ffi!(zgemqr, ZgemqrFnPtr,
    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
define_lapack_ffi!(cgemqrt, CgemqrtFnPtr,
    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,
);

define_lapack_ffi!(dgemqrt, DgemqrtFnPtr,
    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,
);

define_lapack_ffi!(sgemqrt, SgemqrtFnPtr,
    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,
);

define_lapack_ffi!(zgemqrt, ZgemqrtFnPtr,
    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
define_lapack_ffi!(cgeql2, Cgeql2FnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

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

define_lapack_ffi!(zgeqlf, ZgeqlfFnPtr,
    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
define_lapack_ffi!(cgeqp3, Cgeqp3FnPtr,
    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,
);

define_lapack_ffi!(dgeqp3, Dgeqp3FnPtr,
    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,
);

define_lapack_ffi!(sgeqp3, Sgeqp3FnPtr,
    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,
);

define_lapack_ffi!(zgeqp3, Zgeqp3FnPtr,
    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
define_lapack_ffi!(cgeqpf, CgeqpfFnPtr,
    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,
);

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

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

define_lapack_ffi!(zgeqpf, ZgeqpfFnPtr,
    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
define_lapack_ffi!(cgeqr, CgeqrFnPtr,
    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,
);

define_lapack_ffi!(dgeqr, DgeqrFnPtr,
    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,
);

define_lapack_ffi!(sgeqr, SgeqrFnPtr,
    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,
);

define_lapack_ffi!(zgeqr, ZgeqrFnPtr,
    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
define_lapack_ffi!(cgeqr2, Cgeqr2FnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

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

define_lapack_ffi!(zgeqrf, ZgeqrfFnPtr,
    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
define_lapack_ffi!(cgeqrfp, CgeqrfpFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

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

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

define_lapack_ffi!(zgeqrfp, ZgeqrfpFnPtr,
    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
define_lapack_ffi!(cgeqrt, CgeqrtFnPtr,
    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,
);

define_lapack_ffi!(dgeqrt, DgeqrtFnPtr,
    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,
);

define_lapack_ffi!(sgeqrt, SgeqrtFnPtr,
    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,
);

define_lapack_ffi!(zgeqrt, ZgeqrtFnPtr,
    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
define_lapack_ffi!(cgeqrt2, Cgeqrt2FnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    T: *mut Complex32,
    ldt: *const lapackint,
    info: *mut lapackint,
);

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

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

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

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

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

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

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

// GERFS
define_lapack_ffi!(cgerfs, CgerfsFnPtr,
    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,
);

define_lapack_ffi!(dgerfs, DgerfsFnPtr,
    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,
);

define_lapack_ffi!(sgerfs, SgerfsFnPtr,
    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,
);

define_lapack_ffi!(zgerfs, ZgerfsFnPtr,
    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
define_lapack_ffi!(cgerfsx, CgerfsxFnPtr,
    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,
);

define_lapack_ffi!(dgerfsx, DgerfsxFnPtr,
    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,
);

define_lapack_ffi!(sgerfsx, SgerfsxFnPtr,
    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,
);

define_lapack_ffi!(zgerfsx, ZgerfsxFnPtr,
    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
define_lapack_ffi!(cgerq2, Cgerq2FnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

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

define_lapack_ffi!(zgerqf, ZgerqfFnPtr,
    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
define_lapack_ffi!(cgesc2, Cgesc2FnPtr,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    rhs: *mut Complex32,
    ipiv: *const lapackint,
    jpiv: *const lapackint,
    scale: *mut f32,
);

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

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

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

// GESDD
define_lapack_ffi!(cgesdd, CgesddFnPtr,
    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,
);

define_lapack_ffi!(dgesdd, DgesddFnPtr,
    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,
);

define_lapack_ffi!(sgesdd, SgesddFnPtr,
    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,
);

define_lapack_ffi!(zgesdd, ZgesddFnPtr,
    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
define_lapack_ffi!(cgesv, CgesvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

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

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

define_lapack_ffi!(zgesv, ZgesvFnPtr,
    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
define_lapack_ffi!(cgesvd, CgesvdFnPtr,
    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,
);

define_lapack_ffi!(dgesvd, DgesvdFnPtr,
    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,
);

define_lapack_ffi!(sgesvd, SgesvdFnPtr,
    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,
);

define_lapack_ffi!(zgesvd, ZgesvdFnPtr,
    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
define_lapack_ffi!(cgesvdq, CgesvdqFnPtr,
    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,
);

define_lapack_ffi!(dgesvdq, DgesvdqFnPtr,
    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,
);

define_lapack_ffi!(sgesvdq, SgesvdqFnPtr,
    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,
);

define_lapack_ffi!(zgesvdq, ZgesvdqFnPtr,
    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
define_lapack_ffi!(cgesvdx, CgesvdxFnPtr,
    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,
);

define_lapack_ffi!(dgesvdx, DgesvdxFnPtr,
    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,
);

define_lapack_ffi!(sgesvdx, SgesvdxFnPtr,
    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,
);

define_lapack_ffi!(zgesvdx, ZgesvdxFnPtr,
    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
define_lapack_ffi!(cgesvj, CgesvjFnPtr,
    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,
);

define_lapack_ffi!(dgesvj, DgesvjFnPtr,
    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,
);

define_lapack_ffi!(sgesvj, SgesvjFnPtr,
    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,
);

define_lapack_ffi!(zgesvj, ZgesvjFnPtr,
    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
define_lapack_ffi!(cgesvx, CgesvxFnPtr,
    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,
);

define_lapack_ffi!(dgesvx, DgesvxFnPtr,
    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,
);

define_lapack_ffi!(sgesvx, SgesvxFnPtr,
    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,
);

define_lapack_ffi!(zgesvx, ZgesvxFnPtr,
    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
define_lapack_ffi!(cgesvxx, CgesvxxFnPtr,
    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,
);

define_lapack_ffi!(dgesvxx, DgesvxxFnPtr,
    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,
);

define_lapack_ffi!(sgesvxx, SgesvxxFnPtr,
    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,
);

define_lapack_ffi!(zgesvxx, ZgesvxxFnPtr,
    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
define_lapack_ffi!(cgetc2, Cgetc2FnPtr,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *mut lapackint,
    jpiv: *mut lapackint,
    info: *mut lapackint,
);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GETRS
define_lapack_ffi!(cgetrs, CgetrsFnPtr,
    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,
);

define_lapack_ffi!(dgetrs, DgetrsFnPtr,
    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,
);

define_lapack_ffi!(sgetrs, SgetrsFnPtr,
    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,
);

define_lapack_ffi!(zgetrs, ZgetrsFnPtr,
    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
define_lapack_ffi!(cgetsls, CgetslsFnPtr,
    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,
);

define_lapack_ffi!(dgetsls, DgetslsFnPtr,
    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,
);

define_lapack_ffi!(sgetsls, SgetslsFnPtr,
    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,
);

define_lapack_ffi!(zgetsls, ZgetslsFnPtr,
    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
define_lapack_ffi!(cgetsqrhrt, CgetsqrhrtFnPtr,
    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,
);

define_lapack_ffi!(dgetsqrhrt, DgetsqrhrtFnPtr,
    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,
);

define_lapack_ffi!(sgetsqrhrt, SgetsqrhrtFnPtr,
    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,
);

define_lapack_ffi!(zgetsqrhrt, ZgetsqrhrtFnPtr,
    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
define_lapack_ffi!(cggbak, CggbakFnPtr,
    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,
);

define_lapack_ffi!(dggbak, DggbakFnPtr,
    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,
);

define_lapack_ffi!(sggbak, SggbakFnPtr,
    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,
);

define_lapack_ffi!(zggbak, ZggbakFnPtr,
    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
define_lapack_ffi!(cggbal, CggbalFnPtr,
    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,
);

define_lapack_ffi!(dggbal, DggbalFnPtr,
    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,
);

define_lapack_ffi!(sggbal, SggbalFnPtr,
    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,
);

define_lapack_ffi!(zggbal, ZggbalFnPtr,
    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
define_lapack_ffi!(cgges, CggesFnPtr,
    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,
);

define_lapack_ffi!(dgges, DggesFnPtr,
    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,
);

define_lapack_ffi!(sgges, SggesFnPtr,
    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,
);

define_lapack_ffi!(zgges, ZggesFnPtr,
    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
define_lapack_ffi!(cgges3, Cgges3FnPtr,
    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,
);

define_lapack_ffi!(dgges3, Dgges3FnPtr,
    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,
);

define_lapack_ffi!(sgges3, Sgges3FnPtr,
    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,
);

define_lapack_ffi!(zgges3, Zgges3FnPtr,
    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
define_lapack_ffi!(cggesx, CggesxFnPtr,
    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,
);

define_lapack_ffi!(dggesx, DggesxFnPtr,
    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,
);

define_lapack_ffi!(sggesx, SggesxFnPtr,
    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,
);

define_lapack_ffi!(zggesx, ZggesxFnPtr,
    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
define_lapack_ffi!(cggev, CggevFnPtr,
    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,
);

define_lapack_ffi!(dggev, DggevFnPtr,
    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,
);

define_lapack_ffi!(sggev, SggevFnPtr,
    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,
);

define_lapack_ffi!(zggev, ZggevFnPtr,
    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
define_lapack_ffi!(cggev3, Cggev3FnPtr,
    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,
);

define_lapack_ffi!(dggev3, Dggev3FnPtr,
    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,
);

define_lapack_ffi!(sggev3, Sggev3FnPtr,
    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,
);

define_lapack_ffi!(zggev3, Zggev3FnPtr,
    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
define_lapack_ffi!(cggevx, CggevxFnPtr,
    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,
);

define_lapack_ffi!(dggevx, DggevxFnPtr,
    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,
);

define_lapack_ffi!(sggevx, SggevxFnPtr,
    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,
);

define_lapack_ffi!(zggevx, ZggevxFnPtr,
    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
define_lapack_ffi!(cggglm, CggglmFnPtr,
    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,
);

define_lapack_ffi!(dggglm, DggglmFnPtr,
    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,
);

define_lapack_ffi!(sggglm, SggglmFnPtr,
    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,
);

define_lapack_ffi!(zggglm, ZggglmFnPtr,
    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
define_lapack_ffi!(cgghd3, Cgghd3FnPtr,
    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,
);

define_lapack_ffi!(dgghd3, Dgghd3FnPtr,
    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,
);

define_lapack_ffi!(sgghd3, Sgghd3FnPtr,
    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,
);

define_lapack_ffi!(zgghd3, Zgghd3FnPtr,
    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
define_lapack_ffi!(cgghrd, CgghrdFnPtr,
    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,
);

define_lapack_ffi!(dgghrd, DgghrdFnPtr,
    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,
);

define_lapack_ffi!(sgghrd, SgghrdFnPtr,
    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,
);

define_lapack_ffi!(zgghrd, ZgghrdFnPtr,
    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
define_lapack_ffi!(cgglse, CgglseFnPtr,
    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,
);

define_lapack_ffi!(dgglse, DgglseFnPtr,
    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,
);

define_lapack_ffi!(sgglse, SgglseFnPtr,
    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,
);

define_lapack_ffi!(zgglse, ZgglseFnPtr,
    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
define_lapack_ffi!(cggqrf, CggqrfFnPtr,
    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,
);

define_lapack_ffi!(dggqrf, DggqrfFnPtr,
    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,
);

define_lapack_ffi!(sggqrf, SggqrfFnPtr,
    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,
);

define_lapack_ffi!(zggqrf, ZggqrfFnPtr,
    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
define_lapack_ffi!(cggrqf, CggrqfFnPtr,
    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,
);

define_lapack_ffi!(dggrqf, DggrqfFnPtr,
    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,
);

define_lapack_ffi!(sggrqf, SggrqfFnPtr,
    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,
);

define_lapack_ffi!(zggrqf, ZggrqfFnPtr,
    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
define_lapack_ffi!(cggsvd, CggsvdFnPtr,
    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,
);

define_lapack_ffi!(dggsvd, DggsvdFnPtr,
    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,
);

define_lapack_ffi!(sggsvd, SggsvdFnPtr,
    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,
);

define_lapack_ffi!(zggsvd, ZggsvdFnPtr,
    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
define_lapack_ffi!(cggsvd3, Cggsvd3FnPtr,
    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,
);

define_lapack_ffi!(dggsvd3, Dggsvd3FnPtr,
    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,
);

define_lapack_ffi!(sggsvd3, Sggsvd3FnPtr,
    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,
);

define_lapack_ffi!(zggsvd3, Zggsvd3FnPtr,
    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
define_lapack_ffi!(cggsvp, CggsvpFnPtr,
    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,
);

define_lapack_ffi!(dggsvp, DggsvpFnPtr,
    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,
);

define_lapack_ffi!(sggsvp, SggsvpFnPtr,
    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,
);

define_lapack_ffi!(zggsvp, ZggsvpFnPtr,
    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
define_lapack_ffi!(cggsvp3, Cggsvp3FnPtr,
    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,
);

define_lapack_ffi!(dggsvp3, Dggsvp3FnPtr,
    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,
);

define_lapack_ffi!(sggsvp3, Sggsvp3FnPtr,
    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,
);

define_lapack_ffi!(zggsvp3, Zggsvp3FnPtr,
    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
define_lapack_ffi!(cgtcon, CgtconFnPtr,
    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,
);

define_lapack_ffi!(dgtcon, DgtconFnPtr,
    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,
);

define_lapack_ffi!(sgtcon, SgtconFnPtr,
    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,
);

define_lapack_ffi!(zgtcon, ZgtconFnPtr,
    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
define_lapack_ffi!(cgtrfs, CgtrfsFnPtr,
    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,
);

define_lapack_ffi!(dgtrfs, DgtrfsFnPtr,
    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,
);

define_lapack_ffi!(sgtrfs, SgtrfsFnPtr,
    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,
);

define_lapack_ffi!(zgtrfs, ZgtrfsFnPtr,
    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
define_lapack_ffi!(cgtsv, CgtsvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    DL: *mut Complex32,
    D: *mut Complex32,
    DU: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

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

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

define_lapack_ffi!(zgtsv, ZgtsvFnPtr,
    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
define_lapack_ffi!(cgtsvx, CgtsvxFnPtr,
    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,
);

define_lapack_ffi!(dgtsvx, DgtsvxFnPtr,
    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,
);

define_lapack_ffi!(sgtsvx, SgtsvxFnPtr,
    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,
);

define_lapack_ffi!(zgtsvx, ZgtsvxFnPtr,
    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
define_lapack_ffi!(cgttrf, CgttrfFnPtr,
    n: *const lapackint,
    DL: *mut Complex32,
    D: *mut Complex32,
    DU: *mut Complex32,
    DU2: *mut Complex32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

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

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

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

// GTTRS
define_lapack_ffi!(cgttrs, CgttrsFnPtr,
    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,
);

define_lapack_ffi!(dgttrs, DgttrsFnPtr,
    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,
);

define_lapack_ffi!(sgttrs, SgttrsFnPtr,
    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,
);

define_lapack_ffi!(zgttrs, ZgttrsFnPtr,
    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
define_lapack_ffi!(chbev, ChbevFnPtr,
    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,
);

define_lapack_ffi!(zhbev, ZhbevFnPtr,
    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
define_lapack_ffi!(chbev_2stage, Chbev_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhbev_2stage, Zhbev_2stageFnPtr,
    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
define_lapack_ffi!(chbevd, ChbevdFnPtr,
    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,
);

define_lapack_ffi!(zhbevd, ZhbevdFnPtr,
    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
define_lapack_ffi!(chbevd_2stage, Chbevd_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhbevd_2stage, Zhbevd_2stageFnPtr,
    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
define_lapack_ffi!(chbevx, ChbevxFnPtr,
    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,
);

define_lapack_ffi!(zhbevx, ZhbevxFnPtr,
    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
define_lapack_ffi!(chbevx_2stage, Chbevx_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhbevx_2stage, Zhbevx_2stageFnPtr,
    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
define_lapack_ffi!(chbgst, ChbgstFnPtr,
    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,
);

define_lapack_ffi!(zhbgst, ZhbgstFnPtr,
    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
define_lapack_ffi!(chbgv, ChbgvFnPtr,
    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,
);

define_lapack_ffi!(zhbgv, ZhbgvFnPtr,
    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
define_lapack_ffi!(chbgvd, ChbgvdFnPtr,
    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,
);

define_lapack_ffi!(zhbgvd, ZhbgvdFnPtr,
    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
define_lapack_ffi!(chbgvx, ChbgvxFnPtr,
    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,
);

define_lapack_ffi!(zhbgvx, ZhbgvxFnPtr,
    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
define_lapack_ffi!(chbtrd, ChbtrdFnPtr,
    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,
);

define_lapack_ffi!(zhbtrd, ZhbtrdFnPtr,
    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
define_lapack_ffi!(checon, CheconFnPtr,
    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,
);

define_lapack_ffi!(zhecon, ZheconFnPtr,
    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
define_lapack_ffi!(checon_3, Checon_3FnPtr,
    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,
);

define_lapack_ffi!(zhecon_3, Zhecon_3FnPtr,
    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
define_lapack_ffi!(cheequb, CheequbFnPtr,
    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,
);

define_lapack_ffi!(zheequb, ZheequbFnPtr,
    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
define_lapack_ffi!(cheev, CheevFnPtr,
    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,
);

define_lapack_ffi!(zheev, ZheevFnPtr,
    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
define_lapack_ffi!(cheev_2stage, Cheev_2stageFnPtr,
    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,
);

define_lapack_ffi!(zheev_2stage, Zheev_2stageFnPtr,
    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
define_lapack_ffi!(cheevd, CheevdFnPtr,
    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,
);

define_lapack_ffi!(zheevd, ZheevdFnPtr,
    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
define_lapack_ffi!(cheevd_2stage, Cheevd_2stageFnPtr,
    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,
);

define_lapack_ffi!(zheevd_2stage, Zheevd_2stageFnPtr,
    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
define_lapack_ffi!(cheevr, CheevrFnPtr,
    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,
);

define_lapack_ffi!(zheevr, ZheevrFnPtr,
    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
define_lapack_ffi!(cheevr_2stage, Cheevr_2stageFnPtr,
    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,
);

define_lapack_ffi!(zheevr_2stage, Zheevr_2stageFnPtr,
    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
define_lapack_ffi!(cheevx, CheevxFnPtr,
    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,
);

define_lapack_ffi!(zheevx, ZheevxFnPtr,
    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
define_lapack_ffi!(cheevx_2stage, Cheevx_2stageFnPtr,
    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,
);

define_lapack_ffi!(zheevx_2stage, Zheevx_2stageFnPtr,
    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
define_lapack_ffi!(chegst, ChegstFnPtr,
    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,
);

define_lapack_ffi!(zhegst, ZhegstFnPtr,
    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
define_lapack_ffi!(chegv, ChegvFnPtr,
    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,
);

define_lapack_ffi!(zhegv, ZhegvFnPtr,
    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
define_lapack_ffi!(chegv_2stage, Chegv_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhegv_2stage, Zhegv_2stageFnPtr,
    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
define_lapack_ffi!(chegvd, ChegvdFnPtr,
    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,
);

define_lapack_ffi!(zhegvd, ZhegvdFnPtr,
    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
define_lapack_ffi!(chegvx, ChegvxFnPtr,
    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,
);

define_lapack_ffi!(zhegvx, ZhegvxFnPtr,
    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
define_lapack_ffi!(cherfs, CherfsFnPtr,
    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,
);

define_lapack_ffi!(zherfs, ZherfsFnPtr,
    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
define_lapack_ffi!(cherfsx, CherfsxFnPtr,
    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,
);

define_lapack_ffi!(zherfsx, ZherfsxFnPtr,
    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
define_lapack_ffi!(chesv, ChesvFnPtr,
    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,
);

define_lapack_ffi!(zhesv, ZhesvFnPtr,
    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
define_lapack_ffi!(chesv_aa, Chesv_aaFnPtr,
    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,
);

define_lapack_ffi!(zhesv_aa, Zhesv_aaFnPtr,
    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
define_lapack_ffi!(chesv_aa_2stage, Chesv_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhesv_aa_2stage, Zhesv_aa_2stageFnPtr,
    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
define_lapack_ffi!(chesv_rk, Chesv_rkFnPtr,
    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,
);

define_lapack_ffi!(zhesv_rk, Zhesv_rkFnPtr,
    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
define_lapack_ffi!(chesv_rook, Chesv_rookFnPtr,
    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,
);

define_lapack_ffi!(zhesv_rook, Zhesv_rookFnPtr,
    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
define_lapack_ffi!(chesvx, ChesvxFnPtr,
    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,
);

define_lapack_ffi!(zhesvx, ZhesvxFnPtr,
    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
define_lapack_ffi!(chesvxx, ChesvxxFnPtr,
    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,
);

define_lapack_ffi!(zhesvxx, ZhesvxxFnPtr,
    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
define_lapack_ffi!(cheswapr, CheswaprFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

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

// HETRD
define_lapack_ffi!(chetrd, ChetrdFnPtr,
    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,
);

define_lapack_ffi!(zhetrd, ZhetrdFnPtr,
    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
define_lapack_ffi!(chetrd_2stage, Chetrd_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhetrd_2stage, Zhetrd_2stageFnPtr,
    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
define_lapack_ffi!(chetrf, ChetrfFnPtr,
    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,
);

define_lapack_ffi!(zhetrf, ZhetrfFnPtr,
    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
define_lapack_ffi!(chetrf_aa, Chetrf_aaFnPtr,
    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,
);

define_lapack_ffi!(zhetrf_aa, Zhetrf_aaFnPtr,
    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
define_lapack_ffi!(chetrf_aa_2stage, Chetrf_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhetrf_aa_2stage, Zhetrf_aa_2stageFnPtr,
    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
define_lapack_ffi!(chetrf_rk, Chetrf_rkFnPtr,
    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,
);

define_lapack_ffi!(zhetrf_rk, Zhetrf_rkFnPtr,
    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
define_lapack_ffi!(chetrf_rook, Chetrf_rookFnPtr,
    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,
);

define_lapack_ffi!(zhetrf_rook, Zhetrf_rookFnPtr,
    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
define_lapack_ffi!(chetri, ChetriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

// HETRI2
define_lapack_ffi!(chetri2, Chetri2FnPtr,
    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,
);

define_lapack_ffi!(zhetri2, Zhetri2FnPtr,
    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
define_lapack_ffi!(chetri2x, Chetri2xFnPtr,
    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,
);

define_lapack_ffi!(zhetri2x, Zhetri2xFnPtr,
    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
define_lapack_ffi!(chetri_3, Chetri_3FnPtr,
    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,
);

define_lapack_ffi!(zhetri_3, Zhetri_3FnPtr,
    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
define_lapack_ffi!(chetrs, ChetrsFnPtr,
    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,
);

define_lapack_ffi!(zhetrs, ZhetrsFnPtr,
    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
define_lapack_ffi!(chetrs2, Chetrs2FnPtr,
    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,
);

define_lapack_ffi!(zhetrs2, Zhetrs2FnPtr,
    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
define_lapack_ffi!(chetrs_3, Chetrs_3FnPtr,
    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,
);

define_lapack_ffi!(zhetrs_3, Zhetrs_3FnPtr,
    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
define_lapack_ffi!(chetrs_aa, Chetrs_aaFnPtr,
    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,
);

define_lapack_ffi!(zhetrs_aa, Zhetrs_aaFnPtr,
    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
define_lapack_ffi!(chetrs_aa_2stage, Chetrs_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zhetrs_aa_2stage, Zhetrs_aa_2stageFnPtr,
    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
define_lapack_ffi!(chetrs_rook, Chetrs_rookFnPtr,
    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,
);

define_lapack_ffi!(zhetrs_rook, Zhetrs_rookFnPtr,
    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
define_lapack_ffi!(chfrk, ChfrkFnPtr,
    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,
);

define_lapack_ffi!(zhfrk, ZhfrkFnPtr,
    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
define_lapack_ffi!(chgeqz, ChgeqzFnPtr,
    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,
);

define_lapack_ffi!(dhgeqz, DhgeqzFnPtr,
    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,
);

define_lapack_ffi!(shgeqz, ShgeqzFnPtr,
    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,
);

define_lapack_ffi!(zhgeqz, ZhgeqzFnPtr,
    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
define_lapack_ffi!(chpcon, ChpconFnPtr,
    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,
);

define_lapack_ffi!(zhpcon, ZhpconFnPtr,
    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
define_lapack_ffi!(chpev, ChpevFnPtr,
    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,
);

define_lapack_ffi!(zhpev, ZhpevFnPtr,
    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
define_lapack_ffi!(chpevd, ChpevdFnPtr,
    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,
);

define_lapack_ffi!(zhpevd, ZhpevdFnPtr,
    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
define_lapack_ffi!(chpevx, ChpevxFnPtr,
    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,
);

define_lapack_ffi!(zhpevx, ZhpevxFnPtr,
    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
define_lapack_ffi!(chpgst, ChpgstFnPtr,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    BP: *const Complex32,
    info: *mut lapackint,
);

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

// HPGV
define_lapack_ffi!(chpgv, ChpgvFnPtr,
    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,
);

define_lapack_ffi!(zhpgv, ZhpgvFnPtr,
    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
define_lapack_ffi!(chpgvd, ChpgvdFnPtr,
    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,
);

define_lapack_ffi!(zhpgvd, ZhpgvdFnPtr,
    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
define_lapack_ffi!(chpgvx, ChpgvxFnPtr,
    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,
);

define_lapack_ffi!(zhpgvx, ZhpgvxFnPtr,
    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
define_lapack_ffi!(chprfs, ChprfsFnPtr,
    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,
);

define_lapack_ffi!(zhprfs, ZhprfsFnPtr,
    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
define_lapack_ffi!(chpsv, ChpsvFnPtr,
    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,
);

define_lapack_ffi!(zhpsv, ZhpsvFnPtr,
    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
define_lapack_ffi!(chpsvx, ChpsvxFnPtr,
    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,
);

define_lapack_ffi!(zhpsvx, ZhpsvxFnPtr,
    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
define_lapack_ffi!(chptrd, ChptrdFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    D: *mut f32,
    E: *mut f32,
    tau: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

// HPTRS
define_lapack_ffi!(chptrs, ChptrsFnPtr,
    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,
);

define_lapack_ffi!(zhptrs, ZhptrsFnPtr,
    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
define_lapack_ffi!(chsein, ChseinFnPtr,
    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,
);

define_lapack_ffi!(dhsein, DhseinFnPtr,
    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,
);

define_lapack_ffi!(shsein, ShseinFnPtr,
    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,
);

define_lapack_ffi!(zhsein, ZhseinFnPtr,
    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
define_lapack_ffi!(chseqr, ChseqrFnPtr,
    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,
);

define_lapack_ffi!(dhseqr, DhseqrFnPtr,
    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,
);

define_lapack_ffi!(shseqr, ShseqrFnPtr,
    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,
);

define_lapack_ffi!(zhseqr, ZhseqrFnPtr,
    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
define_lapack_ffi!(ilaver, IlaverFnPtr,
    vers_major: *mut lapackint,
    vers_minor: *mut lapackint,
    vers_patch: *mut lapackint,
);

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

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

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

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

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

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

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

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

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

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

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

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

// LACRM
define_lapack_ffi!(clacrm, ClacrmFnPtr,
    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,
);

define_lapack_ffi!(zlacrm, ZlacrmFnPtr,
    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
define_lapack_ffi!(zlag2c, Zlag2cFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    SA: *mut Complex32,
    ldsa: *const lapackint,
    info: *mut lapackint,
);

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

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

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

// LAGGE
define_lapack_ffi!(clagge, ClaggeFnPtr,
    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,
);

define_lapack_ffi!(dlagge, DlaggeFnPtr,
    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,
);

define_lapack_ffi!(slagge, SlaggeFnPtr,
    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,
);

define_lapack_ffi!(zlagge, ZlaggeFnPtr,
    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
define_lapack_ffi!(claghe, ClagheFnPtr,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f32,
    A: *mut Complex32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(zlaghe, ZlagheFnPtr,
    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
define_lapack_ffi!(clagsy, ClagsyFnPtr,
    n: *const lapackint,
    k: *const lapackint,
    D: *const f32,
    A: *mut Complex32,
    lda: *const lapackint,
    iseed: *mut lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

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

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

define_lapack_ffi!(zlagsy, ZlagsyFnPtr,
    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
define_lapack_ffi!(dlamch, DlamchFnPtr,
    cmach: *const c_char,
);

define_lapack_ffi!(slamch, SlamchFnPtr,
    cmach: *const c_char,
);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// LANTB
define_lapack_ffi!(clantb, ClantbFnPtr,
    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,
);

define_lapack_ffi!(dlantb, DlantbFnPtr,
    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,
);

define_lapack_ffi!(slantb, SlantbFnPtr,
    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,
);

define_lapack_ffi!(zlantb, ZlantbFnPtr,
    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
define_lapack_ffi!(clantp, ClantpFnPtr,
    norm: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    work: *mut f32,
);

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

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

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

// LANTR
define_lapack_ffi!(clantr, ClantrFnPtr,
    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,
);

define_lapack_ffi!(dlantr, DlantrFnPtr,
    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,
);

define_lapack_ffi!(slantr, SlantrFnPtr,
    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,
);

define_lapack_ffi!(zlantr, ZlantrFnPtr,
    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
define_lapack_ffi!(clapmr, ClapmrFnPtr,
    forwrd: *const lapackint,
    m: *const lapackint,
    n: *const lapackint,
    X: *mut Complex32,
    ldx: *const lapackint,
    K: *mut lapackint,
);

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

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

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

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

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

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

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

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

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

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

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

// LARCM
define_lapack_ffi!(clarcm, ClarcmFnPtr,
    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,
);

define_lapack_ffi!(zlarcm, ZlarcmFnPtr,
    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
define_lapack_ffi!(clarf, ClarfFnPtr,
    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,
);

define_lapack_ffi!(dlarf, DlarfFnPtr,
    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,
);

define_lapack_ffi!(slarf, SlarfFnPtr,
    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,
);

define_lapack_ffi!(zlarf, ZlarfFnPtr,
    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
define_lapack_ffi!(clarfb, ClarfbFnPtr,
    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,
);

define_lapack_ffi!(dlarfb, DlarfbFnPtr,
    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,
);

define_lapack_ffi!(slarfb, SlarfbFnPtr,
    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,
);

define_lapack_ffi!(zlarfb, ZlarfbFnPtr,
    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
define_lapack_ffi!(clarfg, ClarfgFnPtr,
    n: *const lapackint,
    alpha: *mut Complex32,
    X: *mut Complex32,
    incx: *const lapackint,
    tau: *mut Complex32,
);

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

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

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

// LARFT
define_lapack_ffi!(clarft, ClarftFnPtr,
    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,
);

define_lapack_ffi!(dlarft, DlarftFnPtr,
    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,
);

define_lapack_ffi!(slarft, SlarftFnPtr,
    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,
);

define_lapack_ffi!(zlarft, ZlarftFnPtr,
    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
define_lapack_ffi!(clarfx, ClarfxFnPtr,
    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,
);

define_lapack_ffi!(dlarfx, DlarfxFnPtr,
    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,
);

define_lapack_ffi!(slarfx, SlarfxFnPtr,
    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,
);

define_lapack_ffi!(zlarfx, ZlarfxFnPtr,
    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
define_lapack_ffi!(clarnv, ClarnvFnPtr,
    idist: *const lapackint,
    iseed: *mut lapackint,
    n: *const lapackint,
    X: *mut Complex32,
);

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

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

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

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

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

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

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

// LASCL
define_lapack_ffi!(clascl, ClasclFnPtr,
    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,
);

define_lapack_ffi!(dlascl, DlasclFnPtr,
    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,
);

define_lapack_ffi!(slascl, SlasclFnPtr,
    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,
);

define_lapack_ffi!(zlascl, ZlasclFnPtr,
    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
define_lapack_ffi!(claset, ClasetFnPtr,
    uplo: *const c_char,
    m: *const lapackint,
    n: *const lapackint,
    alpha: *const Complex32,
    beta: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
);

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

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

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

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

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

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

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

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

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

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

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

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

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

// LATMS
define_lapack_ffi!(clatms, ClatmsFnPtr,
    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,
);

define_lapack_ffi!(dlatms, DlatmsFnPtr,
    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,
);

define_lapack_ffi!(slatms, SlatmsFnPtr,
    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,
);

define_lapack_ffi!(zlatms, ZlatmsFnPtr,
    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
define_lapack_ffi!(clauum, ClauumFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

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

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

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

// OPGTR
define_lapack_ffi!(dopgtr, DopgtrFnPtr,
    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,
);

define_lapack_ffi!(sopgtr, SopgtrFnPtr,
    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
define_lapack_ffi!(dopmtr, DopmtrFnPtr,
    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,
);

define_lapack_ffi!(sopmtr, SopmtrFnPtr,
    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
define_lapack_ffi!(dorbdb, DorbdbFnPtr,
    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,
);

define_lapack_ffi!(sorbdb, SorbdbFnPtr,
    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
define_lapack_ffi!(dorcsd, DorcsdFnPtr,
    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,
);

define_lapack_ffi!(sorcsd, SorcsdFnPtr,
    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
define_lapack_ffi!(dorcsd2by1, Dorcsd2by1FnPtr,
    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,
);

define_lapack_ffi!(sorcsd2by1, Sorcsd2by1FnPtr,
    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
define_lapack_ffi!(dorgbr, DorgbrFnPtr,
    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,
);

define_lapack_ffi!(sorgbr, SorgbrFnPtr,
    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
define_lapack_ffi!(dorghr, DorghrFnPtr,
    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,
);

define_lapack_ffi!(sorghr, SorghrFnPtr,
    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
define_lapack_ffi!(dorglq, DorglqFnPtr,
    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,
);

define_lapack_ffi!(sorglq, SorglqFnPtr,
    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
define_lapack_ffi!(dorgql, DorgqlFnPtr,
    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,
);

define_lapack_ffi!(sorgql, SorgqlFnPtr,
    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
define_lapack_ffi!(dorgqr, DorgqrFnPtr,
    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,
);

define_lapack_ffi!(sorgqr, SorgqrFnPtr,
    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
define_lapack_ffi!(dorgrq, DorgrqFnPtr,
    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,
);

define_lapack_ffi!(sorgrq, SorgrqFnPtr,
    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
define_lapack_ffi!(dorgtr, DorgtrFnPtr,
    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,
);

define_lapack_ffi!(sorgtr, SorgtrFnPtr,
    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
define_lapack_ffi!(dorgtsqr_row, Dorgtsqr_rowFnPtr,
    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,
);

define_lapack_ffi!(sorgtsqr_row, Sorgtsqr_rowFnPtr,
    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
define_lapack_ffi!(dormbr, DormbrFnPtr,
    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,
);

define_lapack_ffi!(sormbr, SormbrFnPtr,
    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
define_lapack_ffi!(dormhr, DormhrFnPtr,
    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,
);

define_lapack_ffi!(sormhr, SormhrFnPtr,
    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
define_lapack_ffi!(dormlq, DormlqFnPtr,
    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,
);

define_lapack_ffi!(sormlq, SormlqFnPtr,
    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
define_lapack_ffi!(dormql, DormqlFnPtr,
    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,
);

define_lapack_ffi!(sormql, SormqlFnPtr,
    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
define_lapack_ffi!(dormqr, DormqrFnPtr,
    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,
);

define_lapack_ffi!(sormqr, SormqrFnPtr,
    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
define_lapack_ffi!(dormrq, DormrqFnPtr,
    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,
);

define_lapack_ffi!(sormrq, SormrqFnPtr,
    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
define_lapack_ffi!(dormrz, DormrzFnPtr,
    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,
);

define_lapack_ffi!(sormrz, SormrzFnPtr,
    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
define_lapack_ffi!(dormtr, DormtrFnPtr,
    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,
);

define_lapack_ffi!(sormtr, SormtrFnPtr,
    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
define_lapack_ffi!(cpbcon, CpbconFnPtr,
    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,
);

define_lapack_ffi!(dpbcon, DpbconFnPtr,
    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,
);

define_lapack_ffi!(spbcon, SpbconFnPtr,
    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,
);

define_lapack_ffi!(zpbcon, ZpbconFnPtr,
    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
define_lapack_ffi!(cpbequ, CpbequFnPtr,
    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,
);

define_lapack_ffi!(dpbequ, DpbequFnPtr,
    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,
);

define_lapack_ffi!(spbequ, SpbequFnPtr,
    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,
);

define_lapack_ffi!(zpbequ, ZpbequFnPtr,
    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
define_lapack_ffi!(cpbrfs, CpbrfsFnPtr,
    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,
);

define_lapack_ffi!(dpbrfs, DpbrfsFnPtr,
    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,
);

define_lapack_ffi!(spbrfs, SpbrfsFnPtr,
    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,
);

define_lapack_ffi!(zpbrfs, ZpbrfsFnPtr,
    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
define_lapack_ffi!(cpbstf, CpbstfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

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

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

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

// PBSV
define_lapack_ffi!(cpbsv, CpbsvFnPtr,
    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,
);

define_lapack_ffi!(dpbsv, DpbsvFnPtr,
    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,
);

define_lapack_ffi!(spbsv, SpbsvFnPtr,
    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,
);

define_lapack_ffi!(zpbsv, ZpbsvFnPtr,
    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
define_lapack_ffi!(cpbsvx, CpbsvxFnPtr,
    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,
);

define_lapack_ffi!(dpbsvx, DpbsvxFnPtr,
    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,
);

define_lapack_ffi!(spbsvx, SpbsvxFnPtr,
    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,
);

define_lapack_ffi!(zpbsvx, ZpbsvxFnPtr,
    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
define_lapack_ffi!(cpbtrf, CpbtrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    kd: *const lapackint,
    AB: *mut Complex32,
    ldab: *const lapackint,
    info: *mut lapackint,
);

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

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

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

// PBTRS
define_lapack_ffi!(cpbtrs, CpbtrsFnPtr,
    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,
);

define_lapack_ffi!(dpbtrs, DpbtrsFnPtr,
    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,
);

define_lapack_ffi!(spbtrs, SpbtrsFnPtr,
    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,
);

define_lapack_ffi!(zpbtrs, ZpbtrsFnPtr,
    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
define_lapack_ffi!(cpftrf, CpftrfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    info: *mut lapackint,
);

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

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

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

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

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

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

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

// PFTRS
define_lapack_ffi!(cpftrs, CpftrsFnPtr,
    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,
);

define_lapack_ffi!(dpftrs, DpftrsFnPtr,
    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,
);

define_lapack_ffi!(spftrs, SpftrsFnPtr,
    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,
);

define_lapack_ffi!(zpftrs, ZpftrsFnPtr,
    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
define_lapack_ffi!(cpocon, CpoconFnPtr,
    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,
);

define_lapack_ffi!(dpocon, DpoconFnPtr,
    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,
);

define_lapack_ffi!(spocon, SpoconFnPtr,
    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,
);

define_lapack_ffi!(zpocon, ZpoconFnPtr,
    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
define_lapack_ffi!(cpoequ, CpoequFnPtr,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

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

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

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

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

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

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

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

// PORFS
define_lapack_ffi!(cporfs, CporfsFnPtr,
    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,
);

define_lapack_ffi!(dporfs, DporfsFnPtr,
    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,
);

define_lapack_ffi!(sporfs, SporfsFnPtr,
    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,
);

define_lapack_ffi!(zporfs, ZporfsFnPtr,
    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
define_lapack_ffi!(cporfsx, CporfsxFnPtr,
    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,
);

define_lapack_ffi!(dporfsx, DporfsxFnPtr,
    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,
);

define_lapack_ffi!(sporfsx, SporfsxFnPtr,
    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,
);

define_lapack_ffi!(zporfsx, ZporfsxFnPtr,
    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
define_lapack_ffi!(cposv, CposvFnPtr,
    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,
);

define_lapack_ffi!(dposv, DposvFnPtr,
    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,
);

define_lapack_ffi!(sposv, SposvFnPtr,
    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,
);

define_lapack_ffi!(zposv, ZposvFnPtr,
    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
define_lapack_ffi!(cposvx, CposvxFnPtr,
    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,
);

define_lapack_ffi!(dposvx, DposvxFnPtr,
    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,
);

define_lapack_ffi!(sposvx, SposvxFnPtr,
    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,
);

define_lapack_ffi!(zposvx, ZposvxFnPtr,
    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
define_lapack_ffi!(cposvxx, CposvxxFnPtr,
    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,
);

define_lapack_ffi!(dposvxx, DposvxxFnPtr,
    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,
);

define_lapack_ffi!(sposvxx, SposvxxFnPtr,
    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,
);

define_lapack_ffi!(zposvxx, ZposvxxFnPtr,
    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
define_lapack_ffi!(cpotf2, Cpotf2FnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

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

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

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

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

define_lapack_ffi!(dpotrf, DpotrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(spotrf, SpotrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zpotrf, ZpotrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRF2
define_lapack_ffi!(cpotrf2, Cpotrf2FnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dpotrf2, Dpotrf2FnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(spotrf2, Spotrf2FnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zpotrf2, Zpotrf2FnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRI
define_lapack_ffi!(cpotri, CpotriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dpotri, DpotriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(spotri, SpotriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zpotri, ZpotriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// POTRS
define_lapack_ffi!(cpotrs, CpotrsFnPtr,
    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,
);

define_lapack_ffi!(dpotrs, DpotrsFnPtr,
    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,
);

define_lapack_ffi!(spotrs, SpotrsFnPtr,
    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,
);

define_lapack_ffi!(zpotrs, ZpotrsFnPtr,
    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
define_lapack_ffi!(cppcon, CppconFnPtr,
    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,
);

define_lapack_ffi!(dppcon, DppconFnPtr,
    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,
);

define_lapack_ffi!(sppcon, SppconFnPtr,
    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,
);

define_lapack_ffi!(zppcon, ZppconFnPtr,
    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
define_lapack_ffi!(cppequ, CppequFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(dppequ, DppequFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(sppequ, SppequFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    S: *mut f32,
    scond: *mut f32,
    amax: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zppequ, ZppequFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    S: *mut f64,
    scond: *mut f64,
    amax: *mut f64,
    info: *mut lapackint,
);

// PPRFS
define_lapack_ffi!(cpprfs, CpprfsFnPtr,
    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,
);

define_lapack_ffi!(dpprfs, DpprfsFnPtr,
    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,
);

define_lapack_ffi!(spprfs, SpprfsFnPtr,
    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,
);

define_lapack_ffi!(zpprfs, ZpprfsFnPtr,
    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
define_lapack_ffi!(cppsv, CppsvFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dppsv, DppsvFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(sppsv, SppsvFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zppsv, ZppsvFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PPSVX
define_lapack_ffi!(cppsvx, CppsvxFnPtr,
    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,
);

define_lapack_ffi!(dppsvx, DppsvxFnPtr,
    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,
);

define_lapack_ffi!(sppsvx, SppsvxFnPtr,
    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,
);

define_lapack_ffi!(zppsvx, ZppsvxFnPtr,
    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
define_lapack_ffi!(cpptrf, CpptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dpptrf, DpptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(spptrf, SpptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zpptrf, ZpptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// PPTRI
define_lapack_ffi!(cpptri, CpptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dpptri, DpptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(spptri, SpptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zpptri, ZpptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// PPTRS
define_lapack_ffi!(cpptrs, CpptrsFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dpptrs, DpptrsFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(spptrs, SpptrsFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zpptrs, ZpptrsFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    nrhs: *const lapackint,
    AP: *const Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PSTRF
define_lapack_ffi!(cpstrf, CpstrfFnPtr,
    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,
);

define_lapack_ffi!(dpstrf, DpstrfFnPtr,
    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,
);

define_lapack_ffi!(spstrf, SpstrfFnPtr,
    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,
);

define_lapack_ffi!(zpstrf, ZpstrfFnPtr,
    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
define_lapack_ffi!(cptcon, CptconFnPtr,
    n: *const lapackint,
    D: *const f32,
    E: *const Complex32,
    anorm: *const f32,
    rcond: *mut f32,
    rwork: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(dptcon, DptconFnPtr,
    n: *const lapackint,
    D: *const f64,
    E: *const f64,
    anorm: *const f64,
    rcond: *mut f64,
    work: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(sptcon, SptconFnPtr,
    n: *const lapackint,
    D: *const f32,
    E: *const f32,
    anorm: *const f32,
    rcond: *mut f32,
    work: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zptcon, ZptconFnPtr,
    n: *const lapackint,
    D: *const f64,
    E: *const Complex64,
    anorm: *const f64,
    rcond: *mut f64,
    rwork: *mut f64,
    info: *mut lapackint,
);

// PTEQR
define_lapack_ffi!(cpteqr, CpteqrFnPtr,
    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,
);

define_lapack_ffi!(dpteqr, DpteqrFnPtr,
    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,
);

define_lapack_ffi!(spteqr, SpteqrFnPtr,
    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,
);

define_lapack_ffi!(zpteqr, ZpteqrFnPtr,
    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
define_lapack_ffi!(cptrfs, CptrfsFnPtr,
    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,
);

define_lapack_ffi!(dptrfs, DptrfsFnPtr,
    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,
);

define_lapack_ffi!(sptrfs, SptrfsFnPtr,
    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,
);

define_lapack_ffi!(zptrfs, ZptrfsFnPtr,
    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
define_lapack_ffi!(cptsv, CptsvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f32,
    E: *mut Complex32,
    B: *mut Complex32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dptsv, DptsvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(sptsv, SptsvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zptsv, ZptsvFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *mut f64,
    E: *mut Complex64,
    B: *mut Complex64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

// PTSVX
define_lapack_ffi!(cptsvx, CptsvxFnPtr,
    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,
);

define_lapack_ffi!(dptsvx, DptsvxFnPtr,
    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,
);

define_lapack_ffi!(sptsvx, SptsvxFnPtr,
    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,
);

define_lapack_ffi!(zptsvx, ZptsvxFnPtr,
    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
define_lapack_ffi!(cpttrf, CpttrfFnPtr,
    n: *const lapackint,
    D: *mut f32,
    E: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dpttrf, DpttrfFnPtr,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(spttrf, SpttrfFnPtr,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zpttrf, ZpttrfFnPtr,
    n: *const lapackint,
    D: *mut f64,
    E: *mut Complex64,
    info: *mut lapackint,
);

// PTTRS
define_lapack_ffi!(cpttrs, CpttrsFnPtr,
    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,
);

define_lapack_ffi!(dpttrs, DpttrsFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f64,
    E: *const f64,
    B: *mut f64,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(spttrs, SpttrsFnPtr,
    n: *const lapackint,
    nrhs: *const lapackint,
    D: *const f32,
    E: *const f32,
    B: *mut f32,
    ldb: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zpttrs, ZpttrsFnPtr,
    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
define_lapack_ffi!(dsbev, DsbevFnPtr,
    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,
);

define_lapack_ffi!(ssbev, SsbevFnPtr,
    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
define_lapack_ffi!(dsbev_2stage, Dsbev_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssbev_2stage, Ssbev_2stageFnPtr,
    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
define_lapack_ffi!(dsbevd, DsbevdFnPtr,
    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,
);

define_lapack_ffi!(ssbevd, SsbevdFnPtr,
    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
define_lapack_ffi!(dsbevd_2stage, Dsbevd_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssbevd_2stage, Ssbevd_2stageFnPtr,
    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
define_lapack_ffi!(dsbevx, DsbevxFnPtr,
    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,
);

define_lapack_ffi!(ssbevx, SsbevxFnPtr,
    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
define_lapack_ffi!(dsbevx_2stage, Dsbevx_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssbevx_2stage, Ssbevx_2stageFnPtr,
    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
define_lapack_ffi!(dsbgst, DsbgstFnPtr,
    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,
);

define_lapack_ffi!(ssbgst, SsbgstFnPtr,
    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
define_lapack_ffi!(dsbgv, DsbgvFnPtr,
    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,
);

define_lapack_ffi!(ssbgv, SsbgvFnPtr,
    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
define_lapack_ffi!(dsbgvd, DsbgvdFnPtr,
    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,
);

define_lapack_ffi!(ssbgvd, SsbgvdFnPtr,
    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
define_lapack_ffi!(dsbgvx, DsbgvxFnPtr,
    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,
);

define_lapack_ffi!(ssbgvx, SsbgvxFnPtr,
    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
define_lapack_ffi!(dsbtrd, DsbtrdFnPtr,
    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,
);

define_lapack_ffi!(ssbtrd, SsbtrdFnPtr,
    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
define_lapack_ffi!(dsfrk, DsfrkFnPtr,
    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,
);

define_lapack_ffi!(ssfrk, SsfrkFnPtr,
    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
define_lapack_ffi!(dsgesv, DsgesvFnPtr,
    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
define_lapack_ffi!(cspcon, CspconFnPtr,
    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,
);

define_lapack_ffi!(dspcon, DspconFnPtr,
    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,
);

define_lapack_ffi!(sspcon, SspconFnPtr,
    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,
);

define_lapack_ffi!(zspcon, ZspconFnPtr,
    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
define_lapack_ffi!(dspev, DspevFnPtr,
    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,
);

define_lapack_ffi!(sspev, SspevFnPtr,
    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
define_lapack_ffi!(dspevd, DspevdFnPtr,
    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,
);

define_lapack_ffi!(sspevd, SspevdFnPtr,
    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
define_lapack_ffi!(dspevx, DspevxFnPtr,
    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,
);

define_lapack_ffi!(sspevx, SspevxFnPtr,
    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
define_lapack_ffi!(dspgst, DspgstFnPtr,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    BP: *const f64,
    info: *mut lapackint,
);

define_lapack_ffi!(sspgst, SspgstFnPtr,
    itype: *const lapackint,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    BP: *const f32,
    info: *mut lapackint,
);

// SPGV
define_lapack_ffi!(dspgv, DspgvFnPtr,
    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,
);

define_lapack_ffi!(sspgv, SspgvFnPtr,
    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
define_lapack_ffi!(dspgvd, DspgvdFnPtr,
    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,
);

define_lapack_ffi!(sspgvd, SspgvdFnPtr,
    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
define_lapack_ffi!(dspgvx, DspgvxFnPtr,
    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,
);

define_lapack_ffi!(sspgvx, SspgvxFnPtr,
    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
define_lapack_ffi!(dsposv, DsposvFnPtr,
    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
define_lapack_ffi!(csprfs, CsprfsFnPtr,
    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,
);

define_lapack_ffi!(dsprfs, DsprfsFnPtr,
    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,
);

define_lapack_ffi!(ssprfs, SsprfsFnPtr,
    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,
);

define_lapack_ffi!(zsprfs, ZsprfsFnPtr,
    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
define_lapack_ffi!(cspsv, CspsvFnPtr,
    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,
);

define_lapack_ffi!(dspsv, DspsvFnPtr,
    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,
);

define_lapack_ffi!(sspsv, SspsvFnPtr,
    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,
);

define_lapack_ffi!(zspsv, ZspsvFnPtr,
    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
define_lapack_ffi!(cspsvx, CspsvxFnPtr,
    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,
);

define_lapack_ffi!(dspsvx, DspsvxFnPtr,
    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,
);

define_lapack_ffi!(sspsvx, SspsvxFnPtr,
    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,
);

define_lapack_ffi!(zspsvx, ZspsvxFnPtr,
    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
define_lapack_ffi!(dsptrd, DsptrdFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    D: *mut f64,
    E: *mut f64,
    tau: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(ssptrd, SsptrdFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    D: *mut f32,
    E: *mut f32,
    tau: *mut f32,
    info: *mut lapackint,
);

// SPTRF
define_lapack_ffi!(csptrf, CsptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dsptrf, DsptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(ssptrf, SsptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(zsptrf, ZsptrfFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *mut lapackint,
    info: *mut lapackint,
);

// SPTRI
define_lapack_ffi!(csptri, CsptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dsptri, DsptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    ipiv: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(ssptri, SsptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    ipiv: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zsptri, ZsptriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SPTRS
define_lapack_ffi!(csptrs, CsptrsFnPtr,
    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,
);

define_lapack_ffi!(dsptrs, DsptrsFnPtr,
    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,
);

define_lapack_ffi!(ssptrs, SsptrsFnPtr,
    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,
);

define_lapack_ffi!(zsptrs, ZsptrsFnPtr,
    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
define_lapack_ffi!(dstebz, DstebzFnPtr,
    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,
);

define_lapack_ffi!(sstebz, SstebzFnPtr,
    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
define_lapack_ffi!(cstedc, CstedcFnPtr,
    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,
);

define_lapack_ffi!(dstedc, DstedcFnPtr,
    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,
);

define_lapack_ffi!(sstedc, SstedcFnPtr,
    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,
);

define_lapack_ffi!(zstedc, ZstedcFnPtr,
    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
define_lapack_ffi!(cstegr, CstegrFnPtr,
    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,
);

define_lapack_ffi!(dstegr, DstegrFnPtr,
    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,
);

define_lapack_ffi!(sstegr, SstegrFnPtr,
    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,
);

define_lapack_ffi!(zstegr, ZstegrFnPtr,
    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
define_lapack_ffi!(cstein, CsteinFnPtr,
    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,
);

define_lapack_ffi!(dstein, DsteinFnPtr,
    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,
);

define_lapack_ffi!(sstein, SsteinFnPtr,
    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,
);

define_lapack_ffi!(zstein, ZsteinFnPtr,
    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
define_lapack_ffi!(cstemr, CstemrFnPtr,
    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,
);

define_lapack_ffi!(dstemr, DstemrFnPtr,
    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,
);

define_lapack_ffi!(sstemr, SstemrFnPtr,
    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,
);

define_lapack_ffi!(zstemr, ZstemrFnPtr,
    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
define_lapack_ffi!(csteqr, CsteqrFnPtr,
    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,
);

define_lapack_ffi!(dsteqr, DsteqrFnPtr,
    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,
);

define_lapack_ffi!(ssteqr, SsteqrFnPtr,
    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,
);

define_lapack_ffi!(zsteqr, ZsteqrFnPtr,
    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
define_lapack_ffi!(dsterf, DsterfFnPtr,
    n: *const lapackint,
    D: *mut f64,
    E: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(ssterf, SsterfFnPtr,
    n: *const lapackint,
    D: *mut f32,
    E: *mut f32,
    info: *mut lapackint,
);

// STEV
define_lapack_ffi!(dstev, DstevFnPtr,
    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,
);

define_lapack_ffi!(sstev, SstevFnPtr,
    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
define_lapack_ffi!(dstevd, DstevdFnPtr,
    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,
);

define_lapack_ffi!(sstevd, SstevdFnPtr,
    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
define_lapack_ffi!(dstevr, DstevrFnPtr,
    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,
);

define_lapack_ffi!(sstevr, SstevrFnPtr,
    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
define_lapack_ffi!(dstevx, DstevxFnPtr,
    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,
);

define_lapack_ffi!(sstevx, SstevxFnPtr,
    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
define_lapack_ffi!(csycon, CsyconFnPtr,
    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,
);

define_lapack_ffi!(dsycon, DsyconFnPtr,
    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,
);

define_lapack_ffi!(ssycon, SsyconFnPtr,
    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,
);

define_lapack_ffi!(zsycon, ZsyconFnPtr,
    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
define_lapack_ffi!(csycon_3, Csycon_3FnPtr,
    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,
);

define_lapack_ffi!(dsycon_3, Dsycon_3FnPtr,
    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,
);

define_lapack_ffi!(ssycon_3, Ssycon_3FnPtr,
    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,
);

define_lapack_ffi!(zsycon_3, Zsycon_3FnPtr,
    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
define_lapack_ffi!(csyconv, CsyconvFnPtr,
    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,
);

define_lapack_ffi!(dsyconv, DsyconvFnPtr,
    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,
);

define_lapack_ffi!(ssyconv, SsyconvFnPtr,
    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,
);

define_lapack_ffi!(zsyconv, ZsyconvFnPtr,
    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
define_lapack_ffi!(csyequb, CsyequbFnPtr,
    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,
);

define_lapack_ffi!(dsyequb, DsyequbFnPtr,
    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,
);

define_lapack_ffi!(ssyequb, SsyequbFnPtr,
    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,
);

define_lapack_ffi!(zsyequb, ZsyequbFnPtr,
    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
define_lapack_ffi!(dsyev, DsyevFnPtr,
    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,
);

define_lapack_ffi!(ssyev, SsyevFnPtr,
    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
define_lapack_ffi!(dsyev_2stage, Dsyev_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssyev_2stage, Ssyev_2stageFnPtr,
    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
define_lapack_ffi!(dsyevd, DsyevdFnPtr,
    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,
);

define_lapack_ffi!(ssyevd, SsyevdFnPtr,
    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
define_lapack_ffi!(dsyevd_2stage, Dsyevd_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssyevd_2stage, Ssyevd_2stageFnPtr,
    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
define_lapack_ffi!(dsyevr, DsyevrFnPtr,
    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,
);

define_lapack_ffi!(ssyevr, SsyevrFnPtr,
    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
define_lapack_ffi!(dsyevr_2stage, Dsyevr_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssyevr_2stage, Ssyevr_2stageFnPtr,
    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
define_lapack_ffi!(dsyevx, DsyevxFnPtr,
    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,
);

define_lapack_ffi!(ssyevx, SsyevxFnPtr,
    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
define_lapack_ffi!(dsyevx_2stage, Dsyevx_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssyevx_2stage, Ssyevx_2stageFnPtr,
    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
define_lapack_ffi!(dsygst, DsygstFnPtr,
    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,
);

define_lapack_ffi!(ssygst, SsygstFnPtr,
    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
define_lapack_ffi!(dsygv, DsygvFnPtr,
    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,
);

define_lapack_ffi!(ssygv, SsygvFnPtr,
    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
define_lapack_ffi!(dsygv_2stage, Dsygv_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssygv_2stage, Ssygv_2stageFnPtr,
    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
define_lapack_ffi!(dsygvd, DsygvdFnPtr,
    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,
);

define_lapack_ffi!(ssygvd, SsygvdFnPtr,
    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
define_lapack_ffi!(dsygvx, DsygvxFnPtr,
    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,
);

define_lapack_ffi!(ssygvx, SsygvxFnPtr,
    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
define_lapack_ffi!(csyr, CsyrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    alpha: *const Complex32,
    X: *const Complex32,
    incx: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
);

define_lapack_ffi!(zsyr, ZsyrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    alpha: *const Complex64,
    X: *const Complex64,
    incx: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
);

// SYRFS
define_lapack_ffi!(csyrfs, CsyrfsFnPtr,
    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,
);

define_lapack_ffi!(dsyrfs, DsyrfsFnPtr,
    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,
);

define_lapack_ffi!(ssyrfs, SsyrfsFnPtr,
    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,
);

define_lapack_ffi!(zsyrfs, ZsyrfsFnPtr,
    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
define_lapack_ffi!(csyrfsx, CsyrfsxFnPtr,
    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,
);

define_lapack_ffi!(dsyrfsx, DsyrfsxFnPtr,
    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,
);

define_lapack_ffi!(ssyrfsx, SsyrfsxFnPtr,
    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,
);

define_lapack_ffi!(zsyrfsx, ZsyrfsxFnPtr,
    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
define_lapack_ffi!(csysv, CsysvFnPtr,
    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,
);

define_lapack_ffi!(dsysv, DsysvFnPtr,
    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,
);

define_lapack_ffi!(ssysv, SsysvFnPtr,
    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,
);

define_lapack_ffi!(zsysv, ZsysvFnPtr,
    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
define_lapack_ffi!(csysv_aa, Csysv_aaFnPtr,
    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,
);

define_lapack_ffi!(dsysv_aa, Dsysv_aaFnPtr,
    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,
);

define_lapack_ffi!(ssysv_aa, Ssysv_aaFnPtr,
    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,
);

define_lapack_ffi!(zsysv_aa, Zsysv_aaFnPtr,
    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
define_lapack_ffi!(csysv_aa_2stage, Csysv_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(dsysv_aa_2stage, Dsysv_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssysv_aa_2stage, Ssysv_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zsysv_aa_2stage, Zsysv_aa_2stageFnPtr,
    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
define_lapack_ffi!(csysv_rk, Csysv_rkFnPtr,
    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,
);

define_lapack_ffi!(dsysv_rk, Dsysv_rkFnPtr,
    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,
);

define_lapack_ffi!(ssysv_rk, Ssysv_rkFnPtr,
    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,
);

define_lapack_ffi!(zsysv_rk, Zsysv_rkFnPtr,
    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
define_lapack_ffi!(csysv_rook, Csysv_rookFnPtr,
    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,
);

define_lapack_ffi!(dsysv_rook, Dsysv_rookFnPtr,
    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,
);

define_lapack_ffi!(ssysv_rook, Ssysv_rookFnPtr,
    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,
);

define_lapack_ffi!(zsysv_rook, Zsysv_rookFnPtr,
    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
define_lapack_ffi!(csysvx, CsysvxFnPtr,
    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,
);

define_lapack_ffi!(dsysvx, DsysvxFnPtr,
    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,
);

define_lapack_ffi!(ssysvx, SsysvxFnPtr,
    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,
);

define_lapack_ffi!(zsysvx, ZsysvxFnPtr,
    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
define_lapack_ffi!(csysvxx, CsysvxxFnPtr,
    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,
);

define_lapack_ffi!(dsysvxx, DsysvxxFnPtr,
    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,
);

define_lapack_ffi!(ssysvxx, SsysvxxFnPtr,
    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,
);

define_lapack_ffi!(zsysvxx, ZsysvxxFnPtr,
    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
define_lapack_ffi!(csyswapr, CsyswaprFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

define_lapack_ffi!(dsyswapr, DsyswaprFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

define_lapack_ffi!(ssyswapr, SsyswaprFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

define_lapack_ffi!(zsyswapr, ZsyswaprFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    i1: *const lapackint,
    i2: *const lapackint,
);

// SYTRD
define_lapack_ffi!(dsytrd, DsytrdFnPtr,
    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,
);

define_lapack_ffi!(ssytrd, SsytrdFnPtr,
    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
define_lapack_ffi!(dsytrd_2stage, Dsytrd_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssytrd_2stage, Ssytrd_2stageFnPtr,
    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
define_lapack_ffi!(csytrf, CsytrfFnPtr,
    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,
);

define_lapack_ffi!(dsytrf, DsytrfFnPtr,
    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,
);

define_lapack_ffi!(ssytrf, SsytrfFnPtr,
    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,
);

define_lapack_ffi!(zsytrf, ZsytrfFnPtr,
    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
define_lapack_ffi!(csytrf_aa, Csytrf_aaFnPtr,
    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,
);

define_lapack_ffi!(dsytrf_aa, Dsytrf_aaFnPtr,
    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,
);

define_lapack_ffi!(ssytrf_aa, Ssytrf_aaFnPtr,
    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,
);

define_lapack_ffi!(zsytrf_aa, Zsytrf_aaFnPtr,
    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
define_lapack_ffi!(csytrf_aa_2stage, Csytrf_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(dsytrf_aa_2stage, Dsytrf_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssytrf_aa_2stage, Ssytrf_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zsytrf_aa_2stage, Zsytrf_aa_2stageFnPtr,
    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
define_lapack_ffi!(csytrf_rk, Csytrf_rkFnPtr,
    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,
);

define_lapack_ffi!(dsytrf_rk, Dsytrf_rkFnPtr,
    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,
);

define_lapack_ffi!(ssytrf_rk, Ssytrf_rkFnPtr,
    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,
);

define_lapack_ffi!(zsytrf_rk, Zsytrf_rkFnPtr,
    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
define_lapack_ffi!(csytrf_rook, Csytrf_rookFnPtr,
    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,
);

define_lapack_ffi!(dsytrf_rook, Dsytrf_rookFnPtr,
    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,
);

define_lapack_ffi!(ssytrf_rook, Ssytrf_rookFnPtr,
    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,
);

define_lapack_ffi!(zsytrf_rook, Zsytrf_rookFnPtr,
    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
define_lapack_ffi!(csytri, CsytriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dsytri, DsytriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(ssytri, SsytriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(zsytri, ZsytriFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    ipiv: *const lapackint,
    work: *mut Complex64,
    info: *mut lapackint,
);

// SYTRI2
define_lapack_ffi!(csytri2, Csytri2FnPtr,
    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,
);

define_lapack_ffi!(dsytri2, Dsytri2FnPtr,
    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,
);

define_lapack_ffi!(ssytri2, Ssytri2FnPtr,
    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,
);

define_lapack_ffi!(zsytri2, Zsytri2FnPtr,
    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
define_lapack_ffi!(csytri2x, Csytri2xFnPtr,
    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,
);

define_lapack_ffi!(dsytri2x, Dsytri2xFnPtr,
    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,
);

define_lapack_ffi!(ssytri2x, Ssytri2xFnPtr,
    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,
);

define_lapack_ffi!(zsytri2x, Zsytri2xFnPtr,
    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
define_lapack_ffi!(csytri_3, Csytri_3FnPtr,
    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,
);

define_lapack_ffi!(dsytri_3, Dsytri_3FnPtr,
    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,
);

define_lapack_ffi!(ssytri_3, Ssytri_3FnPtr,
    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,
);

define_lapack_ffi!(zsytri_3, Zsytri_3FnPtr,
    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
define_lapack_ffi!(csytrs, CsytrsFnPtr,
    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,
);

define_lapack_ffi!(dsytrs, DsytrsFnPtr,
    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,
);

define_lapack_ffi!(ssytrs, SsytrsFnPtr,
    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,
);

define_lapack_ffi!(zsytrs, ZsytrsFnPtr,
    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
define_lapack_ffi!(csytrs2, Csytrs2FnPtr,
    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,
);

define_lapack_ffi!(dsytrs2, Dsytrs2FnPtr,
    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,
);

define_lapack_ffi!(ssytrs2, Ssytrs2FnPtr,
    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,
);

define_lapack_ffi!(zsytrs2, Zsytrs2FnPtr,
    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
define_lapack_ffi!(csytrs_3, Csytrs_3FnPtr,
    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,
);

define_lapack_ffi!(dsytrs_3, Dsytrs_3FnPtr,
    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,
);

define_lapack_ffi!(ssytrs_3, Ssytrs_3FnPtr,
    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,
);

define_lapack_ffi!(zsytrs_3, Zsytrs_3FnPtr,
    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
define_lapack_ffi!(csytrs_aa, Csytrs_aaFnPtr,
    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,
);

define_lapack_ffi!(dsytrs_aa, Dsytrs_aaFnPtr,
    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,
);

define_lapack_ffi!(ssytrs_aa, Ssytrs_aaFnPtr,
    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,
);

define_lapack_ffi!(zsytrs_aa, Zsytrs_aaFnPtr,
    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
define_lapack_ffi!(csytrs_aa_2stage, Csytrs_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(dsytrs_aa_2stage, Dsytrs_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(ssytrs_aa_2stage, Ssytrs_aa_2stageFnPtr,
    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,
);

define_lapack_ffi!(zsytrs_aa_2stage, Zsytrs_aa_2stageFnPtr,
    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
define_lapack_ffi!(csytrs_rook, Csytrs_rookFnPtr,
    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,
);

define_lapack_ffi!(dsytrs_rook, Dsytrs_rookFnPtr,
    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,
);

define_lapack_ffi!(ssytrs_rook, Ssytrs_rookFnPtr,
    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,
);

define_lapack_ffi!(zsytrs_rook, Zsytrs_rookFnPtr,
    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
define_lapack_ffi!(ctbcon, CtbconFnPtr,
    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,
);

define_lapack_ffi!(dtbcon, DtbconFnPtr,
    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,
);

define_lapack_ffi!(stbcon, StbconFnPtr,
    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,
);

define_lapack_ffi!(ztbcon, ZtbconFnPtr,
    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
define_lapack_ffi!(ctbrfs, CtbrfsFnPtr,
    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,
);

define_lapack_ffi!(dtbrfs, DtbrfsFnPtr,
    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,
);

define_lapack_ffi!(stbrfs, StbrfsFnPtr,
    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,
);

define_lapack_ffi!(ztbrfs, ZtbrfsFnPtr,
    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
define_lapack_ffi!(ctbtrs, CtbtrsFnPtr,
    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,
);

define_lapack_ffi!(dtbtrs, DtbtrsFnPtr,
    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,
);

define_lapack_ffi!(stbtrs, StbtrsFnPtr,
    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,
);

define_lapack_ffi!(ztbtrs, ZtbtrsFnPtr,
    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
define_lapack_ffi!(ctfsm, CtfsmFnPtr,
    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,
);

define_lapack_ffi!(dtfsm, DtfsmFnPtr,
    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,
);

define_lapack_ffi!(stfsm, StfsmFnPtr,
    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,
);

define_lapack_ffi!(ztfsm, ZtfsmFnPtr,
    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
define_lapack_ffi!(ctftri, CtftriFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtftri, DtftriFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(stftri, StftriFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztftri, ZtftriFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    info: *mut lapackint,
);

// TFTTP
define_lapack_ffi!(ctfttp, CtfttpFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex32,
    AP: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtfttp, DtfttpFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f64,
    AP: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(stfttp, StfttpFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f32,
    AP: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztfttp, ZtfttpFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex64,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TFTTR
define_lapack_ffi!(ctfttr, CtfttrFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dtfttr, DtfttrFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(stfttr, StfttrFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(ztfttr, ZtfttrFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    ARF: *const Complex64,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TGEVC
define_lapack_ffi!(ctgevc, CtgevcFnPtr,
    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,
);

define_lapack_ffi!(dtgevc, DtgevcFnPtr,
    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,
);

define_lapack_ffi!(stgevc, StgevcFnPtr,
    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,
);

define_lapack_ffi!(ztgevc, ZtgevcFnPtr,
    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
define_lapack_ffi!(ctgexc, CtgexcFnPtr,
    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,
);

define_lapack_ffi!(dtgexc, DtgexcFnPtr,
    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,
);

define_lapack_ffi!(stgexc, StgexcFnPtr,
    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,
);

define_lapack_ffi!(ztgexc, ZtgexcFnPtr,
    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
define_lapack_ffi!(ctgsen, CtgsenFnPtr,
    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,
);

define_lapack_ffi!(dtgsen, DtgsenFnPtr,
    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,
);

define_lapack_ffi!(stgsen, StgsenFnPtr,
    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,
);

define_lapack_ffi!(ztgsen, ZtgsenFnPtr,
    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
define_lapack_ffi!(ctgsja, CtgsjaFnPtr,
    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,
);

define_lapack_ffi!(dtgsja, DtgsjaFnPtr,
    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,
);

define_lapack_ffi!(stgsja, StgsjaFnPtr,
    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,
);

define_lapack_ffi!(ztgsja, ZtgsjaFnPtr,
    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
define_lapack_ffi!(ctgsna, CtgsnaFnPtr,
    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,
);

define_lapack_ffi!(dtgsna, DtgsnaFnPtr,
    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,
);

define_lapack_ffi!(stgsna, StgsnaFnPtr,
    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,
);

define_lapack_ffi!(ztgsna, ZtgsnaFnPtr,
    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
define_lapack_ffi!(ctgsyl, CtgsylFnPtr,
    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,
);

define_lapack_ffi!(dtgsyl, DtgsylFnPtr,
    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,
);

define_lapack_ffi!(stgsyl, StgsylFnPtr,
    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,
);

define_lapack_ffi!(ztgsyl, ZtgsylFnPtr,
    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
define_lapack_ffi!(ctpcon, CtpconFnPtr,
    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,
);

define_lapack_ffi!(dtpcon, DtpconFnPtr,
    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,
);

define_lapack_ffi!(stpcon, StpconFnPtr,
    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,
);

define_lapack_ffi!(ztpcon, ZtpconFnPtr,
    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
define_lapack_ffi!(ctplqt, CtplqtFnPtr,
    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,
);

define_lapack_ffi!(dtplqt, DtplqtFnPtr,
    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,
);

define_lapack_ffi!(stplqt, StplqtFnPtr,
    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,
);

define_lapack_ffi!(ztplqt, ZtplqtFnPtr,
    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
define_lapack_ffi!(ctplqt2, Ctplqt2FnPtr,
    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,
);

define_lapack_ffi!(dtplqt2, Dtplqt2FnPtr,
    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,
);

define_lapack_ffi!(stplqt2, Stplqt2FnPtr,
    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,
);

define_lapack_ffi!(ztplqt2, Ztplqt2FnPtr,
    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
define_lapack_ffi!(ctpmlqt, CtpmlqtFnPtr,
    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,
);

define_lapack_ffi!(dtpmlqt, DtpmlqtFnPtr,
    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,
);

define_lapack_ffi!(stpmlqt, StpmlqtFnPtr,
    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,
);

define_lapack_ffi!(ztpmlqt, ZtpmlqtFnPtr,
    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
define_lapack_ffi!(ctpmqrt, CtpmqrtFnPtr,
    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,
);

define_lapack_ffi!(dtpmqrt, DtpmqrtFnPtr,
    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,
);

define_lapack_ffi!(stpmqrt, StpmqrtFnPtr,
    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,
);

define_lapack_ffi!(ztpmqrt, ZtpmqrtFnPtr,
    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
define_lapack_ffi!(ctpqrt, CtpqrtFnPtr,
    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,
);

define_lapack_ffi!(dtpqrt, DtpqrtFnPtr,
    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,
);

define_lapack_ffi!(stpqrt, StpqrtFnPtr,
    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,
);

define_lapack_ffi!(ztpqrt, ZtpqrtFnPtr,
    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
define_lapack_ffi!(ctpqrt2, Ctpqrt2FnPtr,
    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,
);

define_lapack_ffi!(dtpqrt2, Dtpqrt2FnPtr,
    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,
);

define_lapack_ffi!(stpqrt2, Stpqrt2FnPtr,
    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,
);

define_lapack_ffi!(ztpqrt2, Ztpqrt2FnPtr,
    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
define_lapack_ffi!(ctprfb, CtprfbFnPtr,
    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,
);

define_lapack_ffi!(dtprfb, DtprfbFnPtr,
    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,
);

define_lapack_ffi!(stprfb, StprfbFnPtr,
    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,
);

define_lapack_ffi!(ztprfb, ZtprfbFnPtr,
    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
define_lapack_ffi!(ctprfs, CtprfsFnPtr,
    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,
);

define_lapack_ffi!(dtprfs, DtprfsFnPtr,
    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,
);

define_lapack_ffi!(stprfs, StprfsFnPtr,
    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,
);

define_lapack_ffi!(ztprfs, ZtprfsFnPtr,
    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
define_lapack_ffi!(ctptri, CtptriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtptri, DtptriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(stptri, StptriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztptri, ZtptriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TPTRS
define_lapack_ffi!(ctptrs, CtptrsFnPtr,
    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,
);

define_lapack_ffi!(dtptrs, DtptrsFnPtr,
    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,
);

define_lapack_ffi!(stptrs, StptrsFnPtr,
    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,
);

define_lapack_ffi!(ztptrs, ZtptrsFnPtr,
    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
define_lapack_ffi!(ctpttf, CtpttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    ARF: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtpttf, DtpttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    ARF: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(stpttf, StpttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    ARF: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztpttf, ZtpttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    ARF: *mut Complex64,
    info: *mut lapackint,
);

// TPTTR
define_lapack_ffi!(ctpttr, CtpttrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex32,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dtpttr, DtpttrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f64,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(stpttr, StpttrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const f32,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(ztpttr, ZtpttrFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    AP: *const Complex64,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TRCON
define_lapack_ffi!(ctrcon, CtrconFnPtr,
    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,
);

define_lapack_ffi!(dtrcon, DtrconFnPtr,
    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,
);

define_lapack_ffi!(strcon, StrconFnPtr,
    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,
);

define_lapack_ffi!(ztrcon, ZtrconFnPtr,
    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
define_lapack_ffi!(ctrevc, CtrevcFnPtr,
    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,
);

define_lapack_ffi!(dtrevc, DtrevcFnPtr,
    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,
);

define_lapack_ffi!(strevc, StrevcFnPtr,
    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,
);

define_lapack_ffi!(ztrevc, ZtrevcFnPtr,
    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
define_lapack_ffi!(ctrevc3, Ctrevc3FnPtr,
    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,
);

define_lapack_ffi!(dtrevc3, Dtrevc3FnPtr,
    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,
);

define_lapack_ffi!(strevc3, Strevc3FnPtr,
    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,
);

define_lapack_ffi!(ztrevc3, Ztrevc3FnPtr,
    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
define_lapack_ffi!(ctrexc, CtrexcFnPtr,
    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,
);

define_lapack_ffi!(dtrexc, DtrexcFnPtr,
    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,
);

define_lapack_ffi!(strexc, StrexcFnPtr,
    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,
);

define_lapack_ffi!(ztrexc, ZtrexcFnPtr,
    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
define_lapack_ffi!(ctrrfs, CtrrfsFnPtr,
    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,
);

define_lapack_ffi!(dtrrfs, DtrrfsFnPtr,
    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,
);

define_lapack_ffi!(strrfs, StrrfsFnPtr,
    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,
);

define_lapack_ffi!(ztrrfs, ZtrrfsFnPtr,
    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
define_lapack_ffi!(ctrsen, CtrsenFnPtr,
    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,
);

define_lapack_ffi!(dtrsen, DtrsenFnPtr,
    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,
);

define_lapack_ffi!(strsen, StrsenFnPtr,
    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,
);

define_lapack_ffi!(ztrsen, ZtrsenFnPtr,
    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
define_lapack_ffi!(ctrsna, CtrsnaFnPtr,
    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,
);

define_lapack_ffi!(dtrsna, DtrsnaFnPtr,
    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,
);

define_lapack_ffi!(strsna, StrsnaFnPtr,
    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,
);

define_lapack_ffi!(ztrsna, ZtrsnaFnPtr,
    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
define_lapack_ffi!(ctrsyl, CtrsylFnPtr,
    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,
);

define_lapack_ffi!(dtrsyl, DtrsylFnPtr,
    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,
);

define_lapack_ffi!(strsyl, StrsylFnPtr,
    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,
);

define_lapack_ffi!(ztrsyl, ZtrsylFnPtr,
    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
define_lapack_ffi!(ctrtri, CtrtriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dtrtri, DtrtriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(strtri, StrtriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(ztrtri, ZtrtriFnPtr,
    uplo: *const c_char,
    diag: *const c_char,
    n: *const lapackint,
    A: *mut Complex64,
    lda: *const lapackint,
    info: *mut lapackint,
);

// TRTRS
define_lapack_ffi!(ctrtrs, CtrtrsFnPtr,
    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,
);

define_lapack_ffi!(dtrtrs, DtrtrsFnPtr,
    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,
);

define_lapack_ffi!(strtrs, StrtrsFnPtr,
    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,
);

define_lapack_ffi!(ztrtrs, ZtrtrsFnPtr,
    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
define_lapack_ffi!(ctrttf, CtrttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    ARF: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtrttf, DtrttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    ARF: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(strttf, StrttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    ARF: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztrttf, ZtrttfFnPtr,
    transr: *const c_char,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    ARF: *mut Complex64,
    info: *mut lapackint,
);

// TRTTP
define_lapack_ffi!(ctrttp, CtrttpFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex32,
    lda: *const lapackint,
    AP: *mut Complex32,
    info: *mut lapackint,
);

define_lapack_ffi!(dtrttp, DtrttpFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f64,
    lda: *const lapackint,
    AP: *mut f64,
    info: *mut lapackint,
);

define_lapack_ffi!(strttp, StrttpFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const f32,
    lda: *const lapackint,
    AP: *mut f32,
    info: *mut lapackint,
);

define_lapack_ffi!(ztrttp, ZtrttpFnPtr,
    uplo: *const c_char,
    n: *const lapackint,
    A: *const Complex64,
    lda: *const lapackint,
    AP: *mut Complex64,
    info: *mut lapackint,
);

// TZRZF
define_lapack_ffi!(ctzrzf, CtzrzfFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut Complex32,
    lda: *const lapackint,
    tau: *mut Complex32,
    work: *mut Complex32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(dtzrzf, DtzrzfFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f64,
    lda: *const lapackint,
    tau: *mut f64,
    work: *mut f64,
    lwork: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(stzrzf, StzrzfFnPtr,
    m: *const lapackint,
    n: *const lapackint,
    A: *mut f32,
    lda: *const lapackint,
    tau: *mut f32,
    work: *mut f32,
    lwork: *const lapackint,
    info: *mut lapackint,
);

define_lapack_ffi!(ztzrzf, ZtzrzfFnPtr,
    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
define_lapack_ffi!(cunbdb, CunbdbFnPtr,
    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,
);

define_lapack_ffi!(zunbdb, ZunbdbFnPtr,
    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
define_lapack_ffi!(cuncsd, CuncsdFnPtr,
    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,
);

define_lapack_ffi!(zuncsd, ZuncsdFnPtr,
    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
define_lapack_ffi!(cuncsd2by1, Cuncsd2by1FnPtr,
    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,
);

define_lapack_ffi!(zuncsd2by1, Zuncsd2by1FnPtr,
    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
define_lapack_ffi!(cungbr, CungbrFnPtr,
    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,
);

define_lapack_ffi!(zungbr, ZungbrFnPtr,
    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
define_lapack_ffi!(cunghr, CunghrFnPtr,
    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,
);

define_lapack_ffi!(zunghr, ZunghrFnPtr,
    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
define_lapack_ffi!(cunglq, CunglqFnPtr,
    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,
);

define_lapack_ffi!(zunglq, ZunglqFnPtr,
    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
define_lapack_ffi!(cungql, CungqlFnPtr,
    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,
);

define_lapack_ffi!(zungql, ZungqlFnPtr,
    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
define_lapack_ffi!(cungqr, CungqrFnPtr,
    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,
);

define_lapack_ffi!(zungqr, ZungqrFnPtr,
    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
define_lapack_ffi!(cungrq, CungrqFnPtr,
    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,
);

define_lapack_ffi!(zungrq, ZungrqFnPtr,
    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
define_lapack_ffi!(cungtr, CungtrFnPtr,
    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,
);

define_lapack_ffi!(zungtr, ZungtrFnPtr,
    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
define_lapack_ffi!(cungtsqr_row, Cungtsqr_rowFnPtr,
    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,
);

define_lapack_ffi!(zungtsqr_row, Zungtsqr_rowFnPtr,
    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
define_lapack_ffi!(cunmbr, CunmbrFnPtr,
    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,
);

define_lapack_ffi!(zunmbr, ZunmbrFnPtr,
    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
define_lapack_ffi!(cunmhr, CunmhrFnPtr,
    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,
);

define_lapack_ffi!(zunmhr, ZunmhrFnPtr,
    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
define_lapack_ffi!(cunmlq, CunmlqFnPtr,
    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,
);

define_lapack_ffi!(zunmlq, ZunmlqFnPtr,
    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
define_lapack_ffi!(cunmql, CunmqlFnPtr,
    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,
);

define_lapack_ffi!(zunmql, ZunmqlFnPtr,
    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
define_lapack_ffi!(cunmqr, CunmqrFnPtr,
    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,
);

define_lapack_ffi!(zunmqr, ZunmqrFnPtr,
    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
define_lapack_ffi!(cunmrq, CunmrqFnPtr,
    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,
);

define_lapack_ffi!(zunmrq, ZunmrqFnPtr,
    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
define_lapack_ffi!(cunmrz, CunmrzFnPtr,
    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,
);

define_lapack_ffi!(zunmrz, ZunmrzFnPtr,
    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
define_lapack_ffi!(cunmtr, CunmtrFnPtr,
    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,
);

define_lapack_ffi!(zunmtr, ZunmtrFnPtr,
    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
define_lapack_ffi!(cupgtr, CupgtrFnPtr,
    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,
);

define_lapack_ffi!(zupgtr, ZupgtrFnPtr,
    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
define_lapack_ffi!(cupmtr, CupmtrFnPtr,
    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,
);

define_lapack_ffi!(zupmtr, ZupmtrFnPtr,
    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,
);