rstsr_lapack_ffi/lapack/

dyload_initializer.rs

//! Library initializer implementation for dynamic-loading.
//!
//! This file is generated automatically.

use super::*;
use libloading::{Library, Symbol};

unsafe fn get_symbol<'f, F>(libs: &'f [Library], name: &[u8]) -> Option<Symbol<'f, F>> {
    libs.iter().find_map(|lib| lib.get::<F>(name).ok())
}

impl DyLoadLib {
    pub unsafe fn new(libs: Vec<libloading::Library>, libs_path: Vec<String>) -> DyLoadLib {
        let mut result = DyLoadLib {
            __libraries: vec![],      // dummy here, set this field later
            __libraries_path: vec![], // dummy here, set this field later
            lsame_: get_symbol(&libs, b"lsame_\0").map(|sym| *sym),
            cbbcsd_: get_symbol(&libs, b"cbbcsd_\0").map(|sym| *sym),
            dbbcsd_: get_symbol(&libs, b"dbbcsd_\0").map(|sym| *sym),
            sbbcsd_: get_symbol(&libs, b"sbbcsd_\0").map(|sym| *sym),
            zbbcsd_: get_symbol(&libs, b"zbbcsd_\0").map(|sym| *sym),
            dbdsdc_: get_symbol(&libs, b"dbdsdc_\0").map(|sym| *sym),
            sbdsdc_: get_symbol(&libs, b"sbdsdc_\0").map(|sym| *sym),
            cbdsqr_: get_symbol(&libs, b"cbdsqr_\0").map(|sym| *sym),
            dbdsqr_: get_symbol(&libs, b"dbdsqr_\0").map(|sym| *sym),
            sbdsqr_: get_symbol(&libs, b"sbdsqr_\0").map(|sym| *sym),
            zbdsqr_: get_symbol(&libs, b"zbdsqr_\0").map(|sym| *sym),
            dbdsvdx_: get_symbol(&libs, b"dbdsvdx_\0").map(|sym| *sym),
            sbdsvdx_: get_symbol(&libs, b"sbdsvdx_\0").map(|sym| *sym),
            ddisna_: get_symbol(&libs, b"ddisna_\0").map(|sym| *sym),
            sdisna_: get_symbol(&libs, b"sdisna_\0").map(|sym| *sym),
            cgbbrd_: get_symbol(&libs, b"cgbbrd_\0").map(|sym| *sym),
            dgbbrd_: get_symbol(&libs, b"dgbbrd_\0").map(|sym| *sym),
            sgbbrd_: get_symbol(&libs, b"sgbbrd_\0").map(|sym| *sym),
            zgbbrd_: get_symbol(&libs, b"zgbbrd_\0").map(|sym| *sym),
            cgbcon_: get_symbol(&libs, b"cgbcon_\0").map(|sym| *sym),
            dgbcon_: get_symbol(&libs, b"dgbcon_\0").map(|sym| *sym),
            sgbcon_: get_symbol(&libs, b"sgbcon_\0").map(|sym| *sym),
            zgbcon_: get_symbol(&libs, b"zgbcon_\0").map(|sym| *sym),
            cgbequ_: get_symbol(&libs, b"cgbequ_\0").map(|sym| *sym),
            dgbequ_: get_symbol(&libs, b"dgbequ_\0").map(|sym| *sym),
            sgbequ_: get_symbol(&libs, b"sgbequ_\0").map(|sym| *sym),
            zgbequ_: get_symbol(&libs, b"zgbequ_\0").map(|sym| *sym),
            cgbequb_: get_symbol(&libs, b"cgbequb_\0").map(|sym| *sym),
            dgbequb_: get_symbol(&libs, b"dgbequb_\0").map(|sym| *sym),
            sgbequb_: get_symbol(&libs, b"sgbequb_\0").map(|sym| *sym),
            zgbequb_: get_symbol(&libs, b"zgbequb_\0").map(|sym| *sym),
            cgbrfs_: get_symbol(&libs, b"cgbrfs_\0").map(|sym| *sym),
            dgbrfs_: get_symbol(&libs, b"dgbrfs_\0").map(|sym| *sym),
            sgbrfs_: get_symbol(&libs, b"sgbrfs_\0").map(|sym| *sym),
            zgbrfs_: get_symbol(&libs, b"zgbrfs_\0").map(|sym| *sym),
            cgbrfsx_: get_symbol(&libs, b"cgbrfsx_\0").map(|sym| *sym),
            dgbrfsx_: get_symbol(&libs, b"dgbrfsx_\0").map(|sym| *sym),
            sgbrfsx_: get_symbol(&libs, b"sgbrfsx_\0").map(|sym| *sym),
            zgbrfsx_: get_symbol(&libs, b"zgbrfsx_\0").map(|sym| *sym),
            cgbsv_: get_symbol(&libs, b"cgbsv_\0").map(|sym| *sym),
            dgbsv_: get_symbol(&libs, b"dgbsv_\0").map(|sym| *sym),
            sgbsv_: get_symbol(&libs, b"sgbsv_\0").map(|sym| *sym),
            zgbsv_: get_symbol(&libs, b"zgbsv_\0").map(|sym| *sym),
            cgbsvx_: get_symbol(&libs, b"cgbsvx_\0").map(|sym| *sym),
            dgbsvx_: get_symbol(&libs, b"dgbsvx_\0").map(|sym| *sym),
            sgbsvx_: get_symbol(&libs, b"sgbsvx_\0").map(|sym| *sym),
            zgbsvx_: get_symbol(&libs, b"zgbsvx_\0").map(|sym| *sym),
            cgbsvxx_: get_symbol(&libs, b"cgbsvxx_\0").map(|sym| *sym),
            dgbsvxx_: get_symbol(&libs, b"dgbsvxx_\0").map(|sym| *sym),
            sgbsvxx_: get_symbol(&libs, b"sgbsvxx_\0").map(|sym| *sym),
            zgbsvxx_: get_symbol(&libs, b"zgbsvxx_\0").map(|sym| *sym),
            cgbtrf_: get_symbol(&libs, b"cgbtrf_\0").map(|sym| *sym),
            dgbtrf_: get_symbol(&libs, b"dgbtrf_\0").map(|sym| *sym),
            sgbtrf_: get_symbol(&libs, b"sgbtrf_\0").map(|sym| *sym),
            zgbtrf_: get_symbol(&libs, b"zgbtrf_\0").map(|sym| *sym),
            cgbtrs_: get_symbol(&libs, b"cgbtrs_\0").map(|sym| *sym),
            dgbtrs_: get_symbol(&libs, b"dgbtrs_\0").map(|sym| *sym),
            sgbtrs_: get_symbol(&libs, b"sgbtrs_\0").map(|sym| *sym),
            zgbtrs_: get_symbol(&libs, b"zgbtrs_\0").map(|sym| *sym),
            cgebak_: get_symbol(&libs, b"cgebak_\0").map(|sym| *sym),
            dgebak_: get_symbol(&libs, b"dgebak_\0").map(|sym| *sym),
            sgebak_: get_symbol(&libs, b"sgebak_\0").map(|sym| *sym),
            zgebak_: get_symbol(&libs, b"zgebak_\0").map(|sym| *sym),
            cgebal_: get_symbol(&libs, b"cgebal_\0").map(|sym| *sym),
            dgebal_: get_symbol(&libs, b"dgebal_\0").map(|sym| *sym),
            sgebal_: get_symbol(&libs, b"sgebal_\0").map(|sym| *sym),
            zgebal_: get_symbol(&libs, b"zgebal_\0").map(|sym| *sym),
            cgebrd_: get_symbol(&libs, b"cgebrd_\0").map(|sym| *sym),
            dgebrd_: get_symbol(&libs, b"dgebrd_\0").map(|sym| *sym),
            sgebrd_: get_symbol(&libs, b"sgebrd_\0").map(|sym| *sym),
            zgebrd_: get_symbol(&libs, b"zgebrd_\0").map(|sym| *sym),
            cgecon_: get_symbol(&libs, b"cgecon_\0").map(|sym| *sym),
            dgecon_: get_symbol(&libs, b"dgecon_\0").map(|sym| *sym),
            sgecon_: get_symbol(&libs, b"sgecon_\0").map(|sym| *sym),
            zgecon_: get_symbol(&libs, b"zgecon_\0").map(|sym| *sym),
            cgeequ_: get_symbol(&libs, b"cgeequ_\0").map(|sym| *sym),
            dgeequ_: get_symbol(&libs, b"dgeequ_\0").map(|sym| *sym),
            sgeequ_: get_symbol(&libs, b"sgeequ_\0").map(|sym| *sym),
            zgeequ_: get_symbol(&libs, b"zgeequ_\0").map(|sym| *sym),
            cgeequb_: get_symbol(&libs, b"cgeequb_\0").map(|sym| *sym),
            dgeequb_: get_symbol(&libs, b"dgeequb_\0").map(|sym| *sym),
            sgeequb_: get_symbol(&libs, b"sgeequb_\0").map(|sym| *sym),
            zgeequb_: get_symbol(&libs, b"zgeequb_\0").map(|sym| *sym),
            cgees_: get_symbol(&libs, b"cgees_\0").map(|sym| *sym),
            dgees_: get_symbol(&libs, b"dgees_\0").map(|sym| *sym),
            sgees_: get_symbol(&libs, b"sgees_\0").map(|sym| *sym),
            zgees_: get_symbol(&libs, b"zgees_\0").map(|sym| *sym),
            cgeesx_: get_symbol(&libs, b"cgeesx_\0").map(|sym| *sym),
            dgeesx_: get_symbol(&libs, b"dgeesx_\0").map(|sym| *sym),
            sgeesx_: get_symbol(&libs, b"sgeesx_\0").map(|sym| *sym),
            zgeesx_: get_symbol(&libs, b"zgeesx_\0").map(|sym| *sym),
            cgeev_: get_symbol(&libs, b"cgeev_\0").map(|sym| *sym),
            dgeev_: get_symbol(&libs, b"dgeev_\0").map(|sym| *sym),
            sgeev_: get_symbol(&libs, b"sgeev_\0").map(|sym| *sym),
            zgeev_: get_symbol(&libs, b"zgeev_\0").map(|sym| *sym),
            cgeevx_: get_symbol(&libs, b"cgeevx_\0").map(|sym| *sym),
            dgeevx_: get_symbol(&libs, b"dgeevx_\0").map(|sym| *sym),
            sgeevx_: get_symbol(&libs, b"sgeevx_\0").map(|sym| *sym),
            zgeevx_: get_symbol(&libs, b"zgeevx_\0").map(|sym| *sym),
            cgehrd_: get_symbol(&libs, b"cgehrd_\0").map(|sym| *sym),
            dgehrd_: get_symbol(&libs, b"dgehrd_\0").map(|sym| *sym),
            sgehrd_: get_symbol(&libs, b"sgehrd_\0").map(|sym| *sym),
            zgehrd_: get_symbol(&libs, b"zgehrd_\0").map(|sym| *sym),
            cgejsv_: get_symbol(&libs, b"cgejsv_\0").map(|sym| *sym),
            dgejsv_: get_symbol(&libs, b"dgejsv_\0").map(|sym| *sym),
            sgejsv_: get_symbol(&libs, b"sgejsv_\0").map(|sym| *sym),
            zgejsv_: get_symbol(&libs, b"zgejsv_\0").map(|sym| *sym),
            cgelq_: get_symbol(&libs, b"cgelq_\0").map(|sym| *sym),
            dgelq_: get_symbol(&libs, b"dgelq_\0").map(|sym| *sym),
            sgelq_: get_symbol(&libs, b"sgelq_\0").map(|sym| *sym),
            zgelq_: get_symbol(&libs, b"zgelq_\0").map(|sym| *sym),
            cgelq2_: get_symbol(&libs, b"cgelq2_\0").map(|sym| *sym),
            dgelq2_: get_symbol(&libs, b"dgelq2_\0").map(|sym| *sym),
            sgelq2_: get_symbol(&libs, b"sgelq2_\0").map(|sym| *sym),
            zgelq2_: get_symbol(&libs, b"zgelq2_\0").map(|sym| *sym),
            cgelqf_: get_symbol(&libs, b"cgelqf_\0").map(|sym| *sym),
            dgelqf_: get_symbol(&libs, b"dgelqf_\0").map(|sym| *sym),
            sgelqf_: get_symbol(&libs, b"sgelqf_\0").map(|sym| *sym),
            zgelqf_: get_symbol(&libs, b"zgelqf_\0").map(|sym| *sym),
            cgels_: get_symbol(&libs, b"cgels_\0").map(|sym| *sym),
            dgels_: get_symbol(&libs, b"dgels_\0").map(|sym| *sym),
            sgels_: get_symbol(&libs, b"sgels_\0").map(|sym| *sym),
            zgels_: get_symbol(&libs, b"zgels_\0").map(|sym| *sym),
            cgelsd_: get_symbol(&libs, b"cgelsd_\0").map(|sym| *sym),
            dgelsd_: get_symbol(&libs, b"dgelsd_\0").map(|sym| *sym),
            sgelsd_: get_symbol(&libs, b"sgelsd_\0").map(|sym| *sym),
            zgelsd_: get_symbol(&libs, b"zgelsd_\0").map(|sym| *sym),
            cgelss_: get_symbol(&libs, b"cgelss_\0").map(|sym| *sym),
            dgelss_: get_symbol(&libs, b"dgelss_\0").map(|sym| *sym),
            sgelss_: get_symbol(&libs, b"sgelss_\0").map(|sym| *sym),
            zgelss_: get_symbol(&libs, b"zgelss_\0").map(|sym| *sym),
            cgelsy_: get_symbol(&libs, b"cgelsy_\0").map(|sym| *sym),
            dgelsy_: get_symbol(&libs, b"dgelsy_\0").map(|sym| *sym),
            sgelsy_: get_symbol(&libs, b"sgelsy_\0").map(|sym| *sym),
            zgelsy_: get_symbol(&libs, b"zgelsy_\0").map(|sym| *sym),
            cgemlq_: get_symbol(&libs, b"cgemlq_\0").map(|sym| *sym),
            dgemlq_: get_symbol(&libs, b"dgemlq_\0").map(|sym| *sym),
            sgemlq_: get_symbol(&libs, b"sgemlq_\0").map(|sym| *sym),
            zgemlq_: get_symbol(&libs, b"zgemlq_\0").map(|sym| *sym),
            cgemqr_: get_symbol(&libs, b"cgemqr_\0").map(|sym| *sym),
            dgemqr_: get_symbol(&libs, b"dgemqr_\0").map(|sym| *sym),
            sgemqr_: get_symbol(&libs, b"sgemqr_\0").map(|sym| *sym),
            zgemqr_: get_symbol(&libs, b"zgemqr_\0").map(|sym| *sym),
            cgemqrt_: get_symbol(&libs, b"cgemqrt_\0").map(|sym| *sym),
            dgemqrt_: get_symbol(&libs, b"dgemqrt_\0").map(|sym| *sym),
            sgemqrt_: get_symbol(&libs, b"sgemqrt_\0").map(|sym| *sym),
            zgemqrt_: get_symbol(&libs, b"zgemqrt_\0").map(|sym| *sym),
            cgeql2_: get_symbol(&libs, b"cgeql2_\0").map(|sym| *sym),
            dgeql2_: get_symbol(&libs, b"dgeql2_\0").map(|sym| *sym),
            sgeql2_: get_symbol(&libs, b"sgeql2_\0").map(|sym| *sym),
            zgeql2_: get_symbol(&libs, b"zgeql2_\0").map(|sym| *sym),
            cgeqlf_: get_symbol(&libs, b"cgeqlf_\0").map(|sym| *sym),
            dgeqlf_: get_symbol(&libs, b"dgeqlf_\0").map(|sym| *sym),
            sgeqlf_: get_symbol(&libs, b"sgeqlf_\0").map(|sym| *sym),
            zgeqlf_: get_symbol(&libs, b"zgeqlf_\0").map(|sym| *sym),
            sgeqpf_: get_symbol(&libs, b"sgeqpf_\0").map(|sym| *sym),
            dgeqpf_: get_symbol(&libs, b"dgeqpf_\0").map(|sym| *sym),
            cgeqpf_: get_symbol(&libs, b"cgeqpf_\0").map(|sym| *sym),
            zgeqpf_: get_symbol(&libs, b"zgeqpf_\0").map(|sym| *sym),
            cgeqp3_: get_symbol(&libs, b"cgeqp3_\0").map(|sym| *sym),
            dgeqp3_: get_symbol(&libs, b"dgeqp3_\0").map(|sym| *sym),
            sgeqp3_: get_symbol(&libs, b"sgeqp3_\0").map(|sym| *sym),
            zgeqp3_: get_symbol(&libs, b"zgeqp3_\0").map(|sym| *sym),
            cgeqr_: get_symbol(&libs, b"cgeqr_\0").map(|sym| *sym),
            dgeqr_: get_symbol(&libs, b"dgeqr_\0").map(|sym| *sym),
            sgeqr_: get_symbol(&libs, b"sgeqr_\0").map(|sym| *sym),
            zgeqr_: get_symbol(&libs, b"zgeqr_\0").map(|sym| *sym),
            cgeqr2_: get_symbol(&libs, b"cgeqr2_\0").map(|sym| *sym),
            dgeqr2_: get_symbol(&libs, b"dgeqr2_\0").map(|sym| *sym),
            sgeqr2_: get_symbol(&libs, b"sgeqr2_\0").map(|sym| *sym),
            zgeqr2_: get_symbol(&libs, b"zgeqr2_\0").map(|sym| *sym),
            cgeqrf_: get_symbol(&libs, b"cgeqrf_\0").map(|sym| *sym),
            dgeqrf_: get_symbol(&libs, b"dgeqrf_\0").map(|sym| *sym),
            sgeqrf_: get_symbol(&libs, b"sgeqrf_\0").map(|sym| *sym),
            zgeqrf_: get_symbol(&libs, b"zgeqrf_\0").map(|sym| *sym),
            cgeqrfp_: get_symbol(&libs, b"cgeqrfp_\0").map(|sym| *sym),
            dgeqrfp_: get_symbol(&libs, b"dgeqrfp_\0").map(|sym| *sym),
            sgeqrfp_: get_symbol(&libs, b"sgeqrfp_\0").map(|sym| *sym),
            zgeqrfp_: get_symbol(&libs, b"zgeqrfp_\0").map(|sym| *sym),
            cgeqrt_: get_symbol(&libs, b"cgeqrt_\0").map(|sym| *sym),
            dgeqrt_: get_symbol(&libs, b"dgeqrt_\0").map(|sym| *sym),
            sgeqrt_: get_symbol(&libs, b"sgeqrt_\0").map(|sym| *sym),
            zgeqrt_: get_symbol(&libs, b"zgeqrt_\0").map(|sym| *sym),
            cgeqrt2_: get_symbol(&libs, b"cgeqrt2_\0").map(|sym| *sym),
            dgeqrt2_: get_symbol(&libs, b"dgeqrt2_\0").map(|sym| *sym),
            sgeqrt2_: get_symbol(&libs, b"sgeqrt2_\0").map(|sym| *sym),
            zgeqrt2_: get_symbol(&libs, b"zgeqrt2_\0").map(|sym| *sym),
            cgeqrt3_: get_symbol(&libs, b"cgeqrt3_\0").map(|sym| *sym),
            dgeqrt3_: get_symbol(&libs, b"dgeqrt3_\0").map(|sym| *sym),
            sgeqrt3_: get_symbol(&libs, b"sgeqrt3_\0").map(|sym| *sym),
            zgeqrt3_: get_symbol(&libs, b"zgeqrt3_\0").map(|sym| *sym),
            cgerfs_: get_symbol(&libs, b"cgerfs_\0").map(|sym| *sym),
            dgerfs_: get_symbol(&libs, b"dgerfs_\0").map(|sym| *sym),
            sgerfs_: get_symbol(&libs, b"sgerfs_\0").map(|sym| *sym),
            zgerfs_: get_symbol(&libs, b"zgerfs_\0").map(|sym| *sym),
            cgerfsx_: get_symbol(&libs, b"cgerfsx_\0").map(|sym| *sym),
            dgerfsx_: get_symbol(&libs, b"dgerfsx_\0").map(|sym| *sym),
            sgerfsx_: get_symbol(&libs, b"sgerfsx_\0").map(|sym| *sym),
            zgerfsx_: get_symbol(&libs, b"zgerfsx_\0").map(|sym| *sym),
            cgerq2_: get_symbol(&libs, b"cgerq2_\0").map(|sym| *sym),
            dgerq2_: get_symbol(&libs, b"dgerq2_\0").map(|sym| *sym),
            sgerq2_: get_symbol(&libs, b"sgerq2_\0").map(|sym| *sym),
            zgerq2_: get_symbol(&libs, b"zgerq2_\0").map(|sym| *sym),
            cgerqf_: get_symbol(&libs, b"cgerqf_\0").map(|sym| *sym),
            dgerqf_: get_symbol(&libs, b"dgerqf_\0").map(|sym| *sym),
            sgerqf_: get_symbol(&libs, b"sgerqf_\0").map(|sym| *sym),
            zgerqf_: get_symbol(&libs, b"zgerqf_\0").map(|sym| *sym),
            cgesdd_: get_symbol(&libs, b"cgesdd_\0").map(|sym| *sym),
            dgesdd_: get_symbol(&libs, b"dgesdd_\0").map(|sym| *sym),
            sgesdd_: get_symbol(&libs, b"sgesdd_\0").map(|sym| *sym),
            zgesdd_: get_symbol(&libs, b"zgesdd_\0").map(|sym| *sym),
            cgedmd_: get_symbol(&libs, b"cgedmd_\0").map(|sym| *sym),
            dgedmd_: get_symbol(&libs, b"dgedmd_\0").map(|sym| *sym),
            sgedmd_: get_symbol(&libs, b"sgedmd_\0").map(|sym| *sym),
            zgedmd_: get_symbol(&libs, b"zgedmd_\0").map(|sym| *sym),
            cgedmdq_: get_symbol(&libs, b"cgedmdq_\0").map(|sym| *sym),
            dgedmdq_: get_symbol(&libs, b"dgedmdq_\0").map(|sym| *sym),
            sgedmdq_: get_symbol(&libs, b"sgedmdq_\0").map(|sym| *sym),
            zgedmdq_: get_symbol(&libs, b"zgedmdq_\0").map(|sym| *sym),
            cgesv_: get_symbol(&libs, b"cgesv_\0").map(|sym| *sym),
            dgesv_: get_symbol(&libs, b"dgesv_\0").map(|sym| *sym),
            sgesv_: get_symbol(&libs, b"sgesv_\0").map(|sym| *sym),
            zgesv_: get_symbol(&libs, b"zgesv_\0").map(|sym| *sym),
            dsgesv_: get_symbol(&libs, b"dsgesv_\0").map(|sym| *sym),
            zcgesv_: get_symbol(&libs, b"zcgesv_\0").map(|sym| *sym),
            cgesvd_: get_symbol(&libs, b"cgesvd_\0").map(|sym| *sym),
            dgesvd_: get_symbol(&libs, b"dgesvd_\0").map(|sym| *sym),
            sgesvd_: get_symbol(&libs, b"sgesvd_\0").map(|sym| *sym),
            zgesvd_: get_symbol(&libs, b"zgesvd_\0").map(|sym| *sym),
            cgesvdq_: get_symbol(&libs, b"cgesvdq_\0").map(|sym| *sym),
            dgesvdq_: get_symbol(&libs, b"dgesvdq_\0").map(|sym| *sym),
            sgesvdq_: get_symbol(&libs, b"sgesvdq_\0").map(|sym| *sym),
            zgesvdq_: get_symbol(&libs, b"zgesvdq_\0").map(|sym| *sym),
            cgesvdx_: get_symbol(&libs, b"cgesvdx_\0").map(|sym| *sym),
            dgesvdx_: get_symbol(&libs, b"dgesvdx_\0").map(|sym| *sym),
            sgesvdx_: get_symbol(&libs, b"sgesvdx_\0").map(|sym| *sym),
            zgesvdx_: get_symbol(&libs, b"zgesvdx_\0").map(|sym| *sym),
            cgesvj_: get_symbol(&libs, b"cgesvj_\0").map(|sym| *sym),
            dgesvj_: get_symbol(&libs, b"dgesvj_\0").map(|sym| *sym),
            sgesvj_: get_symbol(&libs, b"sgesvj_\0").map(|sym| *sym),
            zgesvj_: get_symbol(&libs, b"zgesvj_\0").map(|sym| *sym),
            cgesvx_: get_symbol(&libs, b"cgesvx_\0").map(|sym| *sym),
            dgesvx_: get_symbol(&libs, b"dgesvx_\0").map(|sym| *sym),
            sgesvx_: get_symbol(&libs, b"sgesvx_\0").map(|sym| *sym),
            zgesvx_: get_symbol(&libs, b"zgesvx_\0").map(|sym| *sym),
            cgesvxx_: get_symbol(&libs, b"cgesvxx_\0").map(|sym| *sym),
            dgesvxx_: get_symbol(&libs, b"dgesvxx_\0").map(|sym| *sym),
            sgesvxx_: get_symbol(&libs, b"sgesvxx_\0").map(|sym| *sym),
            zgesvxx_: get_symbol(&libs, b"zgesvxx_\0").map(|sym| *sym),
            cgetf2_: get_symbol(&libs, b"cgetf2_\0").map(|sym| *sym),
            dgetf2_: get_symbol(&libs, b"dgetf2_\0").map(|sym| *sym),
            sgetf2_: get_symbol(&libs, b"sgetf2_\0").map(|sym| *sym),
            zgetf2_: get_symbol(&libs, b"zgetf2_\0").map(|sym| *sym),
            cgetrf_: get_symbol(&libs, b"cgetrf_\0").map(|sym| *sym),
            dgetrf_: get_symbol(&libs, b"dgetrf_\0").map(|sym| *sym),
            sgetrf_: get_symbol(&libs, b"sgetrf_\0").map(|sym| *sym),
            zgetrf_: get_symbol(&libs, b"zgetrf_\0").map(|sym| *sym),
            cgetrf2_: get_symbol(&libs, b"cgetrf2_\0").map(|sym| *sym),
            dgetrf2_: get_symbol(&libs, b"dgetrf2_\0").map(|sym| *sym),
            sgetrf2_: get_symbol(&libs, b"sgetrf2_\0").map(|sym| *sym),
            zgetrf2_: get_symbol(&libs, b"zgetrf2_\0").map(|sym| *sym),
            cgetri_: get_symbol(&libs, b"cgetri_\0").map(|sym| *sym),
            dgetri_: get_symbol(&libs, b"dgetri_\0").map(|sym| *sym),
            sgetri_: get_symbol(&libs, b"sgetri_\0").map(|sym| *sym),
            zgetri_: get_symbol(&libs, b"zgetri_\0").map(|sym| *sym),
            cgetrs_: get_symbol(&libs, b"cgetrs_\0").map(|sym| *sym),
            dgetrs_: get_symbol(&libs, b"dgetrs_\0").map(|sym| *sym),
            sgetrs_: get_symbol(&libs, b"sgetrs_\0").map(|sym| *sym),
            zgetrs_: get_symbol(&libs, b"zgetrs_\0").map(|sym| *sym),
            cgetsls_: get_symbol(&libs, b"cgetsls_\0").map(|sym| *sym),
            dgetsls_: get_symbol(&libs, b"dgetsls_\0").map(|sym| *sym),
            sgetsls_: get_symbol(&libs, b"sgetsls_\0").map(|sym| *sym),
            zgetsls_: get_symbol(&libs, b"zgetsls_\0").map(|sym| *sym),
            cgetsqrhrt_: get_symbol(&libs, b"cgetsqrhrt_\0").map(|sym| *sym),
            dgetsqrhrt_: get_symbol(&libs, b"dgetsqrhrt_\0").map(|sym| *sym),
            sgetsqrhrt_: get_symbol(&libs, b"sgetsqrhrt_\0").map(|sym| *sym),
            zgetsqrhrt_: get_symbol(&libs, b"zgetsqrhrt_\0").map(|sym| *sym),
            cggbak_: get_symbol(&libs, b"cggbak_\0").map(|sym| *sym),
            dggbak_: get_symbol(&libs, b"dggbak_\0").map(|sym| *sym),
            sggbak_: get_symbol(&libs, b"sggbak_\0").map(|sym| *sym),
            zggbak_: get_symbol(&libs, b"zggbak_\0").map(|sym| *sym),
            cggbal_: get_symbol(&libs, b"cggbal_\0").map(|sym| *sym),
            dggbal_: get_symbol(&libs, b"dggbal_\0").map(|sym| *sym),
            sggbal_: get_symbol(&libs, b"sggbal_\0").map(|sym| *sym),
            zggbal_: get_symbol(&libs, b"zggbal_\0").map(|sym| *sym),
            cgges_: get_symbol(&libs, b"cgges_\0").map(|sym| *sym),
            dgges_: get_symbol(&libs, b"dgges_\0").map(|sym| *sym),
            sgges_: get_symbol(&libs, b"sgges_\0").map(|sym| *sym),
            zgges_: get_symbol(&libs, b"zgges_\0").map(|sym| *sym),
            cgges3_: get_symbol(&libs, b"cgges3_\0").map(|sym| *sym),
            dgges3_: get_symbol(&libs, b"dgges3_\0").map(|sym| *sym),
            sgges3_: get_symbol(&libs, b"sgges3_\0").map(|sym| *sym),
            zgges3_: get_symbol(&libs, b"zgges3_\0").map(|sym| *sym),
            cggesx_: get_symbol(&libs, b"cggesx_\0").map(|sym| *sym),
            dggesx_: get_symbol(&libs, b"dggesx_\0").map(|sym| *sym),
            sggesx_: get_symbol(&libs, b"sggesx_\0").map(|sym| *sym),
            zggesx_: get_symbol(&libs, b"zggesx_\0").map(|sym| *sym),
            cggev_: get_symbol(&libs, b"cggev_\0").map(|sym| *sym),
            dggev_: get_symbol(&libs, b"dggev_\0").map(|sym| *sym),
            sggev_: get_symbol(&libs, b"sggev_\0").map(|sym| *sym),
            zggev_: get_symbol(&libs, b"zggev_\0").map(|sym| *sym),
            cggev3_: get_symbol(&libs, b"cggev3_\0").map(|sym| *sym),
            dggev3_: get_symbol(&libs, b"dggev3_\0").map(|sym| *sym),
            sggev3_: get_symbol(&libs, b"sggev3_\0").map(|sym| *sym),
            zggev3_: get_symbol(&libs, b"zggev3_\0").map(|sym| *sym),
            cggevx_: get_symbol(&libs, b"cggevx_\0").map(|sym| *sym),
            dggevx_: get_symbol(&libs, b"dggevx_\0").map(|sym| *sym),
            sggevx_: get_symbol(&libs, b"sggevx_\0").map(|sym| *sym),
            zggevx_: get_symbol(&libs, b"zggevx_\0").map(|sym| *sym),
            cggglm_: get_symbol(&libs, b"cggglm_\0").map(|sym| *sym),
            dggglm_: get_symbol(&libs, b"dggglm_\0").map(|sym| *sym),
            sggglm_: get_symbol(&libs, b"sggglm_\0").map(|sym| *sym),
            zggglm_: get_symbol(&libs, b"zggglm_\0").map(|sym| *sym),
            cgghd3_: get_symbol(&libs, b"cgghd3_\0").map(|sym| *sym),
            dgghd3_: get_symbol(&libs, b"dgghd3_\0").map(|sym| *sym),
            sgghd3_: get_symbol(&libs, b"sgghd3_\0").map(|sym| *sym),
            zgghd3_: get_symbol(&libs, b"zgghd3_\0").map(|sym| *sym),
            cgghrd_: get_symbol(&libs, b"cgghrd_\0").map(|sym| *sym),
            dgghrd_: get_symbol(&libs, b"dgghrd_\0").map(|sym| *sym),
            sgghrd_: get_symbol(&libs, b"sgghrd_\0").map(|sym| *sym),
            zgghrd_: get_symbol(&libs, b"zgghrd_\0").map(|sym| *sym),
            cgglse_: get_symbol(&libs, b"cgglse_\0").map(|sym| *sym),
            dgglse_: get_symbol(&libs, b"dgglse_\0").map(|sym| *sym),
            sgglse_: get_symbol(&libs, b"sgglse_\0").map(|sym| *sym),
            zgglse_: get_symbol(&libs, b"zgglse_\0").map(|sym| *sym),
            cggqrf_: get_symbol(&libs, b"cggqrf_\0").map(|sym| *sym),
            dggqrf_: get_symbol(&libs, b"dggqrf_\0").map(|sym| *sym),
            sggqrf_: get_symbol(&libs, b"sggqrf_\0").map(|sym| *sym),
            zggqrf_: get_symbol(&libs, b"zggqrf_\0").map(|sym| *sym),
            cggrqf_: get_symbol(&libs, b"cggrqf_\0").map(|sym| *sym),
            dggrqf_: get_symbol(&libs, b"dggrqf_\0").map(|sym| *sym),
            sggrqf_: get_symbol(&libs, b"sggrqf_\0").map(|sym| *sym),
            zggrqf_: get_symbol(&libs, b"zggrqf_\0").map(|sym| *sym),
            cggsvd_: get_symbol(&libs, b"cggsvd_\0").map(|sym| *sym),
            sggsvd_: get_symbol(&libs, b"sggsvd_\0").map(|sym| *sym),
            dggsvd_: get_symbol(&libs, b"dggsvd_\0").map(|sym| *sym),
            zggsvd_: get_symbol(&libs, b"zggsvd_\0").map(|sym| *sym),
            cggsvd3_: get_symbol(&libs, b"cggsvd3_\0").map(|sym| *sym),
            dggsvd3_: get_symbol(&libs, b"dggsvd3_\0").map(|sym| *sym),
            sggsvd3_: get_symbol(&libs, b"sggsvd3_\0").map(|sym| *sym),
            zggsvd3_: get_symbol(&libs, b"zggsvd3_\0").map(|sym| *sym),
            sggsvp_: get_symbol(&libs, b"sggsvp_\0").map(|sym| *sym),
            dggsvp_: get_symbol(&libs, b"dggsvp_\0").map(|sym| *sym),
            cggsvp_: get_symbol(&libs, b"cggsvp_\0").map(|sym| *sym),
            zggsvp_: get_symbol(&libs, b"zggsvp_\0").map(|sym| *sym),
            cggsvp3_: get_symbol(&libs, b"cggsvp3_\0").map(|sym| *sym),
            dggsvp3_: get_symbol(&libs, b"dggsvp3_\0").map(|sym| *sym),
            sggsvp3_: get_symbol(&libs, b"sggsvp3_\0").map(|sym| *sym),
            zggsvp3_: get_symbol(&libs, b"zggsvp3_\0").map(|sym| *sym),
            cgtcon_: get_symbol(&libs, b"cgtcon_\0").map(|sym| *sym),
            dgtcon_: get_symbol(&libs, b"dgtcon_\0").map(|sym| *sym),
            sgtcon_: get_symbol(&libs, b"sgtcon_\0").map(|sym| *sym),
            zgtcon_: get_symbol(&libs, b"zgtcon_\0").map(|sym| *sym),
            cgtrfs_: get_symbol(&libs, b"cgtrfs_\0").map(|sym| *sym),
            dgtrfs_: get_symbol(&libs, b"dgtrfs_\0").map(|sym| *sym),
            sgtrfs_: get_symbol(&libs, b"sgtrfs_\0").map(|sym| *sym),
            zgtrfs_: get_symbol(&libs, b"zgtrfs_\0").map(|sym| *sym),
            cgtsv_: get_symbol(&libs, b"cgtsv_\0").map(|sym| *sym),
            dgtsv_: get_symbol(&libs, b"dgtsv_\0").map(|sym| *sym),
            sgtsv_: get_symbol(&libs, b"sgtsv_\0").map(|sym| *sym),
            zgtsv_: get_symbol(&libs, b"zgtsv_\0").map(|sym| *sym),
            cgtsvx_: get_symbol(&libs, b"cgtsvx_\0").map(|sym| *sym),
            dgtsvx_: get_symbol(&libs, b"dgtsvx_\0").map(|sym| *sym),
            sgtsvx_: get_symbol(&libs, b"sgtsvx_\0").map(|sym| *sym),
            zgtsvx_: get_symbol(&libs, b"zgtsvx_\0").map(|sym| *sym),
            cgttrf_: get_symbol(&libs, b"cgttrf_\0").map(|sym| *sym),
            dgttrf_: get_symbol(&libs, b"dgttrf_\0").map(|sym| *sym),
            sgttrf_: get_symbol(&libs, b"sgttrf_\0").map(|sym| *sym),
            zgttrf_: get_symbol(&libs, b"zgttrf_\0").map(|sym| *sym),
            cgttrs_: get_symbol(&libs, b"cgttrs_\0").map(|sym| *sym),
            dgttrs_: get_symbol(&libs, b"dgttrs_\0").map(|sym| *sym),
            sgttrs_: get_symbol(&libs, b"sgttrs_\0").map(|sym| *sym),
            zgttrs_: get_symbol(&libs, b"zgttrs_\0").map(|sym| *sym),
            chbev_: get_symbol(&libs, b"chbev_\0").map(|sym| *sym),
            zhbev_: get_symbol(&libs, b"zhbev_\0").map(|sym| *sym),
            chbev_2stage_: get_symbol(&libs, b"chbev_2stage_\0").map(|sym| *sym),
            zhbev_2stage_: get_symbol(&libs, b"zhbev_2stage_\0").map(|sym| *sym),
            chbevd_: get_symbol(&libs, b"chbevd_\0").map(|sym| *sym),
            zhbevd_: get_symbol(&libs, b"zhbevd_\0").map(|sym| *sym),
            chbevd_2stage_: get_symbol(&libs, b"chbevd_2stage_\0").map(|sym| *sym),
            zhbevd_2stage_: get_symbol(&libs, b"zhbevd_2stage_\0").map(|sym| *sym),
            chbevx_: get_symbol(&libs, b"chbevx_\0").map(|sym| *sym),
            zhbevx_: get_symbol(&libs, b"zhbevx_\0").map(|sym| *sym),
            chbevx_2stage_: get_symbol(&libs, b"chbevx_2stage_\0").map(|sym| *sym),
            zhbevx_2stage_: get_symbol(&libs, b"zhbevx_2stage_\0").map(|sym| *sym),
            chbgst_: get_symbol(&libs, b"chbgst_\0").map(|sym| *sym),
            zhbgst_: get_symbol(&libs, b"zhbgst_\0").map(|sym| *sym),
            chbgv_: get_symbol(&libs, b"chbgv_\0").map(|sym| *sym),
            zhbgv_: get_symbol(&libs, b"zhbgv_\0").map(|sym| *sym),
            chbgvd_: get_symbol(&libs, b"chbgvd_\0").map(|sym| *sym),
            zhbgvd_: get_symbol(&libs, b"zhbgvd_\0").map(|sym| *sym),
            chbgvx_: get_symbol(&libs, b"chbgvx_\0").map(|sym| *sym),
            zhbgvx_: get_symbol(&libs, b"zhbgvx_\0").map(|sym| *sym),
            chbtrd_: get_symbol(&libs, b"chbtrd_\0").map(|sym| *sym),
            zhbtrd_: get_symbol(&libs, b"zhbtrd_\0").map(|sym| *sym),
            checon_: get_symbol(&libs, b"checon_\0").map(|sym| *sym),
            zhecon_: get_symbol(&libs, b"zhecon_\0").map(|sym| *sym),
            checon_3_: get_symbol(&libs, b"checon_3_\0").map(|sym| *sym),
            zhecon_3_: get_symbol(&libs, b"zhecon_3_\0").map(|sym| *sym),
            cheequb_: get_symbol(&libs, b"cheequb_\0").map(|sym| *sym),
            zheequb_: get_symbol(&libs, b"zheequb_\0").map(|sym| *sym),
            cheev_: get_symbol(&libs, b"cheev_\0").map(|sym| *sym),
            zheev_: get_symbol(&libs, b"zheev_\0").map(|sym| *sym),
            cheev_2stage_: get_symbol(&libs, b"cheev_2stage_\0").map(|sym| *sym),
            zheev_2stage_: get_symbol(&libs, b"zheev_2stage_\0").map(|sym| *sym),
            cheevd_: get_symbol(&libs, b"cheevd_\0").map(|sym| *sym),
            zheevd_: get_symbol(&libs, b"zheevd_\0").map(|sym| *sym),
            cheevd_2stage_: get_symbol(&libs, b"cheevd_2stage_\0").map(|sym| *sym),
            zheevd_2stage_: get_symbol(&libs, b"zheevd_2stage_\0").map(|sym| *sym),
            cheevr_: get_symbol(&libs, b"cheevr_\0").map(|sym| *sym),
            zheevr_: get_symbol(&libs, b"zheevr_\0").map(|sym| *sym),
            cheevr_2stage_: get_symbol(&libs, b"cheevr_2stage_\0").map(|sym| *sym),
            zheevr_2stage_: get_symbol(&libs, b"zheevr_2stage_\0").map(|sym| *sym),
            cheevx_: get_symbol(&libs, b"cheevx_\0").map(|sym| *sym),
            zheevx_: get_symbol(&libs, b"zheevx_\0").map(|sym| *sym),
            cheevx_2stage_: get_symbol(&libs, b"cheevx_2stage_\0").map(|sym| *sym),
            zheevx_2stage_: get_symbol(&libs, b"zheevx_2stage_\0").map(|sym| *sym),
            chegst_: get_symbol(&libs, b"chegst_\0").map(|sym| *sym),
            zhegst_: get_symbol(&libs, b"zhegst_\0").map(|sym| *sym),
            chegv_: get_symbol(&libs, b"chegv_\0").map(|sym| *sym),
            zhegv_: get_symbol(&libs, b"zhegv_\0").map(|sym| *sym),
            chegv_2stage_: get_symbol(&libs, b"chegv_2stage_\0").map(|sym| *sym),
            zhegv_2stage_: get_symbol(&libs, b"zhegv_2stage_\0").map(|sym| *sym),
            chegvd_: get_symbol(&libs, b"chegvd_\0").map(|sym| *sym),
            zhegvd_: get_symbol(&libs, b"zhegvd_\0").map(|sym| *sym),
            chegvx_: get_symbol(&libs, b"chegvx_\0").map(|sym| *sym),
            zhegvx_: get_symbol(&libs, b"zhegvx_\0").map(|sym| *sym),
            cherfs_: get_symbol(&libs, b"cherfs_\0").map(|sym| *sym),
            zherfs_: get_symbol(&libs, b"zherfs_\0").map(|sym| *sym),
            cherfsx_: get_symbol(&libs, b"cherfsx_\0").map(|sym| *sym),
            zherfsx_: get_symbol(&libs, b"zherfsx_\0").map(|sym| *sym),
            chesv_: get_symbol(&libs, b"chesv_\0").map(|sym| *sym),
            zhesv_: get_symbol(&libs, b"zhesv_\0").map(|sym| *sym),
            chesv_aa_: get_symbol(&libs, b"chesv_aa_\0").map(|sym| *sym),
            zhesv_aa_: get_symbol(&libs, b"zhesv_aa_\0").map(|sym| *sym),
            chesv_aa_2stage_: get_symbol(&libs, b"chesv_aa_2stage_\0").map(|sym| *sym),
            zhesv_aa_2stage_: get_symbol(&libs, b"zhesv_aa_2stage_\0").map(|sym| *sym),
            chesv_rk_: get_symbol(&libs, b"chesv_rk_\0").map(|sym| *sym),
            zhesv_rk_: get_symbol(&libs, b"zhesv_rk_\0").map(|sym| *sym),
            chesv_rook_: get_symbol(&libs, b"chesv_rook_\0").map(|sym| *sym),
            zhesv_rook_: get_symbol(&libs, b"zhesv_rook_\0").map(|sym| *sym),
            chesvx_: get_symbol(&libs, b"chesvx_\0").map(|sym| *sym),
            zhesvx_: get_symbol(&libs, b"zhesvx_\0").map(|sym| *sym),
            chesvxx_: get_symbol(&libs, b"chesvxx_\0").map(|sym| *sym),
            zhesvxx_: get_symbol(&libs, b"zhesvxx_\0").map(|sym| *sym),
            cheswapr_: get_symbol(&libs, b"cheswapr_\0").map(|sym| *sym),
            zheswapr_: get_symbol(&libs, b"zheswapr_\0").map(|sym| *sym),
            chetrd_: get_symbol(&libs, b"chetrd_\0").map(|sym| *sym),
            zhetrd_: get_symbol(&libs, b"zhetrd_\0").map(|sym| *sym),
            chetrd_2stage_: get_symbol(&libs, b"chetrd_2stage_\0").map(|sym| *sym),
            zhetrd_2stage_: get_symbol(&libs, b"zhetrd_2stage_\0").map(|sym| *sym),
            chetrf_: get_symbol(&libs, b"chetrf_\0").map(|sym| *sym),
            zhetrf_: get_symbol(&libs, b"zhetrf_\0").map(|sym| *sym),
            chetrf_aa_: get_symbol(&libs, b"chetrf_aa_\0").map(|sym| *sym),
            zhetrf_aa_: get_symbol(&libs, b"zhetrf_aa_\0").map(|sym| *sym),
            chetrf_aa_2stage_: get_symbol(&libs, b"chetrf_aa_2stage_\0").map(|sym| *sym),
            zhetrf_aa_2stage_: get_symbol(&libs, b"zhetrf_aa_2stage_\0").map(|sym| *sym),
            chetrf_rk_: get_symbol(&libs, b"chetrf_rk_\0").map(|sym| *sym),
            zhetrf_rk_: get_symbol(&libs, b"zhetrf_rk_\0").map(|sym| *sym),
            chetrf_rook_: get_symbol(&libs, b"chetrf_rook_\0").map(|sym| *sym),
            zhetrf_rook_: get_symbol(&libs, b"zhetrf_rook_\0").map(|sym| *sym),
            chetri_: get_symbol(&libs, b"chetri_\0").map(|sym| *sym),
            zhetri_: get_symbol(&libs, b"zhetri_\0").map(|sym| *sym),
            chetri2_: get_symbol(&libs, b"chetri2_\0").map(|sym| *sym),
            zhetri2_: get_symbol(&libs, b"zhetri2_\0").map(|sym| *sym),
            chetri2x_: get_symbol(&libs, b"chetri2x_\0").map(|sym| *sym),
            zhetri2x_: get_symbol(&libs, b"zhetri2x_\0").map(|sym| *sym),
            chetri_3_: get_symbol(&libs, b"chetri_3_\0").map(|sym| *sym),
            zhetri_3_: get_symbol(&libs, b"zhetri_3_\0").map(|sym| *sym),
            chetrs_: get_symbol(&libs, b"chetrs_\0").map(|sym| *sym),
            zhetrs_: get_symbol(&libs, b"zhetrs_\0").map(|sym| *sym),
            chetrs2_: get_symbol(&libs, b"chetrs2_\0").map(|sym| *sym),
            zhetrs2_: get_symbol(&libs, b"zhetrs2_\0").map(|sym| *sym),
            chetrs_3_: get_symbol(&libs, b"chetrs_3_\0").map(|sym| *sym),
            zhetrs_3_: get_symbol(&libs, b"zhetrs_3_\0").map(|sym| *sym),
            chetrs_aa_: get_symbol(&libs, b"chetrs_aa_\0").map(|sym| *sym),
            zhetrs_aa_: get_symbol(&libs, b"zhetrs_aa_\0").map(|sym| *sym),
            chetrs_aa_2stage_: get_symbol(&libs, b"chetrs_aa_2stage_\0").map(|sym| *sym),
            zhetrs_aa_2stage_: get_symbol(&libs, b"zhetrs_aa_2stage_\0").map(|sym| *sym),
            chetrs_rook_: get_symbol(&libs, b"chetrs_rook_\0").map(|sym| *sym),
            zhetrs_rook_: get_symbol(&libs, b"zhetrs_rook_\0").map(|sym| *sym),
            chfrk_: get_symbol(&libs, b"chfrk_\0").map(|sym| *sym),
            zhfrk_: get_symbol(&libs, b"zhfrk_\0").map(|sym| *sym),
            chgeqz_: get_symbol(&libs, b"chgeqz_\0").map(|sym| *sym),
            dhgeqz_: get_symbol(&libs, b"dhgeqz_\0").map(|sym| *sym),
            shgeqz_: get_symbol(&libs, b"shgeqz_\0").map(|sym| *sym),
            zhgeqz_: get_symbol(&libs, b"zhgeqz_\0").map(|sym| *sym),
            chpcon_: get_symbol(&libs, b"chpcon_\0").map(|sym| *sym),
            zhpcon_: get_symbol(&libs, b"zhpcon_\0").map(|sym| *sym),
            chpev_: get_symbol(&libs, b"chpev_\0").map(|sym| *sym),
            zhpev_: get_symbol(&libs, b"zhpev_\0").map(|sym| *sym),
            chpevd_: get_symbol(&libs, b"chpevd_\0").map(|sym| *sym),
            zhpevd_: get_symbol(&libs, b"zhpevd_\0").map(|sym| *sym),
            chpevx_: get_symbol(&libs, b"chpevx_\0").map(|sym| *sym),
            zhpevx_: get_symbol(&libs, b"zhpevx_\0").map(|sym| *sym),
            chpgst_: get_symbol(&libs, b"chpgst_\0").map(|sym| *sym),
            zhpgst_: get_symbol(&libs, b"zhpgst_\0").map(|sym| *sym),
            chpgv_: get_symbol(&libs, b"chpgv_\0").map(|sym| *sym),
            zhpgv_: get_symbol(&libs, b"zhpgv_\0").map(|sym| *sym),
            chpgvd_: get_symbol(&libs, b"chpgvd_\0").map(|sym| *sym),
            zhpgvd_: get_symbol(&libs, b"zhpgvd_\0").map(|sym| *sym),
            chpgvx_: get_symbol(&libs, b"chpgvx_\0").map(|sym| *sym),
            zhpgvx_: get_symbol(&libs, b"zhpgvx_\0").map(|sym| *sym),
            chprfs_: get_symbol(&libs, b"chprfs_\0").map(|sym| *sym),
            zhprfs_: get_symbol(&libs, b"zhprfs_\0").map(|sym| *sym),
            chpsv_: get_symbol(&libs, b"chpsv_\0").map(|sym| *sym),
            zhpsv_: get_symbol(&libs, b"zhpsv_\0").map(|sym| *sym),
            chpsvx_: get_symbol(&libs, b"chpsvx_\0").map(|sym| *sym),
            zhpsvx_: get_symbol(&libs, b"zhpsvx_\0").map(|sym| *sym),
            chptrd_: get_symbol(&libs, b"chptrd_\0").map(|sym| *sym),
            zhptrd_: get_symbol(&libs, b"zhptrd_\0").map(|sym| *sym),
            chptrf_: get_symbol(&libs, b"chptrf_\0").map(|sym| *sym),
            zhptrf_: get_symbol(&libs, b"zhptrf_\0").map(|sym| *sym),
            chptri_: get_symbol(&libs, b"chptri_\0").map(|sym| *sym),
            zhptri_: get_symbol(&libs, b"zhptri_\0").map(|sym| *sym),
            chptrs_: get_symbol(&libs, b"chptrs_\0").map(|sym| *sym),
            zhptrs_: get_symbol(&libs, b"zhptrs_\0").map(|sym| *sym),
            chsein_: get_symbol(&libs, b"chsein_\0").map(|sym| *sym),
            dhsein_: get_symbol(&libs, b"dhsein_\0").map(|sym| *sym),
            shsein_: get_symbol(&libs, b"shsein_\0").map(|sym| *sym),
            zhsein_: get_symbol(&libs, b"zhsein_\0").map(|sym| *sym),
            chseqr_: get_symbol(&libs, b"chseqr_\0").map(|sym| *sym),
            dhseqr_: get_symbol(&libs, b"dhseqr_\0").map(|sym| *sym),
            shseqr_: get_symbol(&libs, b"shseqr_\0").map(|sym| *sym),
            zhseqr_: get_symbol(&libs, b"zhseqr_\0").map(|sym| *sym),
            clacgv_: get_symbol(&libs, b"clacgv_\0").map(|sym| *sym),
            zlacgv_: get_symbol(&libs, b"zlacgv_\0").map(|sym| *sym),
            clacn2_: get_symbol(&libs, b"clacn2_\0").map(|sym| *sym),
            dlacn2_: get_symbol(&libs, b"dlacn2_\0").map(|sym| *sym),
            slacn2_: get_symbol(&libs, b"slacn2_\0").map(|sym| *sym),
            zlacn2_: get_symbol(&libs, b"zlacn2_\0").map(|sym| *sym),
            clacp2_: get_symbol(&libs, b"clacp2_\0").map(|sym| *sym),
            zlacp2_: get_symbol(&libs, b"zlacp2_\0").map(|sym| *sym),
            clacpy_: get_symbol(&libs, b"clacpy_\0").map(|sym| *sym),
            dlacpy_: get_symbol(&libs, b"dlacpy_\0").map(|sym| *sym),
            slacpy_: get_symbol(&libs, b"slacpy_\0").map(|sym| *sym),
            zlacpy_: get_symbol(&libs, b"zlacpy_\0").map(|sym| *sym),
            clacrm_: get_symbol(&libs, b"clacrm_\0").map(|sym| *sym),
            zlacrm_: get_symbol(&libs, b"zlacrm_\0").map(|sym| *sym),
            zlag2c_: get_symbol(&libs, b"zlag2c_\0").map(|sym| *sym),
            slag2d_: get_symbol(&libs, b"slag2d_\0").map(|sym| *sym),
            dlag2s_: get_symbol(&libs, b"dlag2s_\0").map(|sym| *sym),
            clag2z_: get_symbol(&libs, b"clag2z_\0").map(|sym| *sym),
            clagge_: get_symbol(&libs, b"clagge_\0").map(|sym| *sym),
            dlagge_: get_symbol(&libs, b"dlagge_\0").map(|sym| *sym),
            slagge_: get_symbol(&libs, b"slagge_\0").map(|sym| *sym),
            zlagge_: get_symbol(&libs, b"zlagge_\0").map(|sym| *sym),
            claghe_: get_symbol(&libs, b"claghe_\0").map(|sym| *sym),
            zlaghe_: get_symbol(&libs, b"zlaghe_\0").map(|sym| *sym),
            clagsy_: get_symbol(&libs, b"clagsy_\0").map(|sym| *sym),
            dlagsy_: get_symbol(&libs, b"dlagsy_\0").map(|sym| *sym),
            slagsy_: get_symbol(&libs, b"slagsy_\0").map(|sym| *sym),
            zlagsy_: get_symbol(&libs, b"zlagsy_\0").map(|sym| *sym),
            dlamch_: get_symbol(&libs, b"dlamch_\0").map(|sym| *sym),
            slamch_: get_symbol(&libs, b"slamch_\0").map(|sym| *sym),
            clangb_: get_symbol(&libs, b"clangb_\0").map(|sym| *sym),
            dlangb_: get_symbol(&libs, b"dlangb_\0").map(|sym| *sym),
            slangb_: get_symbol(&libs, b"slangb_\0").map(|sym| *sym),
            zlangb_: get_symbol(&libs, b"zlangb_\0").map(|sym| *sym),
            clange_: get_symbol(&libs, b"clange_\0").map(|sym| *sym),
            dlange_: get_symbol(&libs, b"dlange_\0").map(|sym| *sym),
            slange_: get_symbol(&libs, b"slange_\0").map(|sym| *sym),
            zlange_: get_symbol(&libs, b"zlange_\0").map(|sym| *sym),
            clangt_: get_symbol(&libs, b"clangt_\0").map(|sym| *sym),
            dlangt_: get_symbol(&libs, b"dlangt_\0").map(|sym| *sym),
            slangt_: get_symbol(&libs, b"slangt_\0").map(|sym| *sym),
            zlangt_: get_symbol(&libs, b"zlangt_\0").map(|sym| *sym),
            clanhb_: get_symbol(&libs, b"clanhb_\0").map(|sym| *sym),
            zlanhb_: get_symbol(&libs, b"zlanhb_\0").map(|sym| *sym),
            clanhe_: get_symbol(&libs, b"clanhe_\0").map(|sym| *sym),
            zlanhe_: get_symbol(&libs, b"zlanhe_\0").map(|sym| *sym),
            clanhp_: get_symbol(&libs, b"clanhp_\0").map(|sym| *sym),
            zlanhp_: get_symbol(&libs, b"zlanhp_\0").map(|sym| *sym),
            clanhs_: get_symbol(&libs, b"clanhs_\0").map(|sym| *sym),
            dlanhs_: get_symbol(&libs, b"dlanhs_\0").map(|sym| *sym),
            slanhs_: get_symbol(&libs, b"slanhs_\0").map(|sym| *sym),
            zlanhs_: get_symbol(&libs, b"zlanhs_\0").map(|sym| *sym),
            clanht_: get_symbol(&libs, b"clanht_\0").map(|sym| *sym),
            zlanht_: get_symbol(&libs, b"zlanht_\0").map(|sym| *sym),
            clansb_: get_symbol(&libs, b"clansb_\0").map(|sym| *sym),
            dlansb_: get_symbol(&libs, b"dlansb_\0").map(|sym| *sym),
            slansb_: get_symbol(&libs, b"slansb_\0").map(|sym| *sym),
            zlansb_: get_symbol(&libs, b"zlansb_\0").map(|sym| *sym),
            clansp_: get_symbol(&libs, b"clansp_\0").map(|sym| *sym),
            dlansp_: get_symbol(&libs, b"dlansp_\0").map(|sym| *sym),
            slansp_: get_symbol(&libs, b"slansp_\0").map(|sym| *sym),
            zlansp_: get_symbol(&libs, b"zlansp_\0").map(|sym| *sym),
            dlanst_: get_symbol(&libs, b"dlanst_\0").map(|sym| *sym),
            slanst_: get_symbol(&libs, b"slanst_\0").map(|sym| *sym),
            clansy_: get_symbol(&libs, b"clansy_\0").map(|sym| *sym),
            dlansy_: get_symbol(&libs, b"dlansy_\0").map(|sym| *sym),
            slansy_: get_symbol(&libs, b"slansy_\0").map(|sym| *sym),
            zlansy_: get_symbol(&libs, b"zlansy_\0").map(|sym| *sym),
            clantb_: get_symbol(&libs, b"clantb_\0").map(|sym| *sym),
            dlantb_: get_symbol(&libs, b"dlantb_\0").map(|sym| *sym),
            slantb_: get_symbol(&libs, b"slantb_\0").map(|sym| *sym),
            zlantb_: get_symbol(&libs, b"zlantb_\0").map(|sym| *sym),
            clantp_: get_symbol(&libs, b"clantp_\0").map(|sym| *sym),
            dlantp_: get_symbol(&libs, b"dlantp_\0").map(|sym| *sym),
            slantp_: get_symbol(&libs, b"slantp_\0").map(|sym| *sym),
            zlantp_: get_symbol(&libs, b"zlantp_\0").map(|sym| *sym),
            clantr_: get_symbol(&libs, b"clantr_\0").map(|sym| *sym),
            dlantr_: get_symbol(&libs, b"dlantr_\0").map(|sym| *sym),
            slantr_: get_symbol(&libs, b"slantr_\0").map(|sym| *sym),
            zlantr_: get_symbol(&libs, b"zlantr_\0").map(|sym| *sym),
            clapmr_: get_symbol(&libs, b"clapmr_\0").map(|sym| *sym),
            dlapmr_: get_symbol(&libs, b"dlapmr_\0").map(|sym| *sym),
            slapmr_: get_symbol(&libs, b"slapmr_\0").map(|sym| *sym),
            zlapmr_: get_symbol(&libs, b"zlapmr_\0").map(|sym| *sym),
            clapmt_: get_symbol(&libs, b"clapmt_\0").map(|sym| *sym),
            dlapmt_: get_symbol(&libs, b"dlapmt_\0").map(|sym| *sym),
            slapmt_: get_symbol(&libs, b"slapmt_\0").map(|sym| *sym),
            zlapmt_: get_symbol(&libs, b"zlapmt_\0").map(|sym| *sym),
            dlapy2_: get_symbol(&libs, b"dlapy2_\0").map(|sym| *sym),
            slapy2_: get_symbol(&libs, b"slapy2_\0").map(|sym| *sym),
            dlapy3_: get_symbol(&libs, b"dlapy3_\0").map(|sym| *sym),
            slapy3_: get_symbol(&libs, b"slapy3_\0").map(|sym| *sym),
            clarcm_: get_symbol(&libs, b"clarcm_\0").map(|sym| *sym),
            zlarcm_: get_symbol(&libs, b"zlarcm_\0").map(|sym| *sym),
            clarf_: get_symbol(&libs, b"clarf_\0").map(|sym| *sym),
            dlarf_: get_symbol(&libs, b"dlarf_\0").map(|sym| *sym),
            slarf_: get_symbol(&libs, b"slarf_\0").map(|sym| *sym),
            zlarf_: get_symbol(&libs, b"zlarf_\0").map(|sym| *sym),
            clarfb_: get_symbol(&libs, b"clarfb_\0").map(|sym| *sym),
            dlarfb_: get_symbol(&libs, b"dlarfb_\0").map(|sym| *sym),
            slarfb_: get_symbol(&libs, b"slarfb_\0").map(|sym| *sym),
            zlarfb_: get_symbol(&libs, b"zlarfb_\0").map(|sym| *sym),
            clarfg_: get_symbol(&libs, b"clarfg_\0").map(|sym| *sym),
            dlarfg_: get_symbol(&libs, b"dlarfg_\0").map(|sym| *sym),
            slarfg_: get_symbol(&libs, b"slarfg_\0").map(|sym| *sym),
            zlarfg_: get_symbol(&libs, b"zlarfg_\0").map(|sym| *sym),
            clarft_: get_symbol(&libs, b"clarft_\0").map(|sym| *sym),
            dlarft_: get_symbol(&libs, b"dlarft_\0").map(|sym| *sym),
            slarft_: get_symbol(&libs, b"slarft_\0").map(|sym| *sym),
            zlarft_: get_symbol(&libs, b"zlarft_\0").map(|sym| *sym),
            clarfx_: get_symbol(&libs, b"clarfx_\0").map(|sym| *sym),
            dlarfx_: get_symbol(&libs, b"dlarfx_\0").map(|sym| *sym),
            slarfx_: get_symbol(&libs, b"slarfx_\0").map(|sym| *sym),
            zlarfx_: get_symbol(&libs, b"zlarfx_\0").map(|sym| *sym),
            clarnv_: get_symbol(&libs, b"clarnv_\0").map(|sym| *sym),
            dlarnv_: get_symbol(&libs, b"dlarnv_\0").map(|sym| *sym),
            slarnv_: get_symbol(&libs, b"slarnv_\0").map(|sym| *sym),
            zlarnv_: get_symbol(&libs, b"zlarnv_\0").map(|sym| *sym),
            dlartgp_: get_symbol(&libs, b"dlartgp_\0").map(|sym| *sym),
            slartgp_: get_symbol(&libs, b"slartgp_\0").map(|sym| *sym),
            dlartgs_: get_symbol(&libs, b"dlartgs_\0").map(|sym| *sym),
            slartgs_: get_symbol(&libs, b"slartgs_\0").map(|sym| *sym),
            clascl_: get_symbol(&libs, b"clascl_\0").map(|sym| *sym),
            dlascl_: get_symbol(&libs, b"dlascl_\0").map(|sym| *sym),
            slascl_: get_symbol(&libs, b"slascl_\0").map(|sym| *sym),
            zlascl_: get_symbol(&libs, b"zlascl_\0").map(|sym| *sym),
            claset_: get_symbol(&libs, b"claset_\0").map(|sym| *sym),
            dlaset_: get_symbol(&libs, b"dlaset_\0").map(|sym| *sym),
            slaset_: get_symbol(&libs, b"slaset_\0").map(|sym| *sym),
            zlaset_: get_symbol(&libs, b"zlaset_\0").map(|sym| *sym),
            dlasrt_: get_symbol(&libs, b"dlasrt_\0").map(|sym| *sym),
            slasrt_: get_symbol(&libs, b"slasrt_\0").map(|sym| *sym),
            classq_: get_symbol(&libs, b"classq_\0").map(|sym| *sym),
            dlassq_: get_symbol(&libs, b"dlassq_\0").map(|sym| *sym),
            slassq_: get_symbol(&libs, b"slassq_\0").map(|sym| *sym),
            zlassq_: get_symbol(&libs, b"zlassq_\0").map(|sym| *sym),
            claswp_: get_symbol(&libs, b"claswp_\0").map(|sym| *sym),
            dlaswp_: get_symbol(&libs, b"dlaswp_\0").map(|sym| *sym),
            slaswp_: get_symbol(&libs, b"slaswp_\0").map(|sym| *sym),
            zlaswp_: get_symbol(&libs, b"zlaswp_\0").map(|sym| *sym),
            clatms_: get_symbol(&libs, b"clatms_\0").map(|sym| *sym),
            dlatms_: get_symbol(&libs, b"dlatms_\0").map(|sym| *sym),
            slatms_: get_symbol(&libs, b"slatms_\0").map(|sym| *sym),
            zlatms_: get_symbol(&libs, b"zlatms_\0").map(|sym| *sym),
            clauum_: get_symbol(&libs, b"clauum_\0").map(|sym| *sym),
            dlauum_: get_symbol(&libs, b"dlauum_\0").map(|sym| *sym),
            slauum_: get_symbol(&libs, b"slauum_\0").map(|sym| *sym),
            zlauum_: get_symbol(&libs, b"zlauum_\0").map(|sym| *sym),
            ilaver_: get_symbol(&libs, b"ilaver_\0").map(|sym| *sym),
            dopgtr_: get_symbol(&libs, b"dopgtr_\0").map(|sym| *sym),
            sopgtr_: get_symbol(&libs, b"sopgtr_\0").map(|sym| *sym),
            dopmtr_: get_symbol(&libs, b"dopmtr_\0").map(|sym| *sym),
            sopmtr_: get_symbol(&libs, b"sopmtr_\0").map(|sym| *sym),
            dorbdb_: get_symbol(&libs, b"dorbdb_\0").map(|sym| *sym),
            sorbdb_: get_symbol(&libs, b"sorbdb_\0").map(|sym| *sym),
            dorcsd_: get_symbol(&libs, b"dorcsd_\0").map(|sym| *sym),
            sorcsd_: get_symbol(&libs, b"sorcsd_\0").map(|sym| *sym),
            dorcsd2by1_: get_symbol(&libs, b"dorcsd2by1_\0").map(|sym| *sym),
            sorcsd2by1_: get_symbol(&libs, b"sorcsd2by1_\0").map(|sym| *sym),
            dorgbr_: get_symbol(&libs, b"dorgbr_\0").map(|sym| *sym),
            sorgbr_: get_symbol(&libs, b"sorgbr_\0").map(|sym| *sym),
            dorghr_: get_symbol(&libs, b"dorghr_\0").map(|sym| *sym),
            sorghr_: get_symbol(&libs, b"sorghr_\0").map(|sym| *sym),
            dorglq_: get_symbol(&libs, b"dorglq_\0").map(|sym| *sym),
            sorglq_: get_symbol(&libs, b"sorglq_\0").map(|sym| *sym),
            dorgql_: get_symbol(&libs, b"dorgql_\0").map(|sym| *sym),
            sorgql_: get_symbol(&libs, b"sorgql_\0").map(|sym| *sym),
            dorgqr_: get_symbol(&libs, b"dorgqr_\0").map(|sym| *sym),
            sorgqr_: get_symbol(&libs, b"sorgqr_\0").map(|sym| *sym),
            dorgrq_: get_symbol(&libs, b"dorgrq_\0").map(|sym| *sym),
            sorgrq_: get_symbol(&libs, b"sorgrq_\0").map(|sym| *sym),
            dorgtr_: get_symbol(&libs, b"dorgtr_\0").map(|sym| *sym),
            sorgtr_: get_symbol(&libs, b"sorgtr_\0").map(|sym| *sym),
            dorgtsqr_row_: get_symbol(&libs, b"dorgtsqr_row_\0").map(|sym| *sym),
            sorgtsqr_row_: get_symbol(&libs, b"sorgtsqr_row_\0").map(|sym| *sym),
            dorhr_col_: get_symbol(&libs, b"dorhr_col_\0").map(|sym| *sym),
            sorhr_col_: get_symbol(&libs, b"sorhr_col_\0").map(|sym| *sym),
            dormbr_: get_symbol(&libs, b"dormbr_\0").map(|sym| *sym),
            sormbr_: get_symbol(&libs, b"sormbr_\0").map(|sym| *sym),
            dormhr_: get_symbol(&libs, b"dormhr_\0").map(|sym| *sym),
            sormhr_: get_symbol(&libs, b"sormhr_\0").map(|sym| *sym),
            dormlq_: get_symbol(&libs, b"dormlq_\0").map(|sym| *sym),
            sormlq_: get_symbol(&libs, b"sormlq_\0").map(|sym| *sym),
            dormql_: get_symbol(&libs, b"dormql_\0").map(|sym| *sym),
            sormql_: get_symbol(&libs, b"sormql_\0").map(|sym| *sym),
            dormqr_: get_symbol(&libs, b"dormqr_\0").map(|sym| *sym),
            sormqr_: get_symbol(&libs, b"sormqr_\0").map(|sym| *sym),
            dormrq_: get_symbol(&libs, b"dormrq_\0").map(|sym| *sym),
            sormrq_: get_symbol(&libs, b"sormrq_\0").map(|sym| *sym),
            dormrz_: get_symbol(&libs, b"dormrz_\0").map(|sym| *sym),
            sormrz_: get_symbol(&libs, b"sormrz_\0").map(|sym| *sym),
            dormtr_: get_symbol(&libs, b"dormtr_\0").map(|sym| *sym),
            sormtr_: get_symbol(&libs, b"sormtr_\0").map(|sym| *sym),
            cpbcon_: get_symbol(&libs, b"cpbcon_\0").map(|sym| *sym),
            dpbcon_: get_symbol(&libs, b"dpbcon_\0").map(|sym| *sym),
            spbcon_: get_symbol(&libs, b"spbcon_\0").map(|sym| *sym),
            zpbcon_: get_symbol(&libs, b"zpbcon_\0").map(|sym| *sym),
            cpbequ_: get_symbol(&libs, b"cpbequ_\0").map(|sym| *sym),
            dpbequ_: get_symbol(&libs, b"dpbequ_\0").map(|sym| *sym),
            spbequ_: get_symbol(&libs, b"spbequ_\0").map(|sym| *sym),
            zpbequ_: get_symbol(&libs, b"zpbequ_\0").map(|sym| *sym),
            cpbrfs_: get_symbol(&libs, b"cpbrfs_\0").map(|sym| *sym),
            dpbrfs_: get_symbol(&libs, b"dpbrfs_\0").map(|sym| *sym),
            spbrfs_: get_symbol(&libs, b"spbrfs_\0").map(|sym| *sym),
            zpbrfs_: get_symbol(&libs, b"zpbrfs_\0").map(|sym| *sym),
            cpbstf_: get_symbol(&libs, b"cpbstf_\0").map(|sym| *sym),
            dpbstf_: get_symbol(&libs, b"dpbstf_\0").map(|sym| *sym),
            spbstf_: get_symbol(&libs, b"spbstf_\0").map(|sym| *sym),
            zpbstf_: get_symbol(&libs, b"zpbstf_\0").map(|sym| *sym),
            cpbsv_: get_symbol(&libs, b"cpbsv_\0").map(|sym| *sym),
            dpbsv_: get_symbol(&libs, b"dpbsv_\0").map(|sym| *sym),
            spbsv_: get_symbol(&libs, b"spbsv_\0").map(|sym| *sym),
            zpbsv_: get_symbol(&libs, b"zpbsv_\0").map(|sym| *sym),
            cpbsvx_: get_symbol(&libs, b"cpbsvx_\0").map(|sym| *sym),
            dpbsvx_: get_symbol(&libs, b"dpbsvx_\0").map(|sym| *sym),
            spbsvx_: get_symbol(&libs, b"spbsvx_\0").map(|sym| *sym),
            zpbsvx_: get_symbol(&libs, b"zpbsvx_\0").map(|sym| *sym),
            cpbtrf_: get_symbol(&libs, b"cpbtrf_\0").map(|sym| *sym),
            dpbtrf_: get_symbol(&libs, b"dpbtrf_\0").map(|sym| *sym),
            spbtrf_: get_symbol(&libs, b"spbtrf_\0").map(|sym| *sym),
            zpbtrf_: get_symbol(&libs, b"zpbtrf_\0").map(|sym| *sym),
            cpbtrs_: get_symbol(&libs, b"cpbtrs_\0").map(|sym| *sym),
            dpbtrs_: get_symbol(&libs, b"dpbtrs_\0").map(|sym| *sym),
            spbtrs_: get_symbol(&libs, b"spbtrs_\0").map(|sym| *sym),
            zpbtrs_: get_symbol(&libs, b"zpbtrs_\0").map(|sym| *sym),
            cpftrf_: get_symbol(&libs, b"cpftrf_\0").map(|sym| *sym),
            dpftrf_: get_symbol(&libs, b"dpftrf_\0").map(|sym| *sym),
            spftrf_: get_symbol(&libs, b"spftrf_\0").map(|sym| *sym),
            zpftrf_: get_symbol(&libs, b"zpftrf_\0").map(|sym| *sym),
            cpftri_: get_symbol(&libs, b"cpftri_\0").map(|sym| *sym),
            dpftri_: get_symbol(&libs, b"dpftri_\0").map(|sym| *sym),
            spftri_: get_symbol(&libs, b"spftri_\0").map(|sym| *sym),
            zpftri_: get_symbol(&libs, b"zpftri_\0").map(|sym| *sym),
            cpftrs_: get_symbol(&libs, b"cpftrs_\0").map(|sym| *sym),
            dpftrs_: get_symbol(&libs, b"dpftrs_\0").map(|sym| *sym),
            spftrs_: get_symbol(&libs, b"spftrs_\0").map(|sym| *sym),
            zpftrs_: get_symbol(&libs, b"zpftrs_\0").map(|sym| *sym),
            cpocon_: get_symbol(&libs, b"cpocon_\0").map(|sym| *sym),
            dpocon_: get_symbol(&libs, b"dpocon_\0").map(|sym| *sym),
            spocon_: get_symbol(&libs, b"spocon_\0").map(|sym| *sym),
            zpocon_: get_symbol(&libs, b"zpocon_\0").map(|sym| *sym),
            cpoequ_: get_symbol(&libs, b"cpoequ_\0").map(|sym| *sym),
            dpoequ_: get_symbol(&libs, b"dpoequ_\0").map(|sym| *sym),
            spoequ_: get_symbol(&libs, b"spoequ_\0").map(|sym| *sym),
            zpoequ_: get_symbol(&libs, b"zpoequ_\0").map(|sym| *sym),
            cpoequb_: get_symbol(&libs, b"cpoequb_\0").map(|sym| *sym),
            dpoequb_: get_symbol(&libs, b"dpoequb_\0").map(|sym| *sym),
            spoequb_: get_symbol(&libs, b"spoequb_\0").map(|sym| *sym),
            zpoequb_: get_symbol(&libs, b"zpoequb_\0").map(|sym| *sym),
            cporfs_: get_symbol(&libs, b"cporfs_\0").map(|sym| *sym),
            dporfs_: get_symbol(&libs, b"dporfs_\0").map(|sym| *sym),
            sporfs_: get_symbol(&libs, b"sporfs_\0").map(|sym| *sym),
            zporfs_: get_symbol(&libs, b"zporfs_\0").map(|sym| *sym),
            cporfsx_: get_symbol(&libs, b"cporfsx_\0").map(|sym| *sym),
            dporfsx_: get_symbol(&libs, b"dporfsx_\0").map(|sym| *sym),
            sporfsx_: get_symbol(&libs, b"sporfsx_\0").map(|sym| *sym),
            zporfsx_: get_symbol(&libs, b"zporfsx_\0").map(|sym| *sym),
            cposv_: get_symbol(&libs, b"cposv_\0").map(|sym| *sym),
            dposv_: get_symbol(&libs, b"dposv_\0").map(|sym| *sym),
            sposv_: get_symbol(&libs, b"sposv_\0").map(|sym| *sym),
            zposv_: get_symbol(&libs, b"zposv_\0").map(|sym| *sym),
            dsposv_: get_symbol(&libs, b"dsposv_\0").map(|sym| *sym),
            zcposv_: get_symbol(&libs, b"zcposv_\0").map(|sym| *sym),
            cposvx_: get_symbol(&libs, b"cposvx_\0").map(|sym| *sym),
            dposvx_: get_symbol(&libs, b"dposvx_\0").map(|sym| *sym),
            sposvx_: get_symbol(&libs, b"sposvx_\0").map(|sym| *sym),
            zposvx_: get_symbol(&libs, b"zposvx_\0").map(|sym| *sym),
            cposvxx_: get_symbol(&libs, b"cposvxx_\0").map(|sym| *sym),
            dposvxx_: get_symbol(&libs, b"dposvxx_\0").map(|sym| *sym),
            sposvxx_: get_symbol(&libs, b"sposvxx_\0").map(|sym| *sym),
            zposvxx_: get_symbol(&libs, b"zposvxx_\0").map(|sym| *sym),
            cpotf2_: get_symbol(&libs, b"cpotf2_\0").map(|sym| *sym),
            dpotf2_: get_symbol(&libs, b"dpotf2_\0").map(|sym| *sym),
            spotf2_: get_symbol(&libs, b"spotf2_\0").map(|sym| *sym),
            zpotf2_: get_symbol(&libs, b"zpotf2_\0").map(|sym| *sym),
            cpotrf_: get_symbol(&libs, b"cpotrf_\0").map(|sym| *sym),
            dpotrf_: get_symbol(&libs, b"dpotrf_\0").map(|sym| *sym),
            spotrf_: get_symbol(&libs, b"spotrf_\0").map(|sym| *sym),
            zpotrf_: get_symbol(&libs, b"zpotrf_\0").map(|sym| *sym),
            cpotrf2_: get_symbol(&libs, b"cpotrf2_\0").map(|sym| *sym),
            dpotrf2_: get_symbol(&libs, b"dpotrf2_\0").map(|sym| *sym),
            spotrf2_: get_symbol(&libs, b"spotrf2_\0").map(|sym| *sym),
            zpotrf2_: get_symbol(&libs, b"zpotrf2_\0").map(|sym| *sym),
            cpotri_: get_symbol(&libs, b"cpotri_\0").map(|sym| *sym),
            dpotri_: get_symbol(&libs, b"dpotri_\0").map(|sym| *sym),
            spotri_: get_symbol(&libs, b"spotri_\0").map(|sym| *sym),
            zpotri_: get_symbol(&libs, b"zpotri_\0").map(|sym| *sym),
            cpotrs_: get_symbol(&libs, b"cpotrs_\0").map(|sym| *sym),
            dpotrs_: get_symbol(&libs, b"dpotrs_\0").map(|sym| *sym),
            spotrs_: get_symbol(&libs, b"spotrs_\0").map(|sym| *sym),
            zpotrs_: get_symbol(&libs, b"zpotrs_\0").map(|sym| *sym),
            cppcon_: get_symbol(&libs, b"cppcon_\0").map(|sym| *sym),
            dppcon_: get_symbol(&libs, b"dppcon_\0").map(|sym| *sym),
            sppcon_: get_symbol(&libs, b"sppcon_\0").map(|sym| *sym),
            zppcon_: get_symbol(&libs, b"zppcon_\0").map(|sym| *sym),
            cppequ_: get_symbol(&libs, b"cppequ_\0").map(|sym| *sym),
            dppequ_: get_symbol(&libs, b"dppequ_\0").map(|sym| *sym),
            sppequ_: get_symbol(&libs, b"sppequ_\0").map(|sym| *sym),
            zppequ_: get_symbol(&libs, b"zppequ_\0").map(|sym| *sym),
            cpprfs_: get_symbol(&libs, b"cpprfs_\0").map(|sym| *sym),
            dpprfs_: get_symbol(&libs, b"dpprfs_\0").map(|sym| *sym),
            spprfs_: get_symbol(&libs, b"spprfs_\0").map(|sym| *sym),
            zpprfs_: get_symbol(&libs, b"zpprfs_\0").map(|sym| *sym),
            cppsv_: get_symbol(&libs, b"cppsv_\0").map(|sym| *sym),
            dppsv_: get_symbol(&libs, b"dppsv_\0").map(|sym| *sym),
            sppsv_: get_symbol(&libs, b"sppsv_\0").map(|sym| *sym),
            zppsv_: get_symbol(&libs, b"zppsv_\0").map(|sym| *sym),
            cppsvx_: get_symbol(&libs, b"cppsvx_\0").map(|sym| *sym),
            dppsvx_: get_symbol(&libs, b"dppsvx_\0").map(|sym| *sym),
            sppsvx_: get_symbol(&libs, b"sppsvx_\0").map(|sym| *sym),
            zppsvx_: get_symbol(&libs, b"zppsvx_\0").map(|sym| *sym),
            cpptrf_: get_symbol(&libs, b"cpptrf_\0").map(|sym| *sym),
            dpptrf_: get_symbol(&libs, b"dpptrf_\0").map(|sym| *sym),
            spptrf_: get_symbol(&libs, b"spptrf_\0").map(|sym| *sym),
            zpptrf_: get_symbol(&libs, b"zpptrf_\0").map(|sym| *sym),
            cpptri_: get_symbol(&libs, b"cpptri_\0").map(|sym| *sym),
            dpptri_: get_symbol(&libs, b"dpptri_\0").map(|sym| *sym),
            spptri_: get_symbol(&libs, b"spptri_\0").map(|sym| *sym),
            zpptri_: get_symbol(&libs, b"zpptri_\0").map(|sym| *sym),
            cpptrs_: get_symbol(&libs, b"cpptrs_\0").map(|sym| *sym),
            dpptrs_: get_symbol(&libs, b"dpptrs_\0").map(|sym| *sym),
            spptrs_: get_symbol(&libs, b"spptrs_\0").map(|sym| *sym),
            zpptrs_: get_symbol(&libs, b"zpptrs_\0").map(|sym| *sym),
            cpstrf_: get_symbol(&libs, b"cpstrf_\0").map(|sym| *sym),
            dpstrf_: get_symbol(&libs, b"dpstrf_\0").map(|sym| *sym),
            spstrf_: get_symbol(&libs, b"spstrf_\0").map(|sym| *sym),
            zpstrf_: get_symbol(&libs, b"zpstrf_\0").map(|sym| *sym),
            cptcon_: get_symbol(&libs, b"cptcon_\0").map(|sym| *sym),
            dptcon_: get_symbol(&libs, b"dptcon_\0").map(|sym| *sym),
            sptcon_: get_symbol(&libs, b"sptcon_\0").map(|sym| *sym),
            zptcon_: get_symbol(&libs, b"zptcon_\0").map(|sym| *sym),
            cpteqr_: get_symbol(&libs, b"cpteqr_\0").map(|sym| *sym),
            dpteqr_: get_symbol(&libs, b"dpteqr_\0").map(|sym| *sym),
            spteqr_: get_symbol(&libs, b"spteqr_\0").map(|sym| *sym),
            zpteqr_: get_symbol(&libs, b"zpteqr_\0").map(|sym| *sym),
            cptrfs_: get_symbol(&libs, b"cptrfs_\0").map(|sym| *sym),
            dptrfs_: get_symbol(&libs, b"dptrfs_\0").map(|sym| *sym),
            sptrfs_: get_symbol(&libs, b"sptrfs_\0").map(|sym| *sym),
            zptrfs_: get_symbol(&libs, b"zptrfs_\0").map(|sym| *sym),
            cptsv_: get_symbol(&libs, b"cptsv_\0").map(|sym| *sym),
            dptsv_: get_symbol(&libs, b"dptsv_\0").map(|sym| *sym),
            sptsv_: get_symbol(&libs, b"sptsv_\0").map(|sym| *sym),
            zptsv_: get_symbol(&libs, b"zptsv_\0").map(|sym| *sym),
            cptsvx_: get_symbol(&libs, b"cptsvx_\0").map(|sym| *sym),
            dptsvx_: get_symbol(&libs, b"dptsvx_\0").map(|sym| *sym),
            sptsvx_: get_symbol(&libs, b"sptsvx_\0").map(|sym| *sym),
            zptsvx_: get_symbol(&libs, b"zptsvx_\0").map(|sym| *sym),
            cpttrf_: get_symbol(&libs, b"cpttrf_\0").map(|sym| *sym),
            dpttrf_: get_symbol(&libs, b"dpttrf_\0").map(|sym| *sym),
            spttrf_: get_symbol(&libs, b"spttrf_\0").map(|sym| *sym),
            zpttrf_: get_symbol(&libs, b"zpttrf_\0").map(|sym| *sym),
            cpttrs_: get_symbol(&libs, b"cpttrs_\0").map(|sym| *sym),
            dpttrs_: get_symbol(&libs, b"dpttrs_\0").map(|sym| *sym),
            spttrs_: get_symbol(&libs, b"spttrs_\0").map(|sym| *sym),
            zpttrs_: get_symbol(&libs, b"zpttrs_\0").map(|sym| *sym),
            dsbev_: get_symbol(&libs, b"dsbev_\0").map(|sym| *sym),
            ssbev_: get_symbol(&libs, b"ssbev_\0").map(|sym| *sym),
            dsbev_2stage_: get_symbol(&libs, b"dsbev_2stage_\0").map(|sym| *sym),
            ssbev_2stage_: get_symbol(&libs, b"ssbev_2stage_\0").map(|sym| *sym),
            dsbevd_: get_symbol(&libs, b"dsbevd_\0").map(|sym| *sym),
            ssbevd_: get_symbol(&libs, b"ssbevd_\0").map(|sym| *sym),
            dsbevd_2stage_: get_symbol(&libs, b"dsbevd_2stage_\0").map(|sym| *sym),
            ssbevd_2stage_: get_symbol(&libs, b"ssbevd_2stage_\0").map(|sym| *sym),
            dsbevx_: get_symbol(&libs, b"dsbevx_\0").map(|sym| *sym),
            ssbevx_: get_symbol(&libs, b"ssbevx_\0").map(|sym| *sym),
            dsbevx_2stage_: get_symbol(&libs, b"dsbevx_2stage_\0").map(|sym| *sym),
            ssbevx_2stage_: get_symbol(&libs, b"ssbevx_2stage_\0").map(|sym| *sym),
            dsbgst_: get_symbol(&libs, b"dsbgst_\0").map(|sym| *sym),
            ssbgst_: get_symbol(&libs, b"ssbgst_\0").map(|sym| *sym),
            dsbgv_: get_symbol(&libs, b"dsbgv_\0").map(|sym| *sym),
            ssbgv_: get_symbol(&libs, b"ssbgv_\0").map(|sym| *sym),
            dsbgvd_: get_symbol(&libs, b"dsbgvd_\0").map(|sym| *sym),
            ssbgvd_: get_symbol(&libs, b"ssbgvd_\0").map(|sym| *sym),
            dsbgvx_: get_symbol(&libs, b"dsbgvx_\0").map(|sym| *sym),
            ssbgvx_: get_symbol(&libs, b"ssbgvx_\0").map(|sym| *sym),
            dsbtrd_: get_symbol(&libs, b"dsbtrd_\0").map(|sym| *sym),
            ssbtrd_: get_symbol(&libs, b"ssbtrd_\0").map(|sym| *sym),
            dsfrk_: get_symbol(&libs, b"dsfrk_\0").map(|sym| *sym),
            ssfrk_: get_symbol(&libs, b"ssfrk_\0").map(|sym| *sym),
            cspcon_: get_symbol(&libs, b"cspcon_\0").map(|sym| *sym),
            dspcon_: get_symbol(&libs, b"dspcon_\0").map(|sym| *sym),
            sspcon_: get_symbol(&libs, b"sspcon_\0").map(|sym| *sym),
            zspcon_: get_symbol(&libs, b"zspcon_\0").map(|sym| *sym),
            dspev_: get_symbol(&libs, b"dspev_\0").map(|sym| *sym),
            sspev_: get_symbol(&libs, b"sspev_\0").map(|sym| *sym),
            dspevd_: get_symbol(&libs, b"dspevd_\0").map(|sym| *sym),
            sspevd_: get_symbol(&libs, b"sspevd_\0").map(|sym| *sym),
            dspevx_: get_symbol(&libs, b"dspevx_\0").map(|sym| *sym),
            sspevx_: get_symbol(&libs, b"sspevx_\0").map(|sym| *sym),
            dspgst_: get_symbol(&libs, b"dspgst_\0").map(|sym| *sym),
            sspgst_: get_symbol(&libs, b"sspgst_\0").map(|sym| *sym),
            dspgv_: get_symbol(&libs, b"dspgv_\0").map(|sym| *sym),
            sspgv_: get_symbol(&libs, b"sspgv_\0").map(|sym| *sym),
            dspgvd_: get_symbol(&libs, b"dspgvd_\0").map(|sym| *sym),
            sspgvd_: get_symbol(&libs, b"sspgvd_\0").map(|sym| *sym),
            dspgvx_: get_symbol(&libs, b"dspgvx_\0").map(|sym| *sym),
            sspgvx_: get_symbol(&libs, b"sspgvx_\0").map(|sym| *sym),
            csprfs_: get_symbol(&libs, b"csprfs_\0").map(|sym| *sym),
            dsprfs_: get_symbol(&libs, b"dsprfs_\0").map(|sym| *sym),
            ssprfs_: get_symbol(&libs, b"ssprfs_\0").map(|sym| *sym),
            zsprfs_: get_symbol(&libs, b"zsprfs_\0").map(|sym| *sym),
            cspsv_: get_symbol(&libs, b"cspsv_\0").map(|sym| *sym),
            dspsv_: get_symbol(&libs, b"dspsv_\0").map(|sym| *sym),
            sspsv_: get_symbol(&libs, b"sspsv_\0").map(|sym| *sym),
            zspsv_: get_symbol(&libs, b"zspsv_\0").map(|sym| *sym),
            cspsvx_: get_symbol(&libs, b"cspsvx_\0").map(|sym| *sym),
            dspsvx_: get_symbol(&libs, b"dspsvx_\0").map(|sym| *sym),
            sspsvx_: get_symbol(&libs, b"sspsvx_\0").map(|sym| *sym),
            zspsvx_: get_symbol(&libs, b"zspsvx_\0").map(|sym| *sym),
            dsptrd_: get_symbol(&libs, b"dsptrd_\0").map(|sym| *sym),
            ssptrd_: get_symbol(&libs, b"ssptrd_\0").map(|sym| *sym),
            csptrf_: get_symbol(&libs, b"csptrf_\0").map(|sym| *sym),
            dsptrf_: get_symbol(&libs, b"dsptrf_\0").map(|sym| *sym),
            ssptrf_: get_symbol(&libs, b"ssptrf_\0").map(|sym| *sym),
            zsptrf_: get_symbol(&libs, b"zsptrf_\0").map(|sym| *sym),
            csptri_: get_symbol(&libs, b"csptri_\0").map(|sym| *sym),
            dsptri_: get_symbol(&libs, b"dsptri_\0").map(|sym| *sym),
            ssptri_: get_symbol(&libs, b"ssptri_\0").map(|sym| *sym),
            zsptri_: get_symbol(&libs, b"zsptri_\0").map(|sym| *sym),
            csptrs_: get_symbol(&libs, b"csptrs_\0").map(|sym| *sym),
            dsptrs_: get_symbol(&libs, b"dsptrs_\0").map(|sym| *sym),
            ssptrs_: get_symbol(&libs, b"ssptrs_\0").map(|sym| *sym),
            zsptrs_: get_symbol(&libs, b"zsptrs_\0").map(|sym| *sym),
            dstebz_: get_symbol(&libs, b"dstebz_\0").map(|sym| *sym),
            sstebz_: get_symbol(&libs, b"sstebz_\0").map(|sym| *sym),
            cstedc_: get_symbol(&libs, b"cstedc_\0").map(|sym| *sym),
            dstedc_: get_symbol(&libs, b"dstedc_\0").map(|sym| *sym),
            sstedc_: get_symbol(&libs, b"sstedc_\0").map(|sym| *sym),
            zstedc_: get_symbol(&libs, b"zstedc_\0").map(|sym| *sym),
            cstegr_: get_symbol(&libs, b"cstegr_\0").map(|sym| *sym),
            dstegr_: get_symbol(&libs, b"dstegr_\0").map(|sym| *sym),
            sstegr_: get_symbol(&libs, b"sstegr_\0").map(|sym| *sym),
            zstegr_: get_symbol(&libs, b"zstegr_\0").map(|sym| *sym),
            cstein_: get_symbol(&libs, b"cstein_\0").map(|sym| *sym),
            dstein_: get_symbol(&libs, b"dstein_\0").map(|sym| *sym),
            sstein_: get_symbol(&libs, b"sstein_\0").map(|sym| *sym),
            zstein_: get_symbol(&libs, b"zstein_\0").map(|sym| *sym),
            cstemr_: get_symbol(&libs, b"cstemr_\0").map(|sym| *sym),
            dstemr_: get_symbol(&libs, b"dstemr_\0").map(|sym| *sym),
            sstemr_: get_symbol(&libs, b"sstemr_\0").map(|sym| *sym),
            zstemr_: get_symbol(&libs, b"zstemr_\0").map(|sym| *sym),
            csteqr_: get_symbol(&libs, b"csteqr_\0").map(|sym| *sym),
            dsteqr_: get_symbol(&libs, b"dsteqr_\0").map(|sym| *sym),
            ssteqr_: get_symbol(&libs, b"ssteqr_\0").map(|sym| *sym),
            zsteqr_: get_symbol(&libs, b"zsteqr_\0").map(|sym| *sym),
            dsterf_: get_symbol(&libs, b"dsterf_\0").map(|sym| *sym),
            ssterf_: get_symbol(&libs, b"ssterf_\0").map(|sym| *sym),
            dstev_: get_symbol(&libs, b"dstev_\0").map(|sym| *sym),
            sstev_: get_symbol(&libs, b"sstev_\0").map(|sym| *sym),
            dstevd_: get_symbol(&libs, b"dstevd_\0").map(|sym| *sym),
            sstevd_: get_symbol(&libs, b"sstevd_\0").map(|sym| *sym),
            dstevr_: get_symbol(&libs, b"dstevr_\0").map(|sym| *sym),
            sstevr_: get_symbol(&libs, b"sstevr_\0").map(|sym| *sym),
            dstevx_: get_symbol(&libs, b"dstevx_\0").map(|sym| *sym),
            sstevx_: get_symbol(&libs, b"sstevx_\0").map(|sym| *sym),
            csycon_: get_symbol(&libs, b"csycon_\0").map(|sym| *sym),
            dsycon_: get_symbol(&libs, b"dsycon_\0").map(|sym| *sym),
            ssycon_: get_symbol(&libs, b"ssycon_\0").map(|sym| *sym),
            zsycon_: get_symbol(&libs, b"zsycon_\0").map(|sym| *sym),
            csycon_3_: get_symbol(&libs, b"csycon_3_\0").map(|sym| *sym),
            dsycon_3_: get_symbol(&libs, b"dsycon_3_\0").map(|sym| *sym),
            ssycon_3_: get_symbol(&libs, b"ssycon_3_\0").map(|sym| *sym),
            zsycon_3_: get_symbol(&libs, b"zsycon_3_\0").map(|sym| *sym),
            csyconv_: get_symbol(&libs, b"csyconv_\0").map(|sym| *sym),
            dsyconv_: get_symbol(&libs, b"dsyconv_\0").map(|sym| *sym),
            ssyconv_: get_symbol(&libs, b"ssyconv_\0").map(|sym| *sym),
            zsyconv_: get_symbol(&libs, b"zsyconv_\0").map(|sym| *sym),
            csyequb_: get_symbol(&libs, b"csyequb_\0").map(|sym| *sym),
            dsyequb_: get_symbol(&libs, b"dsyequb_\0").map(|sym| *sym),
            ssyequb_: get_symbol(&libs, b"ssyequb_\0").map(|sym| *sym),
            zsyequb_: get_symbol(&libs, b"zsyequb_\0").map(|sym| *sym),
            dsyev_: get_symbol(&libs, b"dsyev_\0").map(|sym| *sym),
            ssyev_: get_symbol(&libs, b"ssyev_\0").map(|sym| *sym),
            dsyev_2stage_: get_symbol(&libs, b"dsyev_2stage_\0").map(|sym| *sym),
            ssyev_2stage_: get_symbol(&libs, b"ssyev_2stage_\0").map(|sym| *sym),
            dsyevd_: get_symbol(&libs, b"dsyevd_\0").map(|sym| *sym),
            ssyevd_: get_symbol(&libs, b"ssyevd_\0").map(|sym| *sym),
            dsyevd_2stage_: get_symbol(&libs, b"dsyevd_2stage_\0").map(|sym| *sym),
            ssyevd_2stage_: get_symbol(&libs, b"ssyevd_2stage_\0").map(|sym| *sym),
            dsyevr_: get_symbol(&libs, b"dsyevr_\0").map(|sym| *sym),
            ssyevr_: get_symbol(&libs, b"ssyevr_\0").map(|sym| *sym),
            dsyevr_2stage_: get_symbol(&libs, b"dsyevr_2stage_\0").map(|sym| *sym),
            ssyevr_2stage_: get_symbol(&libs, b"ssyevr_2stage_\0").map(|sym| *sym),
            dsyevx_: get_symbol(&libs, b"dsyevx_\0").map(|sym| *sym),
            ssyevx_: get_symbol(&libs, b"ssyevx_\0").map(|sym| *sym),
            dsyevx_2stage_: get_symbol(&libs, b"dsyevx_2stage_\0").map(|sym| *sym),
            ssyevx_2stage_: get_symbol(&libs, b"ssyevx_2stage_\0").map(|sym| *sym),
            dsygst_: get_symbol(&libs, b"dsygst_\0").map(|sym| *sym),
            ssygst_: get_symbol(&libs, b"ssygst_\0").map(|sym| *sym),
            dsygv_: get_symbol(&libs, b"dsygv_\0").map(|sym| *sym),
            ssygv_: get_symbol(&libs, b"ssygv_\0").map(|sym| *sym),
            dsygv_2stage_: get_symbol(&libs, b"dsygv_2stage_\0").map(|sym| *sym),
            ssygv_2stage_: get_symbol(&libs, b"ssygv_2stage_\0").map(|sym| *sym),
            dsygvd_: get_symbol(&libs, b"dsygvd_\0").map(|sym| *sym),
            ssygvd_: get_symbol(&libs, b"ssygvd_\0").map(|sym| *sym),
            dsygvx_: get_symbol(&libs, b"dsygvx_\0").map(|sym| *sym),
            ssygvx_: get_symbol(&libs, b"ssygvx_\0").map(|sym| *sym),
            csyr_: get_symbol(&libs, b"csyr_\0").map(|sym| *sym),
            zsyr_: get_symbol(&libs, b"zsyr_\0").map(|sym| *sym),
            csyrfs_: get_symbol(&libs, b"csyrfs_\0").map(|sym| *sym),
            dsyrfs_: get_symbol(&libs, b"dsyrfs_\0").map(|sym| *sym),
            ssyrfs_: get_symbol(&libs, b"ssyrfs_\0").map(|sym| *sym),
            zsyrfs_: get_symbol(&libs, b"zsyrfs_\0").map(|sym| *sym),
            csyrfsx_: get_symbol(&libs, b"csyrfsx_\0").map(|sym| *sym),
            dsyrfsx_: get_symbol(&libs, b"dsyrfsx_\0").map(|sym| *sym),
            ssyrfsx_: get_symbol(&libs, b"ssyrfsx_\0").map(|sym| *sym),
            zsyrfsx_: get_symbol(&libs, b"zsyrfsx_\0").map(|sym| *sym),
            csysv_: get_symbol(&libs, b"csysv_\0").map(|sym| *sym),
            dsysv_: get_symbol(&libs, b"dsysv_\0").map(|sym| *sym),
            ssysv_: get_symbol(&libs, b"ssysv_\0").map(|sym| *sym),
            zsysv_: get_symbol(&libs, b"zsysv_\0").map(|sym| *sym),
            csysv_aa_: get_symbol(&libs, b"csysv_aa_\0").map(|sym| *sym),
            dsysv_aa_: get_symbol(&libs, b"dsysv_aa_\0").map(|sym| *sym),
            ssysv_aa_: get_symbol(&libs, b"ssysv_aa_\0").map(|sym| *sym),
            zsysv_aa_: get_symbol(&libs, b"zsysv_aa_\0").map(|sym| *sym),
            csysv_aa_2stage_: get_symbol(&libs, b"csysv_aa_2stage_\0").map(|sym| *sym),
            dsysv_aa_2stage_: get_symbol(&libs, b"dsysv_aa_2stage_\0").map(|sym| *sym),
            ssysv_aa_2stage_: get_symbol(&libs, b"ssysv_aa_2stage_\0").map(|sym| *sym),
            zsysv_aa_2stage_: get_symbol(&libs, b"zsysv_aa_2stage_\0").map(|sym| *sym),
            csysv_rk_: get_symbol(&libs, b"csysv_rk_\0").map(|sym| *sym),
            dsysv_rk_: get_symbol(&libs, b"dsysv_rk_\0").map(|sym| *sym),
            ssysv_rk_: get_symbol(&libs, b"ssysv_rk_\0").map(|sym| *sym),
            zsysv_rk_: get_symbol(&libs, b"zsysv_rk_\0").map(|sym| *sym),
            csysv_rook_: get_symbol(&libs, b"csysv_rook_\0").map(|sym| *sym),
            dsysv_rook_: get_symbol(&libs, b"dsysv_rook_\0").map(|sym| *sym),
            ssysv_rook_: get_symbol(&libs, b"ssysv_rook_\0").map(|sym| *sym),
            zsysv_rook_: get_symbol(&libs, b"zsysv_rook_\0").map(|sym| *sym),
            csysvx_: get_symbol(&libs, b"csysvx_\0").map(|sym| *sym),
            dsysvx_: get_symbol(&libs, b"dsysvx_\0").map(|sym| *sym),
            ssysvx_: get_symbol(&libs, b"ssysvx_\0").map(|sym| *sym),
            zsysvx_: get_symbol(&libs, b"zsysvx_\0").map(|sym| *sym),
            csysvxx_: get_symbol(&libs, b"csysvxx_\0").map(|sym| *sym),
            dsysvxx_: get_symbol(&libs, b"dsysvxx_\0").map(|sym| *sym),
            ssysvxx_: get_symbol(&libs, b"ssysvxx_\0").map(|sym| *sym),
            zsysvxx_: get_symbol(&libs, b"zsysvxx_\0").map(|sym| *sym),
            csyswapr_: get_symbol(&libs, b"csyswapr_\0").map(|sym| *sym),
            dsyswapr_: get_symbol(&libs, b"dsyswapr_\0").map(|sym| *sym),
            ssyswapr_: get_symbol(&libs, b"ssyswapr_\0").map(|sym| *sym),
            zsyswapr_: get_symbol(&libs, b"zsyswapr_\0").map(|sym| *sym),
            dsytrd_: get_symbol(&libs, b"dsytrd_\0").map(|sym| *sym),
            ssytrd_: get_symbol(&libs, b"ssytrd_\0").map(|sym| *sym),
            dsytrd_2stage_: get_symbol(&libs, b"dsytrd_2stage_\0").map(|sym| *sym),
            ssytrd_2stage_: get_symbol(&libs, b"ssytrd_2stage_\0").map(|sym| *sym),
            csytrf_: get_symbol(&libs, b"csytrf_\0").map(|sym| *sym),
            dsytrf_: get_symbol(&libs, b"dsytrf_\0").map(|sym| *sym),
            ssytrf_: get_symbol(&libs, b"ssytrf_\0").map(|sym| *sym),
            zsytrf_: get_symbol(&libs, b"zsytrf_\0").map(|sym| *sym),
            csytrf_aa_: get_symbol(&libs, b"csytrf_aa_\0").map(|sym| *sym),
            dsytrf_aa_: get_symbol(&libs, b"dsytrf_aa_\0").map(|sym| *sym),
            ssytrf_aa_: get_symbol(&libs, b"ssytrf_aa_\0").map(|sym| *sym),
            zsytrf_aa_: get_symbol(&libs, b"zsytrf_aa_\0").map(|sym| *sym),
            csytrf_aa_2stage_: get_symbol(&libs, b"csytrf_aa_2stage_\0").map(|sym| *sym),
            dsytrf_aa_2stage_: get_symbol(&libs, b"dsytrf_aa_2stage_\0").map(|sym| *sym),
            ssytrf_aa_2stage_: get_symbol(&libs, b"ssytrf_aa_2stage_\0").map(|sym| *sym),
            zsytrf_aa_2stage_: get_symbol(&libs, b"zsytrf_aa_2stage_\0").map(|sym| *sym),
            csytrf_rk_: get_symbol(&libs, b"csytrf_rk_\0").map(|sym| *sym),
            dsytrf_rk_: get_symbol(&libs, b"dsytrf_rk_\0").map(|sym| *sym),
            ssytrf_rk_: get_symbol(&libs, b"ssytrf_rk_\0").map(|sym| *sym),
            zsytrf_rk_: get_symbol(&libs, b"zsytrf_rk_\0").map(|sym| *sym),
            csytrf_rook_: get_symbol(&libs, b"csytrf_rook_\0").map(|sym| *sym),
            dsytrf_rook_: get_symbol(&libs, b"dsytrf_rook_\0").map(|sym| *sym),
            ssytrf_rook_: get_symbol(&libs, b"ssytrf_rook_\0").map(|sym| *sym),
            zsytrf_rook_: get_symbol(&libs, b"zsytrf_rook_\0").map(|sym| *sym),
            csytri_: get_symbol(&libs, b"csytri_\0").map(|sym| *sym),
            dsytri_: get_symbol(&libs, b"dsytri_\0").map(|sym| *sym),
            ssytri_: get_symbol(&libs, b"ssytri_\0").map(|sym| *sym),
            zsytri_: get_symbol(&libs, b"zsytri_\0").map(|sym| *sym),
            csytri2_: get_symbol(&libs, b"csytri2_\0").map(|sym| *sym),
            dsytri2_: get_symbol(&libs, b"dsytri2_\0").map(|sym| *sym),
            ssytri2_: get_symbol(&libs, b"ssytri2_\0").map(|sym| *sym),
            zsytri2_: get_symbol(&libs, b"zsytri2_\0").map(|sym| *sym),
            csytri2x_: get_symbol(&libs, b"csytri2x_\0").map(|sym| *sym),
            dsytri2x_: get_symbol(&libs, b"dsytri2x_\0").map(|sym| *sym),
            ssytri2x_: get_symbol(&libs, b"ssytri2x_\0").map(|sym| *sym),
            zsytri2x_: get_symbol(&libs, b"zsytri2x_\0").map(|sym| *sym),
            csytri_3_: get_symbol(&libs, b"csytri_3_\0").map(|sym| *sym),
            dsytri_3_: get_symbol(&libs, b"dsytri_3_\0").map(|sym| *sym),
            ssytri_3_: get_symbol(&libs, b"ssytri_3_\0").map(|sym| *sym),
            zsytri_3_: get_symbol(&libs, b"zsytri_3_\0").map(|sym| *sym),
            csytrs_: get_symbol(&libs, b"csytrs_\0").map(|sym| *sym),
            dsytrs_: get_symbol(&libs, b"dsytrs_\0").map(|sym| *sym),
            ssytrs_: get_symbol(&libs, b"ssytrs_\0").map(|sym| *sym),
            zsytrs_: get_symbol(&libs, b"zsytrs_\0").map(|sym| *sym),
            csytrs2_: get_symbol(&libs, b"csytrs2_\0").map(|sym| *sym),
            dsytrs2_: get_symbol(&libs, b"dsytrs2_\0").map(|sym| *sym),
            ssytrs2_: get_symbol(&libs, b"ssytrs2_\0").map(|sym| *sym),
            zsytrs2_: get_symbol(&libs, b"zsytrs2_\0").map(|sym| *sym),
            csytrs_3_: get_symbol(&libs, b"csytrs_3_\0").map(|sym| *sym),
            dsytrs_3_: get_symbol(&libs, b"dsytrs_3_\0").map(|sym| *sym),
            ssytrs_3_: get_symbol(&libs, b"ssytrs_3_\0").map(|sym| *sym),
            zsytrs_3_: get_symbol(&libs, b"zsytrs_3_\0").map(|sym| *sym),
            csytrs_aa_: get_symbol(&libs, b"csytrs_aa_\0").map(|sym| *sym),
            dsytrs_aa_: get_symbol(&libs, b"dsytrs_aa_\0").map(|sym| *sym),
            ssytrs_aa_: get_symbol(&libs, b"ssytrs_aa_\0").map(|sym| *sym),
            zsytrs_aa_: get_symbol(&libs, b"zsytrs_aa_\0").map(|sym| *sym),
            csytrs_aa_2stage_: get_symbol(&libs, b"csytrs_aa_2stage_\0").map(|sym| *sym),
            dsytrs_aa_2stage_: get_symbol(&libs, b"dsytrs_aa_2stage_\0").map(|sym| *sym),
            ssytrs_aa_2stage_: get_symbol(&libs, b"ssytrs_aa_2stage_\0").map(|sym| *sym),
            zsytrs_aa_2stage_: get_symbol(&libs, b"zsytrs_aa_2stage_\0").map(|sym| *sym),
            csytrs_rook_: get_symbol(&libs, b"csytrs_rook_\0").map(|sym| *sym),
            dsytrs_rook_: get_symbol(&libs, b"dsytrs_rook_\0").map(|sym| *sym),
            ssytrs_rook_: get_symbol(&libs, b"ssytrs_rook_\0").map(|sym| *sym),
            zsytrs_rook_: get_symbol(&libs, b"zsytrs_rook_\0").map(|sym| *sym),
            ctbcon_: get_symbol(&libs, b"ctbcon_\0").map(|sym| *sym),
            dtbcon_: get_symbol(&libs, b"dtbcon_\0").map(|sym| *sym),
            stbcon_: get_symbol(&libs, b"stbcon_\0").map(|sym| *sym),
            ztbcon_: get_symbol(&libs, b"ztbcon_\0").map(|sym| *sym),
            ctbrfs_: get_symbol(&libs, b"ctbrfs_\0").map(|sym| *sym),
            dtbrfs_: get_symbol(&libs, b"dtbrfs_\0").map(|sym| *sym),
            stbrfs_: get_symbol(&libs, b"stbrfs_\0").map(|sym| *sym),
            ztbrfs_: get_symbol(&libs, b"ztbrfs_\0").map(|sym| *sym),
            ctbtrs_: get_symbol(&libs, b"ctbtrs_\0").map(|sym| *sym),
            dtbtrs_: get_symbol(&libs, b"dtbtrs_\0").map(|sym| *sym),
            stbtrs_: get_symbol(&libs, b"stbtrs_\0").map(|sym| *sym),
            ztbtrs_: get_symbol(&libs, b"ztbtrs_\0").map(|sym| *sym),
            ctfsm_: get_symbol(&libs, b"ctfsm_\0").map(|sym| *sym),
            dtfsm_: get_symbol(&libs, b"dtfsm_\0").map(|sym| *sym),
            stfsm_: get_symbol(&libs, b"stfsm_\0").map(|sym| *sym),
            ztfsm_: get_symbol(&libs, b"ztfsm_\0").map(|sym| *sym),
            ctftri_: get_symbol(&libs, b"ctftri_\0").map(|sym| *sym),
            dtftri_: get_symbol(&libs, b"dtftri_\0").map(|sym| *sym),
            stftri_: get_symbol(&libs, b"stftri_\0").map(|sym| *sym),
            ztftri_: get_symbol(&libs, b"ztftri_\0").map(|sym| *sym),
            ctfttp_: get_symbol(&libs, b"ctfttp_\0").map(|sym| *sym),
            dtfttp_: get_symbol(&libs, b"dtfttp_\0").map(|sym| *sym),
            stfttp_: get_symbol(&libs, b"stfttp_\0").map(|sym| *sym),
            ztfttp_: get_symbol(&libs, b"ztfttp_\0").map(|sym| *sym),
            ctfttr_: get_symbol(&libs, b"ctfttr_\0").map(|sym| *sym),
            dtfttr_: get_symbol(&libs, b"dtfttr_\0").map(|sym| *sym),
            stfttr_: get_symbol(&libs, b"stfttr_\0").map(|sym| *sym),
            ztfttr_: get_symbol(&libs, b"ztfttr_\0").map(|sym| *sym),
            ctgevc_: get_symbol(&libs, b"ctgevc_\0").map(|sym| *sym),
            dtgevc_: get_symbol(&libs, b"dtgevc_\0").map(|sym| *sym),
            stgevc_: get_symbol(&libs, b"stgevc_\0").map(|sym| *sym),
            ztgevc_: get_symbol(&libs, b"ztgevc_\0").map(|sym| *sym),
            ctgexc_: get_symbol(&libs, b"ctgexc_\0").map(|sym| *sym),
            dtgexc_: get_symbol(&libs, b"dtgexc_\0").map(|sym| *sym),
            stgexc_: get_symbol(&libs, b"stgexc_\0").map(|sym| *sym),
            ztgexc_: get_symbol(&libs, b"ztgexc_\0").map(|sym| *sym),
            ctgsen_: get_symbol(&libs, b"ctgsen_\0").map(|sym| *sym),
            dtgsen_: get_symbol(&libs, b"dtgsen_\0").map(|sym| *sym),
            stgsen_: get_symbol(&libs, b"stgsen_\0").map(|sym| *sym),
            ztgsen_: get_symbol(&libs, b"ztgsen_\0").map(|sym| *sym),
            ctgsja_: get_symbol(&libs, b"ctgsja_\0").map(|sym| *sym),
            dtgsja_: get_symbol(&libs, b"dtgsja_\0").map(|sym| *sym),
            stgsja_: get_symbol(&libs, b"stgsja_\0").map(|sym| *sym),
            ztgsja_: get_symbol(&libs, b"ztgsja_\0").map(|sym| *sym),
            ctgsna_: get_symbol(&libs, b"ctgsna_\0").map(|sym| *sym),
            dtgsna_: get_symbol(&libs, b"dtgsna_\0").map(|sym| *sym),
            stgsna_: get_symbol(&libs, b"stgsna_\0").map(|sym| *sym),
            ztgsna_: get_symbol(&libs, b"ztgsna_\0").map(|sym| *sym),
            ctgsyl_: get_symbol(&libs, b"ctgsyl_\0").map(|sym| *sym),
            dtgsyl_: get_symbol(&libs, b"dtgsyl_\0").map(|sym| *sym),
            stgsyl_: get_symbol(&libs, b"stgsyl_\0").map(|sym| *sym),
            ztgsyl_: get_symbol(&libs, b"ztgsyl_\0").map(|sym| *sym),
            ctpcon_: get_symbol(&libs, b"ctpcon_\0").map(|sym| *sym),
            dtpcon_: get_symbol(&libs, b"dtpcon_\0").map(|sym| *sym),
            stpcon_: get_symbol(&libs, b"stpcon_\0").map(|sym| *sym),
            ztpcon_: get_symbol(&libs, b"ztpcon_\0").map(|sym| *sym),
            ctplqt_: get_symbol(&libs, b"ctplqt_\0").map(|sym| *sym),
            dtplqt_: get_symbol(&libs, b"dtplqt_\0").map(|sym| *sym),
            stplqt_: get_symbol(&libs, b"stplqt_\0").map(|sym| *sym),
            ztplqt_: get_symbol(&libs, b"ztplqt_\0").map(|sym| *sym),
            ctplqt2_: get_symbol(&libs, b"ctplqt2_\0").map(|sym| *sym),
            dtplqt2_: get_symbol(&libs, b"dtplqt2_\0").map(|sym| *sym),
            stplqt2_: get_symbol(&libs, b"stplqt2_\0").map(|sym| *sym),
            ztplqt2_: get_symbol(&libs, b"ztplqt2_\0").map(|sym| *sym),
            ctpmlqt_: get_symbol(&libs, b"ctpmlqt_\0").map(|sym| *sym),
            dtpmlqt_: get_symbol(&libs, b"dtpmlqt_\0").map(|sym| *sym),
            stpmlqt_: get_symbol(&libs, b"stpmlqt_\0").map(|sym| *sym),
            ztpmlqt_: get_symbol(&libs, b"ztpmlqt_\0").map(|sym| *sym),
            ctpmqrt_: get_symbol(&libs, b"ctpmqrt_\0").map(|sym| *sym),
            dtpmqrt_: get_symbol(&libs, b"dtpmqrt_\0").map(|sym| *sym),
            stpmqrt_: get_symbol(&libs, b"stpmqrt_\0").map(|sym| *sym),
            ztpmqrt_: get_symbol(&libs, b"ztpmqrt_\0").map(|sym| *sym),
            ctpqrt_: get_symbol(&libs, b"ctpqrt_\0").map(|sym| *sym),
            dtpqrt_: get_symbol(&libs, b"dtpqrt_\0").map(|sym| *sym),
            stpqrt_: get_symbol(&libs, b"stpqrt_\0").map(|sym| *sym),
            ztpqrt_: get_symbol(&libs, b"ztpqrt_\0").map(|sym| *sym),
            ctpqrt2_: get_symbol(&libs, b"ctpqrt2_\0").map(|sym| *sym),
            dtpqrt2_: get_symbol(&libs, b"dtpqrt2_\0").map(|sym| *sym),
            stpqrt2_: get_symbol(&libs, b"stpqrt2_\0").map(|sym| *sym),
            ztpqrt2_: get_symbol(&libs, b"ztpqrt2_\0").map(|sym| *sym),
            ctprfb_: get_symbol(&libs, b"ctprfb_\0").map(|sym| *sym),
            dtprfb_: get_symbol(&libs, b"dtprfb_\0").map(|sym| *sym),
            stprfb_: get_symbol(&libs, b"stprfb_\0").map(|sym| *sym),
            ztprfb_: get_symbol(&libs, b"ztprfb_\0").map(|sym| *sym),
            ctprfs_: get_symbol(&libs, b"ctprfs_\0").map(|sym| *sym),
            dtprfs_: get_symbol(&libs, b"dtprfs_\0").map(|sym| *sym),
            stprfs_: get_symbol(&libs, b"stprfs_\0").map(|sym| *sym),
            ztprfs_: get_symbol(&libs, b"ztprfs_\0").map(|sym| *sym),
            ctptri_: get_symbol(&libs, b"ctptri_\0").map(|sym| *sym),
            dtptri_: get_symbol(&libs, b"dtptri_\0").map(|sym| *sym),
            stptri_: get_symbol(&libs, b"stptri_\0").map(|sym| *sym),
            ztptri_: get_symbol(&libs, b"ztptri_\0").map(|sym| *sym),
            ctptrs_: get_symbol(&libs, b"ctptrs_\0").map(|sym| *sym),
            dtptrs_: get_symbol(&libs, b"dtptrs_\0").map(|sym| *sym),
            stptrs_: get_symbol(&libs, b"stptrs_\0").map(|sym| *sym),
            ztptrs_: get_symbol(&libs, b"ztptrs_\0").map(|sym| *sym),
            ctpttf_: get_symbol(&libs, b"ctpttf_\0").map(|sym| *sym),
            dtpttf_: get_symbol(&libs, b"dtpttf_\0").map(|sym| *sym),
            stpttf_: get_symbol(&libs, b"stpttf_\0").map(|sym| *sym),
            ztpttf_: get_symbol(&libs, b"ztpttf_\0").map(|sym| *sym),
            ctpttr_: get_symbol(&libs, b"ctpttr_\0").map(|sym| *sym),
            dtpttr_: get_symbol(&libs, b"dtpttr_\0").map(|sym| *sym),
            stpttr_: get_symbol(&libs, b"stpttr_\0").map(|sym| *sym),
            ztpttr_: get_symbol(&libs, b"ztpttr_\0").map(|sym| *sym),
            ctrcon_: get_symbol(&libs, b"ctrcon_\0").map(|sym| *sym),
            dtrcon_: get_symbol(&libs, b"dtrcon_\0").map(|sym| *sym),
            strcon_: get_symbol(&libs, b"strcon_\0").map(|sym| *sym),
            ztrcon_: get_symbol(&libs, b"ztrcon_\0").map(|sym| *sym),
            ctrevc_: get_symbol(&libs, b"ctrevc_\0").map(|sym| *sym),
            dtrevc_: get_symbol(&libs, b"dtrevc_\0").map(|sym| *sym),
            strevc_: get_symbol(&libs, b"strevc_\0").map(|sym| *sym),
            ztrevc_: get_symbol(&libs, b"ztrevc_\0").map(|sym| *sym),
            ctrevc3_: get_symbol(&libs, b"ctrevc3_\0").map(|sym| *sym),
            dtrevc3_: get_symbol(&libs, b"dtrevc3_\0").map(|sym| *sym),
            strevc3_: get_symbol(&libs, b"strevc3_\0").map(|sym| *sym),
            ztrevc3_: get_symbol(&libs, b"ztrevc3_\0").map(|sym| *sym),
            ctrexc_: get_symbol(&libs, b"ctrexc_\0").map(|sym| *sym),
            dtrexc_: get_symbol(&libs, b"dtrexc_\0").map(|sym| *sym),
            strexc_: get_symbol(&libs, b"strexc_\0").map(|sym| *sym),
            ztrexc_: get_symbol(&libs, b"ztrexc_\0").map(|sym| *sym),
            ctrrfs_: get_symbol(&libs, b"ctrrfs_\0").map(|sym| *sym),
            dtrrfs_: get_symbol(&libs, b"dtrrfs_\0").map(|sym| *sym),
            strrfs_: get_symbol(&libs, b"strrfs_\0").map(|sym| *sym),
            ztrrfs_: get_symbol(&libs, b"ztrrfs_\0").map(|sym| *sym),
            ctrsen_: get_symbol(&libs, b"ctrsen_\0").map(|sym| *sym),
            dtrsen_: get_symbol(&libs, b"dtrsen_\0").map(|sym| *sym),
            strsen_: get_symbol(&libs, b"strsen_\0").map(|sym| *sym),
            ztrsen_: get_symbol(&libs, b"ztrsen_\0").map(|sym| *sym),
            ctrsna_: get_symbol(&libs, b"ctrsna_\0").map(|sym| *sym),
            dtrsna_: get_symbol(&libs, b"dtrsna_\0").map(|sym| *sym),
            strsna_: get_symbol(&libs, b"strsna_\0").map(|sym| *sym),
            ztrsna_: get_symbol(&libs, b"ztrsna_\0").map(|sym| *sym),
            ctrsyl_: get_symbol(&libs, b"ctrsyl_\0").map(|sym| *sym),
            dtrsyl_: get_symbol(&libs, b"dtrsyl_\0").map(|sym| *sym),
            strsyl_: get_symbol(&libs, b"strsyl_\0").map(|sym| *sym),
            ztrsyl_: get_symbol(&libs, b"ztrsyl_\0").map(|sym| *sym),
            ctrsyl3_: get_symbol(&libs, b"ctrsyl3_\0").map(|sym| *sym),
            dtrsyl3_: get_symbol(&libs, b"dtrsyl3_\0").map(|sym| *sym),
            strsyl3_: get_symbol(&libs, b"strsyl3_\0").map(|sym| *sym),
            ztrsyl3_: get_symbol(&libs, b"ztrsyl3_\0").map(|sym| *sym),
            ctrtri_: get_symbol(&libs, b"ctrtri_\0").map(|sym| *sym),
            dtrtri_: get_symbol(&libs, b"dtrtri_\0").map(|sym| *sym),
            strtri_: get_symbol(&libs, b"strtri_\0").map(|sym| *sym),
            ztrtri_: get_symbol(&libs, b"ztrtri_\0").map(|sym| *sym),
            ctrtrs_: get_symbol(&libs, b"ctrtrs_\0").map(|sym| *sym),
            dtrtrs_: get_symbol(&libs, b"dtrtrs_\0").map(|sym| *sym),
            strtrs_: get_symbol(&libs, b"strtrs_\0").map(|sym| *sym),
            ztrtrs_: get_symbol(&libs, b"ztrtrs_\0").map(|sym| *sym),
            ctrttf_: get_symbol(&libs, b"ctrttf_\0").map(|sym| *sym),
            dtrttf_: get_symbol(&libs, b"dtrttf_\0").map(|sym| *sym),
            strttf_: get_symbol(&libs, b"strttf_\0").map(|sym| *sym),
            ztrttf_: get_symbol(&libs, b"ztrttf_\0").map(|sym| *sym),
            ctrttp_: get_symbol(&libs, b"ctrttp_\0").map(|sym| *sym),
            dtrttp_: get_symbol(&libs, b"dtrttp_\0").map(|sym| *sym),
            strttp_: get_symbol(&libs, b"strttp_\0").map(|sym| *sym),
            ztrttp_: get_symbol(&libs, b"ztrttp_\0").map(|sym| *sym),
            ctzrzf_: get_symbol(&libs, b"ctzrzf_\0").map(|sym| *sym),
            dtzrzf_: get_symbol(&libs, b"dtzrzf_\0").map(|sym| *sym),
            stzrzf_: get_symbol(&libs, b"stzrzf_\0").map(|sym| *sym),
            ztzrzf_: get_symbol(&libs, b"ztzrzf_\0").map(|sym| *sym),
            cunbdb_: get_symbol(&libs, b"cunbdb_\0").map(|sym| *sym),
            zunbdb_: get_symbol(&libs, b"zunbdb_\0").map(|sym| *sym),
            cuncsd_: get_symbol(&libs, b"cuncsd_\0").map(|sym| *sym),
            zuncsd_: get_symbol(&libs, b"zuncsd_\0").map(|sym| *sym),
            cuncsd2by1_: get_symbol(&libs, b"cuncsd2by1_\0").map(|sym| *sym),
            zuncsd2by1_: get_symbol(&libs, b"zuncsd2by1_\0").map(|sym| *sym),
            cungbr_: get_symbol(&libs, b"cungbr_\0").map(|sym| *sym),
            zungbr_: get_symbol(&libs, b"zungbr_\0").map(|sym| *sym),
            cunghr_: get_symbol(&libs, b"cunghr_\0").map(|sym| *sym),
            zunghr_: get_symbol(&libs, b"zunghr_\0").map(|sym| *sym),
            cunglq_: get_symbol(&libs, b"cunglq_\0").map(|sym| *sym),
            zunglq_: get_symbol(&libs, b"zunglq_\0").map(|sym| *sym),
            cungql_: get_symbol(&libs, b"cungql_\0").map(|sym| *sym),
            zungql_: get_symbol(&libs, b"zungql_\0").map(|sym| *sym),
            cungqr_: get_symbol(&libs, b"cungqr_\0").map(|sym| *sym),
            zungqr_: get_symbol(&libs, b"zungqr_\0").map(|sym| *sym),
            cungrq_: get_symbol(&libs, b"cungrq_\0").map(|sym| *sym),
            zungrq_: get_symbol(&libs, b"zungrq_\0").map(|sym| *sym),
            cungtr_: get_symbol(&libs, b"cungtr_\0").map(|sym| *sym),
            zungtr_: get_symbol(&libs, b"zungtr_\0").map(|sym| *sym),
            cungtsqr_row_: get_symbol(&libs, b"cungtsqr_row_\0").map(|sym| *sym),
            zungtsqr_row_: get_symbol(&libs, b"zungtsqr_row_\0").map(|sym| *sym),
            cunhr_col_: get_symbol(&libs, b"cunhr_col_\0").map(|sym| *sym),
            zunhr_col_: get_symbol(&libs, b"zunhr_col_\0").map(|sym| *sym),
            cunmbr_: get_symbol(&libs, b"cunmbr_\0").map(|sym| *sym),
            zunmbr_: get_symbol(&libs, b"zunmbr_\0").map(|sym| *sym),
            cunmhr_: get_symbol(&libs, b"cunmhr_\0").map(|sym| *sym),
            zunmhr_: get_symbol(&libs, b"zunmhr_\0").map(|sym| *sym),
            cunmlq_: get_symbol(&libs, b"cunmlq_\0").map(|sym| *sym),
            zunmlq_: get_symbol(&libs, b"zunmlq_\0").map(|sym| *sym),
            cunmql_: get_symbol(&libs, b"cunmql_\0").map(|sym| *sym),
            zunmql_: get_symbol(&libs, b"zunmql_\0").map(|sym| *sym),
            cunmqr_: get_symbol(&libs, b"cunmqr_\0").map(|sym| *sym),
            zunmqr_: get_symbol(&libs, b"zunmqr_\0").map(|sym| *sym),
            cunmrq_: get_symbol(&libs, b"cunmrq_\0").map(|sym| *sym),
            zunmrq_: get_symbol(&libs, b"zunmrq_\0").map(|sym| *sym),
            cunmrz_: get_symbol(&libs, b"cunmrz_\0").map(|sym| *sym),
            zunmrz_: get_symbol(&libs, b"zunmrz_\0").map(|sym| *sym),
            cunmtr_: get_symbol(&libs, b"cunmtr_\0").map(|sym| *sym),
            zunmtr_: get_symbol(&libs, b"zunmtr_\0").map(|sym| *sym),
            cupgtr_: get_symbol(&libs, b"cupgtr_\0").map(|sym| *sym),
            zupgtr_: get_symbol(&libs, b"zupgtr_\0").map(|sym| *sym),
            cupmtr_: get_symbol(&libs, b"cupmtr_\0").map(|sym| *sym),
            zupmtr_: get_symbol(&libs, b"zupmtr_\0").map(|sym| *sym),
        };
        result.__libraries = libs;
        result.__libraries_path = libs_path;
        result
    }
}