package nuod:lapacke
Source

⌘K
Ctrl+K
or
/

    Index

    Variables (0)

    This section is empty.

    Procedures (1256)
    Procedure Groups (0)

    This section is empty.

    Types

    LAPACK_C_SELECT1 ¶
    Source

    LAPACK_C_SELECT1 :: proc "c" (w: ^complex64) -> i64
    Related Procedures With Parameters

    LAPACK_C_SELECT2 ¶
    Source

    LAPACK_C_SELECT2 :: proc "c" (w: ^complex64, vl: ^complex64) -> i64
    Related Procedures With Parameters

    LAPACK_D_SELECT2 ¶
    Source

    LAPACK_D_SELECT2 :: proc "c" (ar: ^f64, ai: ^f64) -> i64
    Related Procedures With Parameters

    LAPACK_D_SELECT3 ¶
    Source

    LAPACK_D_SELECT3 :: proc "c" (ar: ^f64, ai: ^f64, b: ^f64) -> i64
    Related Procedures With Parameters

    LAPACK_S_SELECT2 ¶
    Source

    LAPACK_S_SELECT2 :: proc "c" (ar: ^f32, ai: ^f32) -> i64
    Related Procedures With Parameters

    LAPACK_S_SELECT3 ¶
    Source

    LAPACK_S_SELECT3 :: proc "c" (ar: ^f32, ai: ^f32, b: ^f32) -> i64
    Related Procedures With Parameters

    LAPACK_Z_SELECT1 ¶
    Source

    LAPACK_Z_SELECT1 :: proc "c" (w: ^complex128) -> i64
    Related Procedures With Parameters

    LAPACK_Z_SELECT2 ¶
    Source

    LAPACK_Z_SELECT2 :: proc "c" (w: ^complex128, vl: ^complex128) -> i64
    Related Procedures With Parameters

    bfloat16 ¶
    Source

    bfloat16 :: u16

    blasint ¶
    Source

    blasint :: i64
    Related Procedures With Parameters
    Related Procedures With Returns

    Constants

    LAPACK_COL_MAJOR ¶
    Source

    LAPACK_COL_MAJOR :: 102

    LAPACK_ROW_MAJOR ¶
    Source

    LAPACK_ROW_MAJOR :: 101

    LAPACK_TRANSPOSE_MEMORY_ERROR ¶
    Source

    LAPACK_TRANSPOSE_MEMORY_ERROR :: -1011

    LAPACK_WORK_MEMORY_ERROR ¶
    Source

    LAPACK_WORK_MEMORY_ERROR :: -1010

    OPENBLAS_SUPPORTED ¶
    Source

    OPENBLAS_SUPPORTED: bool : true

    Variables

    This section is empty.

    Procedures

    cbbcsd ¶
    Source

    cbbcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	theta:         ^f32, 
	phi:           ^f32, 
	u1:            ^complex64, 
	ldu1:          i64, 
	u2:            ^complex64, 
	ldu2:          i64, 
	v1t:           ^complex64, 
	ldv1t:         i64, 
	v2t:           ^complex64, 
	ldv2t:         i64, 
	b11d:          ^f32, 
	b11e:          ^f32, 
	b12d:          ^f32, 
	b12e:          ^f32, 
	b21d:          ^f32, 
	b21e:          ^f32, 
	b22d:          ^f32, 
	b22e:          ^f32, 
) -> i64 ---
     

    LAPACK 3.3.0

    cbdsqr ¶
    Source

    cbdsqr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ncvt:          i64, 
	nru:           i64, 
	ncc:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vt:            [^]complex64, 
	ldvt:          i64, 
	u:             [^]complex64, 
	ldu:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cgbbrd ¶
    Source

    cgbbrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	ncc:           i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	q:             [^]complex64, 
	ldq:           i64, 
	pt:            [^]complex64, 
	ldpt:          i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cgbcon ¶
    Source

    cgbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cgbequ ¶
    Source

    cgbequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cgbequb ¶
    Source

    cgbequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cgbrfs ¶
    Source

    cgbrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cgbrfsx ¶
    Source

    cgbrfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cgbsv ¶
    Source

    cgbsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgbsvx ¶
    Source

    cgbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
	rpivot:        ^f32, 
) -> i64 ---

    cgbsvxx ¶
    Source

    cgbsvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cgbtrf ¶
    Source

    cgbtrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    cgbtrs ¶
    Source

    cgbtrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgebak ¶
    Source

    cgebak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	scale:         [^]f32, 
	m:             i64, 
	v:             [^]complex64, 
	ldv:           i64, 
) -> i64 ---

    cgebal ¶
    Source

    cgebal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f32, 
) -> i64 ---

    cgebrd ¶
    Source

    cgebrd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	tauq:          [^]complex64, 
	taup:          [^]complex64, 
) -> i64 ---

    cgecon ¶
    Source

    cgecon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cgeequ ¶
    Source

    cgeequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cgeequb ¶
    Source

    cgeequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cgees ¶
    Source

    cgees :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_C_SELECT1, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	sdim:          ^i64, 
	w:             [^]complex64, 
	vs:            [^]complex64, 
	ldvs:          i64, 
) -> i64 ---

    cgeesx ¶
    Source

    cgeesx :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_C_SELECT1, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	sdim:          ^i64, 
	w:             [^]complex64, 
	vs:            [^]complex64, 
	ldvs:          i64, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    cgeev ¶
    Source

    cgeev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
) -> i64 ---

    cgeevx ¶
    Source

    cgeevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f32, 
	abnrm:         ^f32, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    cgehrd ¶
    Source

    cgehrd :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgejsv ¶
    Source

    cgejsv :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	jobr:          u8, 
	jobt:          u8, 
	jobp:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	sva:           ^f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	stat:          ^f32, 
	istat:         ^i64, 
) -> i64 ---

    cgelq ¶
    Source

    cgelq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	tsize:         i64, 
) -> i64 ---

    cgelq2 ¶
    Source

    cgelq2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgelqf ¶
    Source

    cgelqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgels ¶
    Source

    cgels :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgelsd ¶
    Source

    cgelsd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	s:             [^]f32, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    cgelss ¶
    Source

    cgelss :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	s:             [^]f32, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    cgelsy ¶
    Source

    cgelsy :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	jpvt:          ^i64, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    cgemlq ¶
    Source

    cgemlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	tsize:         i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cgemqr ¶
    Source

    cgemqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	tsize:         i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cgemqrt ¶
    Source

    cgemqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	nb:            i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cgeqlf ¶
    Source

    cgeqlf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqp3 ¶
    Source

    cgeqp3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqpf ¶
    Source

    cgeqpf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqr ¶
    Source

    cgeqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	tsize:         i64, 
) -> i64 ---

    cgeqr2 ¶
    Source

    cgeqr2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqrf ¶
    Source

    cgeqrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqrfp ¶
    Source

    cgeqrfp :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgeqrt ¶
    Source

    cgeqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    cgeqrt2 ¶
    Source

    cgeqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    cgeqrt3 ¶
    Source

    cgeqrt3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    cgerfs ¶
    Source

    cgerfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cgerfsx ¶
    Source

    cgerfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cgerqf ¶
    Source

    cgerqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cgesdd ¶
    Source

    cgesdd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	vt:            [^]complex64, 
	ldvt:          i64, 
) -> i64 ---

    cgesv ¶
    Source

    cgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgesvd ¶
    Source

    cgesvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	vt:            [^]complex64, 
	ldvt:          i64, 
	superb:        [^]f32, 
) -> i64 ---

    cgesvdq ¶
    Source

    cgesvdq :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobp:          u8, 
	jobr:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	numrank:       ^i64, 
) -> i64 ---

    cgesvdx ¶
    Source

    cgesvdx :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	range:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	vt:            [^]complex64, 
	ldvt:          i64, 
	superb:        [^]i64, 
) -> i64 ---

    cgesvj ¶
    Source

    cgesvj :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	sva:           ^f32, 
	mv:            i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	stat:          ^f32, 
) -> i64 ---

    cgesvx ¶
    Source

    cgesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
	rpivot:        ^f32, 
) -> i64 ---

    cgesvxx ¶
    Source

    cgesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cgetf2 ¶
    Source

    cgetf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    cgetrf ¶
    Source

    cgetrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    cgetrf2 ¶
    Source

    cgetrf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    cgetri ¶
    Source

    cgetri :: proc "c" (matrix_layout: i32, n: i64, a: [^]complex64, lda: i64, ipiv: [^]i64) -> i64 ---

    cgetrs ¶
    Source

    cgetrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgetsls ¶
    Source

    cgetsls :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgetsqrhrt ¶
    Source

    cgetsqrhrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb1:           i64, 
	nb1:           i64, 
	nb2:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    cggbak ¶
    Source

    cggbak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
	m:             i64, 
	v:             [^]complex64, 
	ldv:           i64, 
) -> i64 ---

    cggbal ¶
    Source

    cggbal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
) -> i64 ---

    cgges ¶
    Source

    cgges :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_C_SELECT2, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vsl:           ^complex64, 
	ldvsl:         i64, 
	vsr:           ^complex64, 
	ldvsr:         i64, 
) -> i64 ---

    cgges3 ¶
    Source

    cgges3 :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_C_SELECT2, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vsl:           ^complex64, 
	ldvsl:         i64, 
	vsr:           ^complex64, 
	ldvsr:         i64, 
) -> i64 ---

    cggesx ¶
    Source

    cggesx :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_C_SELECT2, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vsl:           ^complex64, 
	ldvsl:         i64, 
	vsr:           ^complex64, 
	ldvsr:         i64, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    cggev ¶
    Source

    cggev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
) -> i64 ---

    cggev3 ¶
    Source

    cggev3 :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
) -> i64 ---

    cggevx ¶
    Source

    cggevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
	abnrm:         ^f32, 
	bbnrm:         ^f32, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    cggglm ¶
    Source

    cggglm :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	d:             [^]complex64, 
	x:             [^]complex64, 
	y:             ^complex64, 
) -> i64 ---

    cgghd3 ¶
    Source

    cgghd3 :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    cgghrd ¶
    Source

    cgghrd :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    cgglse ¶
    Source

    cgglse :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	_c:            [^]complex64, 
	d:             [^]complex64, 
	x:             [^]complex64, 
) -> i64 ---

    cggqrf ¶
    Source

    cggqrf :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	taua:          ^complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	taub:          ^complex64, 
) -> i64 ---

    cggrqf ¶
    Source

    cggrqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	taua:          ^complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	taub:          ^complex64, 
) -> i64 ---

    cggsvd ¶
    Source

    cggsvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    cggsvd3 ¶
    Source

    cggsvd3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    cggsvp ¶
    Source

    cggsvp :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
) -> i64 ---

    cggsvp3 ¶
    Source

    cggsvp3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
) -> i64 ---

    cgtcon ¶
    Source

    cgtcon :: proc "c" (
	norm:  u8, 
	n:     i64, 
	dl:    [^]complex64, 
	d:     [^]complex64, 
	du:    [^]complex64, 
	du2:   [^]complex64, 
	ipiv:  [^]i64, 
	anorm: f32, 
	rcond: ^f32, 
) -> i64 ---

    cgtrfs ¶
    Source

    cgtrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex64, 
	d:             [^]complex64, 
	du:            [^]complex64, 
	dlf:           ^complex64, 
	df:            [^]complex64, 
	duf:           ^complex64, 
	du2:           [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cgtsv ¶
    Source

    cgtsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex64, 
	d:             [^]complex64, 
	du:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cgtsvx ¶
    Source

    cgtsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex64, 
	d:             [^]complex64, 
	du:            [^]complex64, 
	dlf:           ^complex64, 
	df:            [^]complex64, 
	duf:           ^complex64, 
	du2:           [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cgttrf ¶
    Source

    cgttrf :: proc "c" (
	n:    i64, 
	dl:   [^]complex64, 
	d:    [^]complex64, 
	du:   [^]complex64, 
	du2:  [^]complex64, 
	ipiv: [^]i64, 
) -> i64 ---

    cgttrs ¶
    Source

    cgttrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex64, 
	d:             [^]complex64, 
	du:            [^]complex64, 
	du2:           [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chbev ¶
    Source

    chbev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbev_2stage ¶
    Source

    chbev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbevd ¶
    Source

    chbevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbevd_2stage ¶
    Source

    chbevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbevx ¶
    Source

    chbevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chbevx_2stage ¶
    Source

    chbevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chbgst ¶
    Source

    chbgst :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	bb:            ^complex64, 
	ldbb:          i64, 
	x:             [^]complex64, 
	ldx:           i64, 
) -> i64 ---

    chbgv ¶
    Source

    chbgv :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	bb:            ^complex64, 
	ldbb:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbgvd ¶
    Source

    chbgvd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	bb:            ^complex64, 
	ldbb:          i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chbgvx ¶
    Source

    chbgvx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	bb:            ^complex64, 
	ldbb:          i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chbtrd ¶
    Source

    chbtrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	q:             [^]complex64, 
	ldq:           i64, 
) -> i64 ---

    checon ¶
    Source

    checon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    checon_3 ¶
    Source

    checon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cheequb ¶
    Source

    cheequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cheev ¶
    Source

    cheev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    cheev_2stage ¶
    Source

    cheev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    cheevd ¶
    Source

    cheevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    cheevd_2stage ¶
    Source

    cheevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    cheevr ¶
    Source

    cheevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    cheevr_2stage ¶
    Source

    cheevr_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    cheevx ¶
    Source

    cheevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    cheevx_2stage ¶
    Source

    cheevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chegst ¶
    Source

    chegst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chegv ¶
    Source

    chegv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    chegv_2stage ¶
    Source

    chegv_2stage :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    chegvd ¶
    Source

    chegvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    chegvx ¶
    Source

    chegvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    cherfs ¶
    Source

    cherfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cherfsx ¶
    Source

    cherfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    chesv ¶
    Source

    chesv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chesv_aa ¶
    Source

    chesv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chesv_aa_2stage ¶
    Source

    chesv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chesv_rk ¶
    Source

    chesv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chesvx ¶
    Source

    chesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    chesvxx ¶
    Source

    chesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cheswapr ¶
    Source

    cheswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    chetrd ¶
    Source

    chetrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	tau:           [^]complex64, 
) -> i64 ---

    chetrf ¶
    Source

    chetrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetrf_aa ¶
    Source

    chetrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetrf_aa_2stage ¶
    Source

    chetrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    chetrf_rk ¶
    Source

    chetrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetrf_rook ¶
    Source

    chetrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetri ¶
    Source

    chetri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetri2 ¶
    Source

    chetri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetri2x ¶
    Source

    chetri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    chetri_3 ¶
    Source

    chetri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
) -> i64 ---

    chetrs ¶
    Source

    chetrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chetrs2 ¶
    Source

    chetrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chetrs_3 ¶
    Source

    chetrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chetrs_aa ¶
    Source

    chetrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chetrs_aa_2stage ¶
    Source

    chetrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chetrs_rook ¶
    Source

    chetrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chfrk ¶
    Source

    chfrk :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	trans:         u8, 
	n:             i64, 
	k:             i64, 
	alpha:         f32, 
	a:             [^]complex64, 
	lda:           i64, 
	beta:          f32, 
	_c:            [^]complex64, 
) -> i64 ---

    chgeqz ¶
    Source

    chgeqz :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]complex64, 
	ldh:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	q:             [^]complex64, 
	ldq:           i64, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chpcon ¶
    Source

    chpcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    chpev ¶
    Source

    chpev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chpevd ¶
    Source

    chpevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chpevx ¶
    Source

    chpevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chpgst ¶
    Source

    chpgst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	bp:            [^]complex64, 
) -> i64 ---

    chpgv ¶
    Source

    chpgv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	bp:            [^]complex64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chpgvd ¶
    Source

    chpgvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	bp:            [^]complex64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    chpgvx ¶
    Source

    chpgvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	bp:            [^]complex64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    chprfs ¶
    Source

    chprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    chpsv ¶
    Source

    chpsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chpsvx ¶
    Source

    chpsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    chptrd ¶
    Source

    chptrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	d:             [^]f32, 
	e:             [^]f32, 
	tau:           [^]complex64, 
) -> i64 ---

    chptrf ¶
    Source

    chptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64, ipiv: [^]i64) -> i64 ---

    chptri ¶
    Source

    chptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64, ipiv: [^]i64) -> i64 ---

    chptrs ¶
    Source

    chptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    chsein ¶
    Source

    chsein :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	eigsrc:        u8, 
	initv:         u8, 
	select:        [^]i64, 
	n:             i64, 
	h:             [^]complex64, 
	ldh:           i64, 
	w:             [^]complex64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
	ifaill:        ^i64, 
	ifailr:        ^i64, 
) -> i64 ---

    chseqr ¶
    Source

    chseqr :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]complex64, 
	ldh:           i64, 
	w:             [^]complex64, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    clacgv ¶
    Source

    clacgv :: proc "c" (n: i64, x: [^]complex64, incx: i64) -> i64 ---

    clacn2 ¶
    Source

    clacn2 :: proc "c" (
	n:     i64, 
	v:     [^]complex64, 
	x:     [^]complex64, 
	est:   ^f32, 
	kase:  ^i64, 
	isave: ^i64, 
) -> i64 ---

    clacp2 ¶
    Source

    clacp2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    clacpy ¶
    Source

    clacpy :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    clacrm ¶
    Source

    clacrm :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    clag2z ¶
    Source

    clag2z :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	sa:            ^complex64, 
	ldsa:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    clagge ¶
    Source

    clagge :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	d:             [^]f32, 
	a:             [^]complex64, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    claghe ¶
    Source

    claghe :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f32, 
	a:             [^]complex64, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    clagsy ¶
    Source

    clagsy :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f32, 
	a:             [^]complex64, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    clangb ¶
    Source

    clangb :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
) -> f32 ---

    clange ¶
    Source

    clange :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> f32 ---

    clanhe ¶
    Source

    clanhe :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> f32 ---

    clansy ¶
    Source

    clansy :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> f32 ---

    clantr ¶
    Source

    clantr :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> f32 ---

    clapmr ¶
    Source

    clapmr :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    clapmt ¶
    Source

    clapmt :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    clarcm ¶
    Source

    clarcm :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    clarfb ¶
    Source

    clarfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    clarfg ¶
    Source

    clarfg :: proc "c" (n: i64, alpha: [^]complex64, x: [^]complex64, incx: i64, tau: [^]complex64) -> i64 ---

    clarft ¶
    Source

    clarft :: proc "c" (
	matrix_layout: i32, 
	direct:        u8, 
	storev:        u8, 
	n:             i64, 
	k:             i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	tau:           [^]complex64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    clarfx ¶
    Source

    clarfx :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	m:             i64, 
	n:             i64, 
	v:             [^]complex64, 
	tau:           complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
	work:          [^]complex64, 
) -> i64 ---

    clarnv ¶
    Source

    clarnv :: proc "c" (idist: i64, iseed: [^]i64, n: i64, x: [^]complex64) -> i64 ---

    clascl ¶
    Source

    clascl :: proc "c" (
	matrix_layout: i32, 
	type:          u8, 
	kl:            i64, 
	ku:            i64, 
	cfrom:         f32, 
	cto:           f32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    claset ¶
    Source

    claset :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         complex64, 
	beta:          complex64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    classq ¶
    Source

    classq :: proc "c" (n: i64, x: [^]complex64, incx: i64, scale: [^]f32, sumsq: ^f32) -> i64 ---

    claswp ¶
    Source

    claswp :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	k1:            i64, 
	k2:            i64, 
	ipiv:          [^]i64, 
	incx:          i64, 
) -> i64 ---

    clatms ¶
    Source

    clatms :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	dist:          u8, 
	iseed:         [^]i64, 
	sym:           u8, 
	d:             [^]f32, 
	mode:          i64, 
	cond:          f32, 
	dmax:          f32, 
	kl:            i64, 
	ku:            i64, 
	pack:          u8, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    clauum ¶
    Source

    clauum :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex64, lda: i64) -> i64 ---

    cpbcon ¶
    Source

    cpbcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cpbequ ¶
    Source

    cpbequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cpbrfs ¶
    Source

    cpbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cpbstf ¶
    Source

    cpbstf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kb:            i64, 
	bb:            ^complex64, 
	ldbb:          i64, 
) -> i64 ---

    cpbsv ¶
    Source

    cpbsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cpbsvx ¶
    Source

    cpbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	afb:           [^]complex64, 
	ldafb:         i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cpbtrf ¶
    Source

    cpbtrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
) -> i64 ---

    cpbtrs ¶
    Source

    cpbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cpftrf ¶
    Source

    cpftrf :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]complex64) -> i64 ---

    cpftri ¶
    Source

    cpftri :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]complex64) -> i64 ---

    cpftrs ¶
    Source

    cpftrs :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cpocon ¶
    Source

    cpocon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cpoequ ¶
    Source

    cpoequ :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cpoequb ¶
    Source

    cpoequb :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cporfs ¶
    Source

    cporfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cporfsx ¶
    Source

    cporfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cposv ¶
    Source

    cposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cposvx ¶
    Source

    cposvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cposvxx ¶
    Source

    cposvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    cpotrf ¶
    Source

    cpotrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex64, lda: i64) -> i64 ---

    cpotrf2 ¶
    Source

    cpotrf2 :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex64, lda: i64) -> i64 ---

    cpotri ¶
    Source

    cpotri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex64, lda: i64) -> i64 ---

    cpotrs ¶
    Source

    cpotrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cppcon ¶
    Source

    cppcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    cppequ ¶
    Source

    cppequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    cpprfs ¶
    Source

    cpprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cppsv ¶
    Source

    cppsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cppsvx ¶
    Source

    cppsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cpptrf ¶
    Source

    cpptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64) -> i64 ---

    cpptri ¶
    Source

    cpptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64) -> i64 ---

    cpptrs ¶
    Source

    cpptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cpstrf ¶
    Source

    cpstrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	piv:           ^i64, 
	rank:          ^i64, 
	tol:           f32, 
) -> i64 ---

    cptcon ¶
    Source

    cptcon :: proc "c" (n: i64, d: [^]f32, e: [^]complex64, anorm: f32, rcond: ^f32) -> i64 ---

    cpteqr ¶
    Source

    cpteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    cptrfs ¶
    Source

    cptrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]complex64, 
	df:            [^]f32, 
	ef:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cptsv ¶
    Source

    cptsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cptsvx ¶
    Source

    cptsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]complex64, 
	df:            [^]f32, 
	ef:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cpttrf ¶
    Source

    cpttrf :: proc "c" (n: i64, d: [^]f32, e: [^]complex64) -> i64 ---

    cpttrs ¶
    Source

    cpttrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cspcon ¶
    Source

    cspcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    csprfs ¶
    Source

    csprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    cspsv ¶
    Source

    cspsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cspsvx ¶
    Source

    cspsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	afp:           ^complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    csptrf ¶
    Source

    csptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64, ipiv: [^]i64) -> i64 ---

    csptri ¶
    Source

    csptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex64, ipiv: [^]i64) -> i64 ---

    csptrs ¶
    Source

    csptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    cstedc ¶
    Source

    cstedc :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    cstegr ¶
    Source

    cstegr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    cstein ¶
    Source

    cstein :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	m:             i64, 
	w:             [^]f32, 
	iblock:        ^i64, 
	isplit:        ^i64, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifailv:        ^i64, 
) -> i64 ---

    cstemr ¶
    Source

    cstemr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
	nzc:           i64, 
	isuppz:        [^]i64, 
	tryrac:        ^i64, 
) -> i64 ---

    csteqr ¶
    Source

    csteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]complex64, 
	ldz:           i64, 
) -> i64 ---

    csycon ¶
    Source

    csycon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    csycon_3 ¶
    Source

    csycon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    csyconv ¶
    Source

    csyconv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	way:           u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	e:             [^]complex64, 
) -> i64 ---

    csyequb ¶
    Source

    csyequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    csyr ¶
    Source

    csyr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	alpha:         complex64, 
	x:             [^]complex64, 
	incx:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    csyrfs ¶
    Source

    csyrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    csyrfsx ¶
    Source

    csyrfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    csysv ¶
    Source

    csysv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csysv_aa ¶
    Source

    csysv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csysv_aa_2stage ¶
    Source

    csysv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csysv_rk ¶
    Source

    csysv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csysv_rook ¶
    Source

    csysv_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csysvx ¶
    Source

    csysvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    csysvxx ¶
    Source

    csysvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	af:            ^complex64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    csyswapr ¶
    Source

    csyswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    csytrf ¶
    Source

    csytrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytrf_aa ¶
    Source

    csytrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytrf_aa_2stage ¶
    Source

    csytrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    csytrf_rk ¶
    Source

    csytrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytrf_rook ¶
    Source

    csytrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytri ¶
    Source

    csytri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytri2 ¶
    Source

    csytri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytri2x ¶
    Source

    csytri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    csytri_3 ¶
    Source

    csytri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
) -> i64 ---

    csytrs ¶
    Source

    csytrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csytrs2 ¶
    Source

    csytrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csytrs_3 ¶
    Source

    csytrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	e:             [^]complex64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csytrs_aa ¶
    Source

    csytrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csytrs_aa_2stage ¶
    Source

    csytrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tb:            ^complex64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    csytrs_rook ¶
    Source

    csytrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctbcon ¶
    Source

    ctbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	rcond:         ^f32, 
) -> i64 ---

    ctbrfs ¶
    Source

    ctbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ctbtrs ¶
    Source

    ctbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex64, 
	ldab:          i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctfsm ¶
    Source

    ctfsm :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         complex64, 
	a:             [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctftri ¶
    Source

    ctftri :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex64, 
) -> i64 ---

    ctfttp ¶
    Source

    ctfttp :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^complex64, 
	ap:            [^]complex64, 
) -> i64 ---

    ctfttr ¶
    Source

    ctfttr :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^complex64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    ctgevc ¶
    Source

    ctgevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	s:             [^]complex64, 
	lds:           i64, 
	p:             ^complex64, 
	ldp:           i64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ctgexc ¶
    Source

    ctgexc :: proc "c" (
	matrix_layout: i32, 
	wantq:         i64, 
	wantz:         i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	z:             [^]complex64, 
	ldz:           i64, 
	ifst:          i64, 
	ilst:          i64, 
) -> i64 ---

    ctgsen ¶
    Source

    ctgsen :: proc "c" (
	matrix_layout: i32, 
	ijob:          i64, 
	wantq:         i64, 
	wantz:         i64, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	alpha:         [^]complex64, 
	beta:          [^]complex64, 
	q:             [^]complex64, 
	ldq:           i64, 
	z:             [^]complex64, 
	ldz:           i64, 
	m:             ^i64, 
	pl:            ^f32, 
	pr:            ^f32, 
	dif:           ^f32, 
) -> i64 ---

    ctgsja ¶
    Source

    ctgsja :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]complex64, 
	ldu:           i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	ncycle:        ^i64, 
) -> i64 ---

    ctgsna ¶
    Source

    ctgsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	s:             [^]f32, 
	dif:           ^f32, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ctgsyl ¶
    Source

    ctgsyl :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	ijob:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
	d:             [^]complex64, 
	ldd:           i64, 
	e:             [^]complex64, 
	lde:           i64, 
	f:             ^complex64, 
	ldf:           i64, 
	scale:         [^]f32, 
	dif:           ^f32, 
) -> i64 ---

    ctpcon ¶
    Source

    ctpcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	rcond:         ^f32, 
) -> i64 ---

    ctpmqrt ¶
    Source

    ctpmqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	nb:            i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctpqrt ¶
    Source

    ctpqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	nb:            i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    ctpqrt2 ¶
    Source

    ctpqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    ctprfb ¶
    Source

    ctprfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	v:             [^]complex64, 
	ldv:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctprfs ¶
    Source

    ctprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ctptri ¶
    Source

    ctptri :: proc "c" (matrix_layout: i32, uplo: u8, diag: u8, n: i64, ap: [^]complex64) -> i64 ---

    ctptrs ¶
    Source

    ctptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctpttf ¶
    Source

    ctpttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	arf:           ^complex64, 
) -> i64 ---

    ctpttr ¶
    Source

    ctpttr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    ctrcon ¶
    Source

    ctrcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	rcond:         ^f32, 
) -> i64 ---

    ctrevc ¶
    Source

    ctrevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ctrexc ¶
    Source

    ctrexc :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	n:             i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	ifst:          i64, 
	ilst:          i64, 
) -> i64 ---

    ctrrfs ¶
    Source

    ctrrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	x:             [^]complex64, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ctrsen ¶
    Source

    ctrsen :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	q:             [^]complex64, 
	ldq:           i64, 
	w:             [^]complex64, 
	m:             ^i64, 
	s:             [^]f32, 
	sep:           [^]f32, 
) -> i64 ---

    ctrsna ¶
    Source

    ctrsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	vl:            [^]complex64, 
	ldvl:          i64, 
	vr:            [^]complex64, 
	ldvr:          i64, 
	s:             [^]f32, 
	sep:           [^]f32, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ctrsyl ¶
    Source

    ctrsyl :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
	_c:            [^]complex64, 
	ldc:           i64, 
	scale:         [^]f32, 
) -> i64 ---

    ctrtri ¶
    Source

    ctrtri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
) -> i64 ---

    ctrtrs ¶
    Source

    ctrtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex64, 
	lda:           i64, 
	b:             [^]complex64, 
	ldb:           i64, 
) -> i64 ---

    ctrttf ¶
    Source

    ctrttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	arf:           ^complex64, 
) -> i64 ---

    ctrttp ¶
    Source

    ctrttp :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	ap:            [^]complex64, 
) -> i64 ---

    ctzrzf ¶
    Source

    ctzrzf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cunbdb ¶
    Source

    cunbdb :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex64, 
	ldx11:         i64, 
	x12:           ^complex64, 
	ldx12:         i64, 
	x21:           ^complex64, 
	ldx21:         i64, 
	x22:           ^complex64, 
	ldx22:         i64, 
	theta:         ^f32, 
	phi:           ^f32, 
	taup1:         ^complex64, 
	taup2:         ^complex64, 
	tauq1:         ^complex64, 
	tauq2:         ^complex64, 
) -> i64 ---

    cuncsd ¶
    Source

    cuncsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex64, 
	ldx11:         i64, 
	x12:           ^complex64, 
	ldx12:         i64, 
	x21:           ^complex64, 
	ldx21:         i64, 
	x22:           ^complex64, 
	ldx22:         i64, 
	theta:         ^f32, 
	u1:            ^complex64, 
	ldu1:          i64, 
	u2:            ^complex64, 
	ldu2:          i64, 
	v1t:           ^complex64, 
	ldv1t:         i64, 
	v2t:           ^complex64, 
	ldv2t:         i64, 
) -> i64 ---

    cuncsd2by1 ¶
    Source

    cuncsd2by1 :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex64, 
	ldx11:         i64, 
	x21:           ^complex64, 
	ldx21:         i64, 
	theta:         ^f32, 
	u1:            ^complex64, 
	ldu1:          i64, 
	u2:            ^complex64, 
	ldu2:          i64, 
	v1t:           ^complex64, 
	ldv1t:         i64, 
) -> i64 ---

    cungbr ¶
    Source

    cungbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cunghr ¶
    Source

    cunghr :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cunglq ¶
    Source

    cunglq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cungql ¶
    Source

    cungql :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cungqr ¶
    Source

    cungqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cungrq ¶
    Source

    cungrq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cungtr ¶
    Source

    cungtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
) -> i64 ---

    cungtsqr_row ¶
    Source

    cungtsqr_row :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb:            i64, 
	nb:            i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
) -> i64 ---

    cunhr_col ¶
    Source

    cunhr_col :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]complex64, 
	lda:           i64, 
	t:             [^]complex64, 
	ldt:           i64, 
	d:             [^]complex64, 
) -> i64 ---

    cunmbr ¶
    Source

    cunmbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmhr ¶
    Source

    cunmhr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmlq ¶
    Source

    cunmlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmql ¶
    Source

    cunmql :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmqr ¶
    Source

    cunmqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmrq ¶
    Source

    cunmrq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmrz ¶
    Source

    cunmrz :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cunmtr ¶
    Source

    cunmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex64, 
	lda:           i64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    cupgtr ¶
    Source

    cupgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex64, 
	tau:           [^]complex64, 
	q:             [^]complex64, 
	ldq:           i64, 
) -> i64 ---

    cupmtr ¶
    Source

    cupmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ap:            [^]complex64, 
	tau:           [^]complex64, 
	_c:            [^]complex64, 
	ldc:           i64, 
) -> i64 ---

    dbbcsd ¶
    Source

    dbbcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	theta:         ^f64, 
	phi:           ^f64, 
	u1:            ^f64, 
	ldu1:          i64, 
	u2:            ^f64, 
	ldu2:          i64, 
	v1t:           ^f64, 
	ldv1t:         i64, 
	v2t:           ^f64, 
	ldv2t:         i64, 
	b11d:          ^f64, 
	b11e:          ^f64, 
	b12d:          ^f64, 
	b12e:          ^f64, 
	b21d:          ^f64, 
	b21e:          ^f64, 
	b22d:          ^f64, 
	b22e:          ^f64, 
) -> i64 ---

    dbdsdc ¶
    Source

    dbdsdc :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	compq:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	vt:            [^]f64, 
	ldvt:          i64, 
	q:             [^]f64, 
	iq:            [^]i64, 
) -> i64 ---

    dbdsqr ¶
    Source

    dbdsqr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ncvt:          i64, 
	nru:           i64, 
	ncc:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vt:            [^]f64, 
	ldvt:          i64, 
	u:             [^]f64, 
	ldu:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dbdsvdx ¶
    Source

    dbdsvdx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	superb:        [^]i64, 
) -> i64 ---

    ddisna ¶
    Source

    ddisna :: proc "c" (job: u8, m: i64, n: i64, d: [^]f64, sep: [^]f64) -> i64 ---

    dgbbrd ¶
    Source

    dgbbrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	ncc:           i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	q:             [^]f64, 
	ldq:           i64, 
	pt:            [^]f64, 
	ldpt:          i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dgbcon ¶
    Source

    dgbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dgbequ ¶
    Source

    dgbequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dgbequb ¶
    Source

    dgbequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dgbrfs ¶
    Source

    dgbrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dgbrfsx ¶
    Source

    dgbrfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dgbsv ¶
    Source

    dgbsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgbsvx ¶
    Source

    dgbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
	rpivot:        ^f64, 
) -> i64 ---

    dgbsvxx ¶
    Source

    dgbsvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dgbtrf ¶
    Source

    dgbtrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dgbtrs ¶
    Source

    dgbtrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgebak ¶
    Source

    dgebak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	scale:         [^]f64, 
	m:             i64, 
	v:             [^]f64, 
	ldv:           i64, 
) -> i64 ---

    dgebal ¶
    Source

    dgebal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f64, 
) -> i64 ---

    dgebrd ¶
    Source

    dgebrd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	tauq:          [^]f64, 
	taup:          [^]f64, 
) -> i64 ---

    dgecon ¶
    Source

    dgecon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dgeequ ¶
    Source

    dgeequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dgeequb ¶
    Source

    dgeequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dgees ¶
    Source

    dgees :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_D_SELECT2, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	sdim:          ^i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	vs:            [^]f64, 
	ldvs:          i64, 
) -> i64 ---

    dgeesx ¶
    Source

    dgeesx :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_D_SELECT2, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	sdim:          ^i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	vs:            [^]f64, 
	ldvs:          i64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    dgeev ¶
    Source

    dgeev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
) -> i64 ---

    dgeevx ¶
    Source

    dgeevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f64, 
	abnrm:         ^f64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    dgehrd ¶
    Source

    dgehrd :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgejsv ¶
    Source

    dgejsv :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	jobr:          u8, 
	jobt:          u8, 
	jobp:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	sva:           ^f64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	stat:          ^f64, 
	istat:         ^i64, 
) -> i64 ---

    dgelq ¶
    Source

    dgelq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	tsize:         i64, 
) -> i64 ---

    dgelq2 ¶
    Source

    dgelq2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgelqf ¶
    Source

    dgelqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgels ¶
    Source

    dgels :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgelsd ¶
    Source

    dgelsd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	s:             [^]f64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    dgelss ¶
    Source

    dgelss :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	s:             [^]f64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    dgelsy ¶
    Source

    dgelsy :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	jpvt:          ^i64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    dgemlq ¶
    Source

    dgemlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	tsize:         i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dgemqr ¶
    Source

    dgemqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	tsize:         i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dgemqrt ¶
    Source

    dgemqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	nb:            i64, 
	v:             [^]f64, 
	ldv:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dgeqlf ¶
    Source

    dgeqlf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqp3 ¶
    Source

    dgeqp3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqpf ¶
    Source

    dgeqpf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqr ¶
    Source

    dgeqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	tsize:         i64, 
) -> i64 ---

    dgeqr2 ¶
    Source

    dgeqr2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqrf ¶
    Source

    dgeqrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqrfp ¶
    Source

    dgeqrfp :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgeqrt ¶
    Source

    dgeqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dgeqrt2 ¶
    Source

    dgeqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dgeqrt3 ¶
    Source

    dgeqrt3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dgerfs ¶
    Source

    dgerfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dgerfsx ¶
    Source

    dgerfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dgerqf ¶
    Source

    dgerqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dgesdd ¶
    Source

    dgesdd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	vt:            [^]f64, 
	ldvt:          i64, 
) -> i64 ---

    dgesv ¶
    Source

    dgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgesvd ¶
    Source

    dgesvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	vt:            [^]f64, 
	ldvt:          i64, 
	superb:        [^]f64, 
) -> i64 ---

    dgesvdq ¶
    Source

    dgesvdq :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobp:          u8, 
	jobr:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	numrank:       ^i64, 
) -> i64 ---

    dgesvdx ¶
    Source

    dgesvdx :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	range:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	vt:            [^]f64, 
	ldvt:          i64, 
	superb:        [^]i64, 
) -> i64 ---

    dgesvj ¶
    Source

    dgesvj :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	sva:           ^f64, 
	mv:            i64, 
	v:             [^]f64, 
	ldv:           i64, 
	stat:          ^f64, 
) -> i64 ---

    dgesvx ¶
    Source

    dgesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
	rpivot:        ^f64, 
) -> i64 ---

    dgesvxx ¶
    Source

    dgesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dgetf2 ¶
    Source

    dgetf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dgetrf ¶
    Source

    dgetrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dgetrf2 ¶
    Source

    dgetrf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dgetri ¶
    Source

    dgetri :: proc "c" (matrix_layout: i32, n: i64, a: [^]f64, lda: i64, ipiv: [^]i64) -> i64 ---

    dgetrs ¶
    Source

    dgetrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgetsls ¶
    Source

    dgetsls :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgetsqrhrt ¶
    Source

    dgetsqrhrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb1:           i64, 
	nb1:           i64, 
	nb2:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dggbak ¶
    Source

    dggbak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
	m:             i64, 
	v:             [^]f64, 
	ldv:           i64, 
) -> i64 ---

    dggbal ¶
    Source

    dggbal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
) -> i64 ---

    dgges ¶
    Source

    dgges :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_D_SELECT3, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vsl:           ^f64, 
	ldvsl:         i64, 
	vsr:           ^f64, 
	ldvsr:         i64, 
) -> i64 ---

    dgges3 ¶
    Source

    dgges3 :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_D_SELECT3, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vsl:           ^f64, 
	ldvsl:         i64, 
	vsr:           ^f64, 
	ldvsr:         i64, 
) -> i64 ---

    dggesx ¶
    Source

    dggesx :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_D_SELECT3, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vsl:           ^f64, 
	ldvsl:         i64, 
	vsr:           ^f64, 
	ldvsr:         i64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    dggev ¶
    Source

    dggev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
) -> i64 ---

    dggev3 ¶
    Source

    dggev3 :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
) -> i64 ---

    dggevx ¶
    Source

    dggevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
	abnrm:         ^f64, 
	bbnrm:         ^f64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    dggglm ¶
    Source

    dggglm :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	d:             [^]f64, 
	x:             [^]f64, 
	y:             ^f64, 
) -> i64 ---

    dgghd3 ¶
    Source

    dgghd3 :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dgghrd ¶
    Source

    dgghrd :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dgglse ¶
    Source

    dgglse :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	_c:            [^]f64, 
	d:             [^]f64, 
	x:             [^]f64, 
) -> i64 ---

    dggqrf ¶
    Source

    dggqrf :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	taua:          ^f64, 
	b:             [^]f64, 
	ldb:           i64, 
	taub:          ^f64, 
) -> i64 ---

    dggrqf ¶
    Source

    dggrqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	taua:          ^f64, 
	b:             [^]f64, 
	ldb:           i64, 
	taub:          ^f64, 
) -> i64 ---

    dggsvd ¶
    Source

    dggsvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    dggsvd3 ¶
    Source

    dggsvd3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    dggsvp ¶
    Source

    dggsvp :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
) -> i64 ---

    dggsvp3 ¶
    Source

    dggsvp3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
) -> i64 ---

    dgtcon ¶
    Source

    dgtcon :: proc "c" (
	norm:  u8, 
	n:     i64, 
	dl:    [^]f64, 
	d:     [^]f64, 
	du:    [^]f64, 
	du2:   [^]f64, 
	ipiv:  [^]i64, 
	anorm: f64, 
	rcond: ^f64, 
) -> i64 ---

    dgtrfs ¶
    Source

    dgtrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f64, 
	d:             [^]f64, 
	du:            [^]f64, 
	dlf:           ^f64, 
	df:            [^]f64, 
	duf:           ^f64, 
	du2:           [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dgtsv ¶
    Source

    dgtsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f64, 
	d:             [^]f64, 
	du:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dgtsvx ¶
    Source

    dgtsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f64, 
	d:             [^]f64, 
	du:            [^]f64, 
	dlf:           ^f64, 
	df:            [^]f64, 
	duf:           ^f64, 
	du2:           [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dgttrf ¶
    Source

    dgttrf :: proc "c" (
	n:    i64, 
	dl:   [^]f64, 
	d:    [^]f64, 
	du:   [^]f64, 
	du2:  [^]f64, 
	ipiv: [^]i64, 
) -> i64 ---

    dgttrs ¶
    Source

    dgttrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f64, 
	d:             [^]f64, 
	du:            [^]f64, 
	du2:           [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dhgeqz ¶
    Source

    dhgeqz :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]f64, 
	ldh:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	q:             [^]f64, 
	ldq:           i64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dhsein ¶
    Source

    dhsein :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	eigsrc:        u8, 
	initv:         u8, 
	select:        [^]i64, 
	n:             i64, 
	h:             [^]f64, 
	ldh:           i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
	ifaill:        ^i64, 
	ifailr:        ^i64, 
) -> i64 ---

    dhseqr ¶
    Source

    dhseqr :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]f64, 
	ldh:           i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dlacn2 ¶
    Source

    dlacn2 :: proc "c" (
	n:     i64, 
	v:     [^]f64, 
	x:     [^]f64, 
	isgn:  [^]i64, 
	est:   ^f64, 
	kase:  ^i64, 
	isave: ^i64, 
) -> i64 ---

    dlacpy ¶
    Source

    dlacpy :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dlag2s ¶
    Source

    dlag2s :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	sa:            ^f32, 
	ldsa:          i64, 
) -> i64 ---

    dlagge ¶
    Source

    dlagge :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	d:             [^]f64, 
	a:             [^]f64, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    dlagsy ¶
    Source

    dlagsy :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f64, 
	a:             [^]f64, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    dlamch ¶
    Source

    dlamch :: proc "c" (cmach: u8) -> f64 ---

    dlangb ¶
    Source

    dlangb :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
) -> f64 ---

    dlange ¶
    Source

    dlange :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> f64 ---

    dlansy ¶
    Source

    dlansy :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> f64 ---

    dlantr ¶
    Source

    dlantr :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> f64 ---

    dlapmr ¶
    Source

    dlapmr :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]f64, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    dlapmt ¶
    Source

    dlapmt :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]f64, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    dlapy2 ¶
    Source

    dlapy2 :: proc "c" (x: f64, y: f64) -> f64 ---

    dlapy3 ¶
    Source

    dlapy3 :: proc "c" (x: f64, y: f64, z: f64) -> f64 ---

    dlarfb ¶
    Source

    dlarfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	v:             [^]f64, 
	ldv:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dlarfg ¶
    Source

    dlarfg :: proc "c" (n: i64, alpha: [^]f64, x: [^]f64, incx: i64, tau: [^]f64) -> i64 ---

    dlarft ¶
    Source

    dlarft :: proc "c" (
	matrix_layout: i32, 
	direct:        u8, 
	storev:        u8, 
	n:             i64, 
	k:             i64, 
	v:             [^]f64, 
	ldv:           i64, 
	tau:           [^]f64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dlarfx ¶
    Source

    dlarfx :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	m:             i64, 
	n:             i64, 
	v:             [^]f64, 
	tau:           f64, 
	_c:            [^]f64, 
	ldc:           i64, 
	work:          [^]f64, 
) -> i64 ---

    dlarnv ¶
    Source

    dlarnv :: proc "c" (idist: i64, iseed: [^]i64, n: i64, x: [^]f64) -> i64 ---

    dlartgp ¶
    Source

    dlartgp :: proc "c" (f: f64, g: f64, cs: ^f64, sn: ^f64, r: [^]f64) -> i64 ---

    dlartgs ¶
    Source

    dlartgs :: proc "c" (x: f64, y: f64, sigma: f64, cs: ^f64, sn: ^f64) -> i64 ---

    dlascl ¶
    Source

    dlascl :: proc "c" (
	matrix_layout: i32, 
	type:          u8, 
	kl:            i64, 
	ku:            i64, 
	cfrom:         f64, 
	cto:           f64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dlaset ¶
    Source

    dlaset :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         f64, 
	beta:          f64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dlasrt ¶
    Source

    dlasrt :: proc "c" (id: u8, n: i64, d: [^]f64) -> i64 ---

    dlassq ¶
    Source

    dlassq :: proc "c" (n: i64, x: [^]f64, incx: i64, scale: [^]f64, sumsq: ^f64) -> i64 ---

    dlaswp ¶
    Source

    dlaswp :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	k1:            i64, 
	k2:            i64, 
	ipiv:          [^]i64, 
	incx:          i64, 
) -> i64 ---

    dlatms ¶
    Source

    dlatms :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	dist:          u8, 
	iseed:         [^]i64, 
	sym:           u8, 
	d:             [^]f64, 
	mode:          i64, 
	cond:          f64, 
	dmax:          f64, 
	kl:            i64, 
	ku:            i64, 
	pack:          u8, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dlauum ¶
    Source

    dlauum :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f64, lda: i64) -> i64 ---

    dopgtr ¶
    Source

    dopgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	tau:           [^]f64, 
	q:             [^]f64, 
	ldq:           i64, 
) -> i64 ---

    dopmtr ¶
    Source

    dopmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ap:            [^]f64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dorbdb ¶
    Source

    dorbdb :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f64, 
	ldx11:         i64, 
	x12:           ^f64, 
	ldx12:         i64, 
	x21:           ^f64, 
	ldx21:         i64, 
	x22:           ^f64, 
	ldx22:         i64, 
	theta:         ^f64, 
	phi:           ^f64, 
	taup1:         ^f64, 
	taup2:         ^f64, 
	tauq1:         ^f64, 
	tauq2:         ^f64, 
) -> i64 ---

    dorcsd ¶
    Source

    dorcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f64, 
	ldx11:         i64, 
	x12:           ^f64, 
	ldx12:         i64, 
	x21:           ^f64, 
	ldx21:         i64, 
	x22:           ^f64, 
	ldx22:         i64, 
	theta:         ^f64, 
	u1:            ^f64, 
	ldu1:          i64, 
	u2:            ^f64, 
	ldu2:          i64, 
	v1t:           ^f64, 
	ldv1t:         i64, 
	v2t:           ^f64, 
	ldv2t:         i64, 
) -> i64 ---

    dorcsd2by1 ¶
    Source

    dorcsd2by1 :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f64, 
	ldx11:         i64, 
	x21:           ^f64, 
	ldx21:         i64, 
	theta:         ^f64, 
	u1:            ^f64, 
	ldu1:          i64, 
	u2:            ^f64, 
	ldu2:          i64, 
	v1t:           ^f64, 
	ldv1t:         i64, 
) -> i64 ---

    dorgbr ¶
    Source

    dorgbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorghr ¶
    Source

    dorghr :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorglq ¶
    Source

    dorglq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorgql ¶
    Source

    dorgql :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorgqr ¶
    Source

    dorgqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorgrq ¶
    Source

    dorgrq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorgtr ¶
    Source

    dorgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    dorgtsqr_row ¶
    Source

    dorgtsqr_row :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb:            i64, 
	nb:            i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dorhr_col ¶
    Source

    dorhr_col :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]f64, 
	lda:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	d:             [^]f64, 
) -> i64 ---

    dormbr ¶
    Source

    dormbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormhr ¶
    Source

    dormhr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormlq ¶
    Source

    dormlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormql ¶
    Source

    dormql :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormqr ¶
    Source

    dormqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormrq ¶
    Source

    dormrq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormrz ¶
    Source

    dormrz :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dormtr ¶
    Source

    dormtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
	_c:            [^]f64, 
	ldc:           i64, 
) -> i64 ---

    dpbcon ¶
    Source

    dpbcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dpbequ ¶
    Source

    dpbequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dpbrfs ¶
    Source

    dpbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dpbstf ¶
    Source

    dpbstf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kb:            i64, 
	bb:            ^f64, 
	ldbb:          i64, 
) -> i64 ---

    dpbsv ¶
    Source

    dpbsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dpbsvx ¶
    Source

    dpbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	afb:           [^]f64, 
	ldafb:         i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dpbtrf ¶
    Source

    dpbtrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
) -> i64 ---

    dpbtrs ¶
    Source

    dpbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dpftrf ¶
    Source

    dpftrf :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]f64) -> i64 ---

    dpftri ¶
    Source

    dpftri :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]f64) -> i64 ---

    dpftrs ¶
    Source

    dpftrs :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dpocon ¶
    Source

    dpocon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dpoequ ¶
    Source

    dpoequ :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dpoequb ¶
    Source

    dpoequb :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dporfs ¶
    Source

    dporfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dporfsx ¶
    Source

    dporfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dposv ¶
    Source

    dposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dposvx ¶
    Source

    dposvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dposvxx ¶
    Source

    dposvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dpotrf ¶
    Source

    dpotrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f64, lda: i64) -> i64 ---

    dpotrf2 ¶
    Source

    dpotrf2 :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f64, lda: i64) -> i64 ---

    dpotri ¶
    Source

    dpotri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f64, lda: i64) -> i64 ---

    dpotrs ¶
    Source

    dpotrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dppcon ¶
    Source

    dppcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dppequ ¶
    Source

    dppequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dpprfs ¶
    Source

    dpprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	afp:           ^f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dppsv ¶
    Source

    dppsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dppsvx ¶
    Source

    dppsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	afp:           ^f64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dpptrf ¶
    Source

    dpptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f64) -> i64 ---

    dpptri ¶
    Source

    dpptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f64) -> i64 ---

    dpptrs ¶
    Source

    dpptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dpstrf ¶
    Source

    dpstrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	piv:           ^i64, 
	rank:          ^i64, 
	tol:           f64, 
) -> i64 ---

    dptcon ¶
    Source

    dptcon :: proc "c" (n: i64, d: [^]f64, e: [^]f64, anorm: f64, rcond: ^f64) -> i64 ---

    dpteqr ¶
    Source

    dpteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dptrfs ¶
    Source

    dptrfs :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	df:            [^]f64, 
	ef:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dptsv ¶
    Source

    dptsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dptsvx ¶
    Source

    dptsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	df:            [^]f64, 
	ef:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dpttrf ¶
    Source

    dpttrf :: proc "c" (n: i64, d: [^]f64, e: [^]f64) -> i64 ---

    dpttrs ¶
    Source

    dpttrs :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsbev ¶
    Source

    dsbev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbev_2stage ¶
    Source

    dsbev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbevd ¶
    Source

    dsbevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbevd_2stage ¶
    Source

    dsbevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbevx ¶
    Source

    dsbevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	q:             [^]f64, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsbevx_2stage ¶
    Source

    dsbevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	q:             [^]f64, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsbgst ¶
    Source

    dsbgst :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	bb:            ^f64, 
	ldbb:          i64, 
	x:             [^]f64, 
	ldx:           i64, 
) -> i64 ---

    dsbgv ¶
    Source

    dsbgv :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	bb:            ^f64, 
	ldbb:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbgvd ¶
    Source

    dsbgvd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	bb:            ^f64, 
	ldbb:          i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsbgvx ¶
    Source

    dsbgvx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	bb:            ^f64, 
	ldbb:          i64, 
	q:             [^]f64, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsbtrd ¶
    Source

    dsbtrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	q:             [^]f64, 
	ldq:           i64, 
) -> i64 ---

    dsfrk ¶
    Source

    dsfrk :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	trans:         u8, 
	n:             i64, 
	k:             i64, 
	alpha:         f64, 
	a:             [^]f64, 
	lda:           i64, 
	beta:          f64, 
	_c:            [^]f64, 
) -> i64 ---

    dsgesv ¶
    Source

    dsgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	iter:          ^i64, 
) -> i64 ---

    dspcon ¶
    Source

    dspcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dspev ¶
    Source

    dspev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dspevd ¶
    Source

    dspevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dspevx ¶
    Source

    dspevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dspgst ¶
    Source

    dspgst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	bp:            [^]f64, 
) -> i64 ---

    dspgv ¶
    Source

    dspgv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	bp:            [^]f64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dspgvd ¶
    Source

    dspgvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	bp:            [^]f64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dspgvx ¶
    Source

    dspgvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	bp:            [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsposv ¶
    Source

    dsposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	iter:          ^i64, 
) -> i64 ---

    dsprfs ¶
    Source

    dsprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	afp:           ^f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dspsv ¶
    Source

    dspsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dspsvx ¶
    Source

    dspsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	afp:           ^f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dsptrd ¶
    Source

    dsptrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	d:             [^]f64, 
	e:             [^]f64, 
	tau:           [^]f64, 
) -> i64 ---

    dsptrf ¶
    Source

    dsptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f64, ipiv: [^]i64) -> i64 ---

    dsptri ¶
    Source

    dsptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f64, ipiv: [^]i64) -> i64 ---

    dsptrs ¶
    Source

    dsptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dstebz ¶
    Source

    dstebz :: proc "c" (
	range:  u8, 
	order:  u8, 
	n:      i64, 
	vl:     f64, 
	vu:     f64, 
	il:     i64, 
	iu:     i64, 
	abstol: f64, 
	d:      [^]f64, 
	e:      [^]f64, 
	m:      ^i64, 
	nsplit: ^i64, 
	w:      [^]f64, 
	iblock: ^i64, 
	isplit: ^i64, 
) -> i64 ---

    dstedc ¶
    Source

    dstedc :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dstegr ¶
    Source

    dstegr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    dstein ¶
    Source

    dstein :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	m:             i64, 
	w:             [^]f64, 
	iblock:        ^i64, 
	isplit:        ^i64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifailv:        ^i64, 
) -> i64 ---

    dstemr ¶
    Source

    dstemr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	nzc:           i64, 
	isuppz:        [^]i64, 
	tryrac:        ^i64, 
) -> i64 ---

    dsteqr ¶
    Source

    dsteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dsterf ¶
    Source

    dsterf :: proc "c" (n: i64, d: [^]f64, e: [^]f64) -> i64 ---

    dstev ¶
    Source

    dstev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dstevd ¶
    Source

    dstevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
) -> i64 ---

    dstevr ¶
    Source

    dstevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    dstevx ¶
    Source

    dstevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsycon ¶
    Source

    dsycon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dsycon_3 ¶
    Source

    dsycon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	e:             [^]f64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    dsyconv ¶
    Source

    dsyconv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	way:           u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	e:             [^]f64, 
) -> i64 ---

    dsyequb ¶
    Source

    dsyequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    dsyev ¶
    Source

    dsyev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsyev_2stage ¶
    Source

    dsyev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsyevd ¶
    Source

    dsyevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsyevd_2stage ¶
    Source

    dsyevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsyevr ¶
    Source

    dsyevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    dsyevr_2stage ¶
    Source

    dsyevr_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    dsyevx ¶
    Source

    dsyevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsyevx_2stage ¶
    Source

    dsyevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsygst ¶
    Source

    dsygst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsygv ¶
    Source

    dsygv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsygv_2stage ¶
    Source

    dsygv_2stage :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsygvd ¶
    Source

    dsygvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    dsygvx ¶
    Source

    dsygvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    dsyrfs ¶
    Source

    dsyrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dsyrfsx ¶
    Source

    dsyrfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dsysv ¶
    Source

    dsysv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsysv_aa ¶
    Source

    dsysv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsysv_aa_2stage ¶
    Source

    dsysv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	tb:            ^f64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsysv_rk ¶
    Source

    dsysv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	e:             [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsysv_rook ¶
    Source

    dsysv_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsysvx ¶
    Source

    dsysvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dsysvxx ¶
    Source

    dsysvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	af:            ^f64, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    dsyswapr ¶
    Source

    dsyswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    dsytrd ¶
    Source

    dsytrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	tau:           [^]f64, 
) -> i64 ---

    dsytrf ¶
    Source

    dsytrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytrf_aa ¶
    Source

    dsytrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytrf_aa_2stage ¶
    Source

    dsytrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tb:            ^f64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    dsytrf_rk ¶
    Source

    dsytrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	e:             [^]f64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytrf_rook ¶
    Source

    dsytrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytri ¶
    Source

    dsytri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytri2 ¶
    Source

    dsytri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytri2x ¶
    Source

    dsytri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    dsytri_3 ¶
    Source

    dsytri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	e:             [^]f64, 
	ipiv:          [^]i64, 
) -> i64 ---

    dsytrs ¶
    Source

    dsytrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsytrs2 ¶
    Source

    dsytrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsytrs_3 ¶
    Source

    dsytrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	e:             [^]f64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsytrs_aa ¶
    Source

    dsytrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsytrs_aa_2stage ¶
    Source

    dsytrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	tb:            ^f64, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dsytrs_rook ¶
    Source

    dsytrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtbcon ¶
    Source

    dtbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	rcond:         ^f64, 
) -> i64 ---

    dtbrfs ¶
    Source

    dtbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dtbtrs ¶
    Source

    dtbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f64, 
	ldab:          i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtfsm ¶
    Source

    dtfsm :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         f64, 
	a:             [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtftri ¶
    Source

    dtftri :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f64, 
) -> i64 ---

    dtfttp ¶
    Source

    dtfttp :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^f64, 
	ap:            [^]f64, 
) -> i64 ---

    dtfttr ¶
    Source

    dtfttr :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^f64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dtgevc ¶
    Source

    dtgevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	s:             [^]f64, 
	lds:           i64, 
	p:             ^f64, 
	ldp:           i64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    dtgexc ¶
    Source

    dtgexc :: proc "c" (
	matrix_layout: i32, 
	wantq:         i64, 
	wantz:         i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	z:             [^]f64, 
	ldz:           i64, 
	ifst:          ^i64, 
	ilst:          ^i64, 
) -> i64 ---

    dtgsen ¶
    Source

    dtgsen :: proc "c" (
	matrix_layout: i32, 
	ijob:          i64, 
	wantq:         i64, 
	wantz:         i64, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	alphar:        ^f64, 
	alphai:        ^f64, 
	beta:          [^]f64, 
	q:             [^]f64, 
	ldq:           i64, 
	z:             [^]f64, 
	ldz:           i64, 
	m:             ^i64, 
	pl:            ^f64, 
	pr:            ^f64, 
	dif:           ^f64, 
) -> i64 ---

    dtgsja ¶
    Source

    dtgsja :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]f64, 
	ldu:           i64, 
	v:             [^]f64, 
	ldv:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	ncycle:        ^i64, 
) -> i64 ---

    dtgsna ¶
    Source

    dtgsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	s:             [^]f64, 
	dif:           ^f64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    dtgsyl ¶
    Source

    dtgsyl :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	ijob:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
	d:             [^]f64, 
	ldd:           i64, 
	e:             [^]f64, 
	lde:           i64, 
	f:             ^f64, 
	ldf:           i64, 
	scale:         [^]f64, 
	dif:           ^f64, 
) -> i64 ---

    dtpcon ¶
    Source

    dtpcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	rcond:         ^f64, 
) -> i64 ---

    dtpmqrt ¶
    Source

    dtpmqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	nb:            i64, 
	v:             [^]f64, 
	ldv:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtpqrt ¶
    Source

    dtpqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	nb:            i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dtpqrt2 ¶
    Source

    dtpqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
) -> i64 ---

    dtprfb ¶
    Source

    dtprfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	v:             [^]f64, 
	ldv:           i64, 
	t:             [^]f64, 
	ldt:           i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtprfs ¶
    Source

    dtprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dtptri ¶
    Source

    dtptri :: proc "c" (matrix_layout: i32, uplo: u8, diag: u8, n: i64, ap: [^]f64) -> i64 ---

    dtptrs ¶
    Source

    dtptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtpttf ¶
    Source

    dtpttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	arf:           ^f64, 
) -> i64 ---

    dtpttr ¶
    Source

    dtpttr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dtrcon ¶
    Source

    dtrcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	rcond:         ^f64, 
) -> i64 ---

    dtrevc ¶
    Source

    dtrevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f64, 
	ldt:           i64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    dtrexc ¶
    Source

    dtrexc :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	n:             i64, 
	t:             [^]f64, 
	ldt:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	ifst:          ^i64, 
	ilst:          ^i64, 
) -> i64 ---

    dtrrfs ¶
    Source

    dtrrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	x:             [^]f64, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    dtrsen ¶
    Source

    dtrsen :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f64, 
	ldt:           i64, 
	q:             [^]f64, 
	ldq:           i64, 
	wr:            [^]f64, 
	wi:            [^]f64, 
	m:             ^i64, 
	s:             [^]f64, 
	sep:           [^]f64, 
) -> i64 ---

    dtrsna ¶
    Source

    dtrsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f64, 
	ldt:           i64, 
	vl:            [^]f64, 
	ldvl:          i64, 
	vr:            [^]f64, 
	ldvr:          i64, 
	s:             [^]f64, 
	sep:           [^]f64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    dtrsyl ¶
    Source

    dtrsyl :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
	scale:         [^]f64, 
) -> i64 ---

    dtrsyl3 ¶
    Source

    dtrsyl3 :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	_c:            [^]f64, 
	ldc:           i64, 
	scale:         [^]f64, 
) -> i64 ---

    dtrtri ¶
    Source

    dtrtri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    dtrtrs ¶
    Source

    dtrtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
) -> i64 ---

    dtrttf ¶
    Source

    dtrttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	arf:           ^f64, 
) -> i64 ---

    dtrttp ¶
    Source

    dtrttp :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	ap:            [^]f64, 
) -> i64 ---

    dtzrzf ¶
    Source

    dtzrzf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	tau:           [^]f64, 
) -> i64 ---

    get_nancheck ¶
    Source

    get_nancheck :: proc "c" () -> i32 ---

    ilaver ¶
    Source

    ilaver :: proc "c" (vers_major: ^i64, vers_minor: ^i64, vers_patch: ^i64) ---

    lapack_make_complex_double ¶
    Source

    lapack_make_complex_double :: proc "c" (re: f64, im: f64) -> complex128 ---

    lapack_make_complex_float ¶
    Source

    lapack_make_complex_float :: proc "c" (re: f32, im: f32) -> complex64 ---

    sbbcsd ¶
    Source

    sbbcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	theta:         ^f32, 
	phi:           ^f32, 
	u1:            ^f32, 
	ldu1:          i64, 
	u2:            ^f32, 
	ldu2:          i64, 
	v1t:           ^f32, 
	ldv1t:         i64, 
	v2t:           ^f32, 
	ldv2t:         i64, 
	b11d:          ^f32, 
	b11e:          ^f32, 
	b12d:          ^f32, 
	b12e:          ^f32, 
	b21d:          ^f32, 
	b21e:          ^f32, 
	b22d:          ^f32, 
	b22e:          ^f32, 
) -> i64 ---

    sbdsdc ¶
    Source

    sbdsdc :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	compq:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	vt:            [^]f32, 
	ldvt:          i64, 
	q:             [^]f32, 
	iq:            [^]i64, 
) -> i64 ---
     

    C-LAPACK function prototypes

    sbdsqr ¶
    Source

    sbdsqr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ncvt:          i64, 
	nru:           i64, 
	ncc:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vt:            [^]f32, 
	ldvt:          i64, 
	u:             [^]f32, 
	ldu:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sbdsvdx ¶
    Source

    sbdsvdx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	superb:        [^]i64, 
) -> i64 ---

    sdisna ¶
    Source

    sdisna :: proc "c" (job: u8, m: i64, n: i64, d: [^]f32, sep: [^]f32) -> i64 ---

    set_nancheck ¶
    Source

    set_nancheck :: proc "c" (flag: i32) ---
     

    APIs for set/get nancheck flags

    sgbbrd ¶
    Source

    sgbbrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	ncc:           i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	q:             [^]f32, 
	ldq:           i64, 
	pt:            [^]f32, 
	ldpt:          i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sgbcon ¶
    Source

    sgbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    sgbequ ¶
    Source

    sgbequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    sgbequb ¶
    Source

    sgbequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    sgbrfs ¶
    Source

    sgbrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sgbrfsx ¶
    Source

    sgbrfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    sgbsv ¶
    Source

    sgbsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgbsvx ¶
    Source

    sgbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
	rpivot:        ^f32, 
) -> i64 ---

    sgbsvxx ¶
    Source

    sgbsvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    sgbtrf ¶
    Source

    sgbtrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    sgbtrs ¶
    Source

    sgbtrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgebak ¶
    Source

    sgebak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	scale:         [^]f32, 
	m:             i64, 
	v:             [^]f32, 
	ldv:           i64, 
) -> i64 ---

    sgebal ¶
    Source

    sgebal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f32, 
) -> i64 ---

    sgebrd ¶
    Source

    sgebrd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	tauq:          [^]f32, 
	taup:          [^]f32, 
) -> i64 ---

    sgecon ¶
    Source

    sgecon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    sgeequ ¶
    Source

    sgeequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    sgeequb ¶
    Source

    sgeequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	rowcnd:        ^f32, 
	colcnd:        ^f32, 
	amax:          ^f32, 
) -> i64 ---

    sgees ¶
    Source

    sgees :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_S_SELECT2, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	sdim:          ^i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	vs:            [^]f32, 
	ldvs:          i64, 
) -> i64 ---

    sgeesx ¶
    Source

    sgeesx :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_S_SELECT2, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	sdim:          ^i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	vs:            [^]f32, 
	ldvs:          i64, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    sgeev ¶
    Source

    sgeev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
) -> i64 ---

    sgeevx ¶
    Source

    sgeevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f32, 
	abnrm:         ^f32, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    sgehrd ¶
    Source

    sgehrd :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgejsv ¶
    Source

    sgejsv :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	jobr:          u8, 
	jobt:          u8, 
	jobp:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	sva:           ^f32, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	stat:          ^f32, 
	istat:         ^i64, 
) -> i64 ---

    sgelq ¶
    Source

    sgelq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	tsize:         i64, 
) -> i64 ---

    sgelq2 ¶
    Source

    sgelq2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgelqf ¶
    Source

    sgelqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgels ¶
    Source

    sgels :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgelsd ¶
    Source

    sgelsd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	s:             [^]f32, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    sgelss ¶
    Source

    sgelss :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	s:             [^]f32, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    sgelsy ¶
    Source

    sgelsy :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	jpvt:          ^i64, 
	rcond:         f32, 
	rank:          ^i64, 
) -> i64 ---

    sgemlq ¶
    Source

    sgemlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	tsize:         i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sgemqr ¶
    Source

    sgemqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	tsize:         i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sgemqrt ¶
    Source

    sgemqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	nb:            i64, 
	v:             [^]f32, 
	ldv:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---
     

    LAPACK 3.4.0

    sgeqlf ¶
    Source

    sgeqlf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqp3 ¶
    Source

    sgeqp3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqpf ¶
    Source

    sgeqpf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqr ¶
    Source

    sgeqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	tsize:         i64, 
) -> i64 ---

    sgeqr2 ¶
    Source

    sgeqr2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqrf ¶
    Source

    sgeqrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqrfp ¶
    Source

    sgeqrfp :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgeqrt ¶
    Source

    sgeqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    sgeqrt2 ¶
    Source

    sgeqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    sgeqrt3 ¶
    Source

    sgeqrt3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    sgerfs ¶
    Source

    sgerfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sgerfsx ¶
    Source

    sgerfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    sgerqf ¶
    Source

    sgerqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sgesdd ¶
    Source

    sgesdd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	vt:            [^]f32, 
	ldvt:          i64, 
) -> i64 ---

    sgesv ¶
    Source

    sgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgesvd ¶
    Source

    sgesvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	vt:            [^]f32, 
	ldvt:          i64, 
	superb:        [^]f32, 
) -> i64 ---

    sgesvdq ¶
    Source

    sgesvdq :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobp:          u8, 
	jobr:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	numrank:       ^i64, 
) -> i64 ---

    sgesvdx ¶
    Source

    sgesvdx :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	range:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	vt:            [^]f32, 
	ldvt:          i64, 
	superb:        [^]i64, 
) -> i64 ---

    sgesvj ¶
    Source

    sgesvj :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	sva:           ^f32, 
	mv:            i64, 
	v:             [^]f32, 
	ldv:           i64, 
	stat:          ^f32, 
) -> i64 ---

    sgesvx ¶
    Source

    sgesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
	rpivot:        ^f32, 
) -> i64 ---

    sgesvxx ¶
    Source

    sgesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f32, 
	_c:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    sgetf2 ¶
    Source

    sgetf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    sgetrf ¶
    Source

    sgetrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    sgetrf2 ¶
    Source

    sgetrf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    sgetri ¶
    Source

    sgetri :: proc "c" (matrix_layout: i32, n: i64, a: [^]f32, lda: i64, ipiv: [^]i64) -> i64 ---

    sgetrs ¶
    Source

    sgetrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgetsls ¶
    Source

    sgetsls :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgetsqrhrt ¶
    Source

    sgetsqrhrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb1:           i64, 
	nb1:           i64, 
	nb2:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    sggbak ¶
    Source

    sggbak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
	m:             i64, 
	v:             [^]f32, 
	ldv:           i64, 
) -> i64 ---

    sggbal ¶
    Source

    sggbal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
) -> i64 ---

    sgges ¶
    Source

    sgges :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_S_SELECT3, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vsl:           ^f32, 
	ldvsl:         i64, 
	vsr:           ^f32, 
	ldvsr:         i64, 
) -> i64 ---

    sgges3 ¶
    Source

    sgges3 :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_S_SELECT3, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vsl:           ^f32, 
	ldvsl:         i64, 
	vsr:           ^f32, 
	ldvsr:         i64, 
) -> i64 ---

    sggesx ¶
    Source

    sggesx :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_S_SELECT3, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	sdim:          ^i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vsl:           ^f32, 
	ldvsl:         i64, 
	vsr:           ^f32, 
	ldvsr:         i64, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    sggev ¶
    Source

    sggev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
) -> i64 ---

    sggev3 ¶
    Source

    sggev3 :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
) -> i64 ---

    sggevx ¶
    Source

    sggevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f32, 
	rscale:        ^f32, 
	abnrm:         ^f32, 
	bbnrm:         ^f32, 
	rconde:        ^f32, 
	rcondv:        ^f32, 
) -> i64 ---

    sggglm ¶
    Source

    sggglm :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	d:             [^]f32, 
	x:             [^]f32, 
	y:             ^f32, 
) -> i64 ---

    sgghd3 ¶
    Source

    sgghd3 :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sgghrd ¶
    Source

    sgghrd :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sgglse ¶
    Source

    sgglse :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	_c:            [^]f32, 
	d:             [^]f32, 
	x:             [^]f32, 
) -> i64 ---

    sggqrf ¶
    Source

    sggqrf :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	taua:          ^f32, 
	b:             [^]f32, 
	ldb:           i64, 
	taub:          ^f32, 
) -> i64 ---

    sggrqf ¶
    Source

    sggrqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	taua:          ^f32, 
	b:             [^]f32, 
	ldb:           i64, 
	taub:          ^f32, 
) -> i64 ---

    sggsvd ¶
    Source

    sggsvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    sggsvd3 ¶
    Source

    sggsvd3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    sggsvp ¶
    Source

    sggsvp :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
) -> i64 ---

    sggsvp3 ¶
    Source

    sggsvp3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
) -> i64 ---

    sgtcon ¶
    Source

    sgtcon :: proc "c" (
	norm:  u8, 
	n:     i64, 
	dl:    [^]f32, 
	d:     [^]f32, 
	du:    [^]f32, 
	du2:   [^]f32, 
	ipiv:  [^]i64, 
	anorm: f32, 
	rcond: ^f32, 
) -> i64 ---

    sgtrfs ¶
    Source

    sgtrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f32, 
	d:             [^]f32, 
	du:            [^]f32, 
	dlf:           ^f32, 
	df:            [^]f32, 
	duf:           ^f32, 
	du2:           [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sgtsv ¶
    Source

    sgtsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f32, 
	d:             [^]f32, 
	du:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sgtsvx ¶
    Source

    sgtsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f32, 
	d:             [^]f32, 
	du:            [^]f32, 
	dlf:           ^f32, 
	df:            [^]f32, 
	duf:           ^f32, 
	du2:           [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sgttrf ¶
    Source

    sgttrf :: proc "c" (
	n:    i64, 
	dl:   [^]f32, 
	d:    [^]f32, 
	du:   [^]f32, 
	du2:  [^]f32, 
	ipiv: [^]i64, 
) -> i64 ---

    sgttrs ¶
    Source

    sgttrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]f32, 
	d:             [^]f32, 
	du:            [^]f32, 
	du2:           [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    shgeqz ¶
    Source

    shgeqz :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]f32, 
	ldh:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	q:             [^]f32, 
	ldq:           i64, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    shsein ¶
    Source

    shsein :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	eigsrc:        u8, 
	initv:         u8, 
	select:        [^]i64, 
	n:             i64, 
	h:             [^]f32, 
	ldh:           i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
	ifaill:        ^i64, 
	ifailr:        ^i64, 
) -> i64 ---

    shseqr ¶
    Source

    shseqr :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]f32, 
	ldh:           i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    slacn2 ¶
    Source

    slacn2 :: proc "c" (
	n:     i64, 
	v:     [^]f32, 
	x:     [^]f32, 
	isgn:  [^]i64, 
	est:   ^f32, 
	kase:  ^i64, 
	isave: ^i64, 
) -> i64 ---

    slacpy ¶
    Source

    slacpy :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    slag2d ¶
    Source

    slag2d :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	sa:            ^f32, 
	ldsa:          i64, 
	a:             [^]f64, 
	lda:           i64, 
) -> i64 ---

    slagge ¶
    Source

    slagge :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	d:             [^]f32, 
	a:             [^]f32, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    slagsy ¶
    Source

    slagsy :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f32, 
	a:             [^]f32, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    slamch ¶
    Source

    slamch :: proc "c" (cmach: u8) -> f32 ---

    slangb ¶
    Source

    slangb :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
) -> f32 ---

    slange ¶
    Source

    slange :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
) -> f32 ---

    slansy ¶
    Source

    slansy :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
) -> f32 ---

    slantr ¶
    Source

    slantr :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
) -> f32 ---

    slapmr ¶
    Source

    slapmr :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]f32, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    slapmt ¶
    Source

    slapmt :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]f32, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    slapy2 ¶
    Source

    slapy2 :: proc "c" (x: f32, y: f32) -> f32 ---

    slapy3 ¶
    Source

    slapy3 :: proc "c" (x: f32, y: f32, z: f32) -> f32 ---

    slarfb ¶
    Source

    slarfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	v:             [^]f32, 
	ldv:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    slarfg ¶
    Source

    slarfg :: proc "c" (n: i64, alpha: [^]f32, x: [^]f32, incx: i64, tau: [^]f32) -> i64 ---

    slarft ¶
    Source

    slarft :: proc "c" (
	matrix_layout: i32, 
	direct:        u8, 
	storev:        u8, 
	n:             i64, 
	k:             i64, 
	v:             [^]f32, 
	ldv:           i64, 
	tau:           [^]f32, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    slarfx ¶
    Source

    slarfx :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	m:             i64, 
	n:             i64, 
	v:             [^]f32, 
	tau:           f32, 
	_c:            [^]f32, 
	ldc:           i64, 
	work:          [^]f32, 
) -> i64 ---

    slarnv ¶
    Source

    slarnv :: proc "c" (idist: i64, iseed: [^]i64, n: i64, x: [^]f32) -> i64 ---

    slartgp ¶
    Source

    slartgp :: proc "c" (f: f32, g: f32, cs: ^f32, sn: ^f32, r: [^]f32) -> i64 ---

    slartgs ¶
    Source

    slartgs :: proc "c" (x: f32, y: f32, sigma: f32, cs: ^f32, sn: ^f32) -> i64 ---

    slascl ¶
    Source

    slascl :: proc "c" (
	matrix_layout: i32, 
	type:          u8, 
	kl:            i64, 
	ku:            i64, 
	cfrom:         f32, 
	cto:           f32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    slaset ¶
    Source

    slaset :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         f32, 
	beta:          f32, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    slasrt ¶
    Source

    slasrt :: proc "c" (id: u8, n: i64, d: [^]f32) -> i64 ---

    slassq ¶
    Source

    slassq :: proc "c" (n: i64, x: [^]f32, incx: i64, scale: [^]f32, sumsq: ^f32) -> i64 ---

    slaswp ¶
    Source

    slaswp :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	k1:            i64, 
	k2:            i64, 
	ipiv:          [^]i64, 
	incx:          i64, 
) -> i64 ---

    slatms ¶
    Source

    slatms :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	dist:          u8, 
	iseed:         [^]i64, 
	sym:           u8, 
	d:             [^]f32, 
	mode:          i64, 
	cond:          f32, 
	dmax:          f32, 
	kl:            i64, 
	ku:            i64, 
	pack:          u8, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    slauum ¶
    Source

    slauum :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f32, lda: i64) -> i64 ---

    sopgtr ¶
    Source

    sopgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	tau:           [^]f32, 
	q:             [^]f32, 
	ldq:           i64, 
) -> i64 ---

    sopmtr ¶
    Source

    sopmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ap:            [^]f32, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sorbdb ¶
    Source

    sorbdb :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f32, 
	ldx11:         i64, 
	x12:           ^f32, 
	ldx12:         i64, 
	x21:           ^f32, 
	ldx21:         i64, 
	x22:           ^f32, 
	ldx22:         i64, 
	theta:         ^f32, 
	phi:           ^f32, 
	taup1:         ^f32, 
	taup2:         ^f32, 
	tauq1:         ^f32, 
	tauq2:         ^f32, 
) -> i64 ---

    sorcsd ¶
    Source

    sorcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f32, 
	ldx11:         i64, 
	x12:           ^f32, 
	ldx12:         i64, 
	x21:           ^f32, 
	ldx21:         i64, 
	x22:           ^f32, 
	ldx22:         i64, 
	theta:         ^f32, 
	u1:            ^f32, 
	ldu1:          i64, 
	u2:            ^f32, 
	ldu2:          i64, 
	v1t:           ^f32, 
	ldv1t:         i64, 
	v2t:           ^f32, 
	ldv2t:         i64, 
) -> i64 ---

    sorcsd2by1 ¶
    Source

    sorcsd2by1 :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^f32, 
	ldx11:         i64, 
	x21:           ^f32, 
	ldx21:         i64, 
	theta:         ^f32, 
	u1:            ^f32, 
	ldu1:          i64, 
	u2:            ^f32, 
	ldu2:          i64, 
	v1t:           ^f32, 
	ldv1t:         i64, 
) -> i64 ---

    sorgbr ¶
    Source

    sorgbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorghr ¶
    Source

    sorghr :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorglq ¶
    Source

    sorglq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorgql ¶
    Source

    sorgql :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorgqr ¶
    Source

    sorgqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorgrq ¶
    Source

    sorgrq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorgtr ¶
    Source

    sorgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    sorgtsqr_row ¶
    Source

    sorgtsqr_row :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb:            i64, 
	nb:            i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    sorhr_col ¶
    Source

    sorhr_col :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]f32, 
	lda:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	d:             [^]f32, 
) -> i64 ---
     

    LAPACK 3.10.0

    sormbr ¶
    Source

    sormbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormhr ¶
    Source

    sormhr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormlq ¶
    Source

    sormlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormql ¶
    Source

    sormql :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormqr ¶
    Source

    sormqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormrq ¶
    Source

    sormrq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormrz ¶
    Source

    sormrz :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    sormtr ¶
    Source

    sormtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
	_c:            [^]f32, 
	ldc:           i64, 
) -> i64 ---

    spbcon ¶
    Source

    spbcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    spbequ ¶
    Source

    spbequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    spbrfs ¶
    Source

    spbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    spbstf ¶
    Source

    spbstf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kb:            i64, 
	bb:            ^f32, 
	ldbb:          i64, 
) -> i64 ---

    spbsv ¶
    Source

    spbsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    spbsvx ¶
    Source

    spbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	afb:           [^]f32, 
	ldafb:         i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    spbtrf ¶
    Source

    spbtrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
) -> i64 ---

    spbtrs ¶
    Source

    spbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    spftrf ¶
    Source

    spftrf :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]f32) -> i64 ---

    spftri ¶
    Source

    spftri :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]f32) -> i64 ---

    spftrs ¶
    Source

    spftrs :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    spocon ¶
    Source

    spocon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    spoequ ¶
    Source

    spoequ :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    spoequb ¶
    Source

    spoequb :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    sporfs ¶
    Source

    sporfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sporfsx ¶
    Source

    sporfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    sposv ¶
    Source

    sposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sposvx ¶
    Source

    sposvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sposvxx ¶
    Source

    sposvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    spotrf ¶
    Source

    spotrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f32, lda: i64) -> i64 ---

    spotrf2 ¶
    Source

    spotrf2 :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f32, lda: i64) -> i64 ---

    spotri ¶
    Source

    spotri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]f32, lda: i64) -> i64 ---

    spotrs ¶
    Source

    spotrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sppcon ¶
    Source

    sppcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    sppequ ¶
    Source

    sppequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    spprfs ¶
    Source

    spprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	afp:           ^f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sppsv ¶
    Source

    sppsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sppsvx ¶
    Source

    sppsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	afp:           ^f32, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    spptrf ¶
    Source

    spptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f32) -> i64 ---

    spptri ¶
    Source

    spptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f32) -> i64 ---

    spptrs ¶
    Source

    spptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    spstrf ¶
    Source

    spstrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	piv:           ^i64, 
	rank:          ^i64, 
	tol:           f32, 
) -> i64 ---

    sptcon ¶
    Source

    sptcon :: proc "c" (n: i64, d: [^]f32, e: [^]f32, anorm: f32, rcond: ^f32) -> i64 ---

    spteqr ¶
    Source

    spteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sptrfs ¶
    Source

    sptrfs :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	df:            [^]f32, 
	ef:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sptsv ¶
    Source

    sptsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sptsvx ¶
    Source

    sptsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	df:            [^]f32, 
	ef:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    spttrf ¶
    Source

    spttrf :: proc "c" (n: i64, d: [^]f32, e: [^]f32) -> i64 ---

    spttrs ¶
    Source

    spttrs :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssbev ¶
    Source

    ssbev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbev_2stage ¶
    Source

    ssbev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbevd ¶
    Source

    ssbevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbevd_2stage ¶
    Source

    ssbevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbevx ¶
    Source

    ssbevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	q:             [^]f32, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssbevx_2stage ¶
    Source

    ssbevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	q:             [^]f32, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssbgst ¶
    Source

    ssbgst :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	bb:            ^f32, 
	ldbb:          i64, 
	x:             [^]f32, 
	ldx:           i64, 
) -> i64 ---

    ssbgv ¶
    Source

    ssbgv :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	bb:            ^f32, 
	ldbb:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbgvd ¶
    Source

    ssbgvd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	bb:            ^f32, 
	ldbb:          i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssbgvx ¶
    Source

    ssbgvx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	bb:            ^f32, 
	ldbb:          i64, 
	q:             [^]f32, 
	ldq:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssbtrd ¶
    Source

    ssbtrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	q:             [^]f32, 
	ldq:           i64, 
) -> i64 ---

    ssfrk ¶
    Source

    ssfrk :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	trans:         u8, 
	n:             i64, 
	k:             i64, 
	alpha:         f32, 
	a:             [^]f32, 
	lda:           i64, 
	beta:          f32, 
	_c:            [^]f32, 
) -> i64 ---

    sspcon ¶
    Source

    sspcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    sspev ¶
    Source

    sspev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sspevd ¶
    Source

    sspevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sspevx ¶
    Source

    sspevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    sspgst ¶
    Source

    sspgst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	bp:            [^]f32, 
) -> i64 ---

    sspgv ¶
    Source

    sspgv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	bp:            [^]f32, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sspgvd ¶
    Source

    sspgvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	bp:            [^]f32, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sspgvx ¶
    Source

    sspgvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	bp:            [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssprfs ¶
    Source

    ssprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	afp:           ^f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    sspsv ¶
    Source

    sspsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sspsvx ¶
    Source

    sspsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	afp:           ^f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ssptrd ¶
    Source

    ssptrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	d:             [^]f32, 
	e:             [^]f32, 
	tau:           [^]f32, 
) -> i64 ---

    ssptrf ¶
    Source

    ssptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f32, ipiv: [^]i64) -> i64 ---

    ssptri ¶
    Source

    ssptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]f32, ipiv: [^]i64) -> i64 ---

    ssptrs ¶
    Source

    ssptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    sstebz ¶
    Source

    sstebz :: proc "c" (
	range:  u8, 
	order:  u8, 
	n:      i64, 
	vl:     f32, 
	vu:     f32, 
	il:     i64, 
	iu:     i64, 
	abstol: f32, 
	d:      [^]f32, 
	e:      [^]f32, 
	m:      ^i64, 
	nsplit: ^i64, 
	w:      [^]f32, 
	iblock: ^i64, 
	isplit: ^i64, 
) -> i64 ---

    sstedc ¶
    Source

    sstedc :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sstegr ¶
    Source

    sstegr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    sstein ¶
    Source

    sstein :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	m:             i64, 
	w:             [^]f32, 
	iblock:        ^i64, 
	isplit:        ^i64, 
	z:             [^]f32, 
	ldz:           i64, 
	ifailv:        ^i64, 
) -> i64 ---

    sstemr ¶
    Source

    sstemr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	nzc:           i64, 
	isuppz:        [^]i64, 
	tryrac:        ^i64, 
) -> i64 ---

    ssteqr ¶
    Source

    ssteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    ssterf ¶
    Source

    ssterf :: proc "c" (n: i64, d: [^]f32, e: [^]f32) -> i64 ---

    sstev ¶
    Source

    sstev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sstevd ¶
    Source

    sstevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
) -> i64 ---

    sstevr ¶
    Source

    sstevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    sstevx ¶
    Source

    sstevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssycon ¶
    Source

    ssycon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    ssycon_3 ¶
    Source

    ssycon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	e:             [^]f32, 
	ipiv:          [^]i64, 
	anorm:         f32, 
	rcond:         ^f32, 
) -> i64 ---

    ssyconv ¶
    Source

    ssyconv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	way:           u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	e:             [^]f32, 
) -> i64 ---

    ssyequb ¶
    Source

    ssyequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	s:             [^]f32, 
	scond:         ^f32, 
	amax:          ^f32, 
) -> i64 ---

    ssyev ¶
    Source

    ssyev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssyev_2stage ¶
    Source

    ssyev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssyevd ¶
    Source

    ssyevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssyevd_2stage ¶
    Source

    ssyevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssyevr ¶
    Source

    ssyevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    ssyevr_2stage ¶
    Source

    ssyevr_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    ssyevx ¶
    Source

    ssyevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssyevx_2stage ¶
    Source

    ssyevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssygst ¶
    Source

    ssygst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssygv ¶
    Source

    ssygv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssygv_2stage ¶
    Source

    ssygv_2stage :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssygvd ¶
    Source

    ssygvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	w:             [^]f32, 
) -> i64 ---

    ssygvx ¶
    Source

    ssygvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	vl:            f32, 
	vu:            f32, 
	il:            i64, 
	iu:            i64, 
	abstol:        f32, 
	m:             ^i64, 
	w:             [^]f32, 
	z:             [^]f32, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    ssyrfs ¶
    Source

    ssyrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ssyrfsx ¶
    Source

    ssyrfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    ssysv ¶
    Source

    ssysv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssysv_aa ¶
    Source

    ssysv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---
     

    LAPACK 3.7.0

    ssysv_aa_2stage ¶
    Source

    ssysv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	tb:            ^f32, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---
     

    LAPACK 3.8.0

    ssysv_rk ¶
    Source

    ssysv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	e:             [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssysv_rook ¶
    Source

    ssysv_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---
     

    LAPACK 3.X.X

    ssysvx ¶
    Source

    ssysvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    ssysvxx ¶
    Source

    ssysvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	af:            ^f32, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	rcond:         ^f32, 
	rpvgrw:        ^f32, 
	berr:          [^]f32, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f32, 
	err_bnds_comp: [^]f32, 
	nparams:       i64, 
	params:        [^]f32, 
) -> i64 ---

    ssyswapr ¶
    Source

    ssyswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    ssytrd ¶
    Source

    ssytrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	d:             [^]f32, 
	e:             [^]f32, 
	tau:           [^]f32, 
) -> i64 ---

    ssytrf ¶
    Source

    ssytrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytrf_aa ¶
    Source

    ssytrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytrf_aa_2stage ¶
    Source

    ssytrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tb:            ^f32, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    ssytrf_rk ¶
    Source

    ssytrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	e:             [^]f32, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytrf_rook ¶
    Source

    ssytrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytri ¶
    Source

    ssytri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytri2 ¶
    Source

    ssytri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytri2x ¶
    Source

    ssytri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    ssytri_3 ¶
    Source

    ssytri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	e:             [^]f32, 
	ipiv:          [^]i64, 
) -> i64 ---

    ssytrs ¶
    Source

    ssytrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssytrs2 ¶
    Source

    ssytrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssytrs_3 ¶
    Source

    ssytrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	e:             [^]f32, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssytrs_aa ¶
    Source

    ssytrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssytrs_aa_2stage ¶
    Source

    ssytrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	tb:            ^f32, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    ssytrs_rook ¶
    Source

    ssytrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stbcon ¶
    Source

    stbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	rcond:         ^f32, 
) -> i64 ---

    stbrfs ¶
    Source

    stbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    stbtrs ¶
    Source

    stbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]f32, 
	ldab:          i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stfsm ¶
    Source

    stfsm :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         f32, 
	a:             [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stftri ¶
    Source

    stftri :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f32, 
) -> i64 ---

    stfttp ¶
    Source

    stfttp :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^f32, 
	ap:            [^]f32, 
) -> i64 ---

    stfttr ¶
    Source

    stfttr :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^f32, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    stgevc ¶
    Source

    stgevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	s:             [^]f32, 
	lds:           i64, 
	p:             ^f32, 
	ldp:           i64, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    stgexc ¶
    Source

    stgexc :: proc "c" (
	matrix_layout: i32, 
	wantq:         i64, 
	wantz:         i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	z:             [^]f32, 
	ldz:           i64, 
	ifst:          ^i64, 
	ilst:          ^i64, 
) -> i64 ---

    stgsen ¶
    Source

    stgsen :: proc "c" (
	matrix_layout: i32, 
	ijob:          i64, 
	wantq:         i64, 
	wantz:         i64, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	alphar:        ^f32, 
	alphai:        ^f32, 
	beta:          [^]f32, 
	q:             [^]f32, 
	ldq:           i64, 
	z:             [^]f32, 
	ldz:           i64, 
	m:             ^i64, 
	pl:            ^f32, 
	pr:            ^f32, 
	dif:           ^f32, 
) -> i64 ---

    stgsja ¶
    Source

    stgsja :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	tola:          f32, 
	tolb:          f32, 
	alpha:         [^]f32, 
	beta:          [^]f32, 
	u:             [^]f32, 
	ldu:           i64, 
	v:             [^]f32, 
	ldv:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	ncycle:        ^i64, 
) -> i64 ---

    stgsna ¶
    Source

    stgsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	s:             [^]f32, 
	dif:           ^f32, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    stgsyl ¶
    Source

    stgsyl :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	ijob:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
	d:             [^]f32, 
	ldd:           i64, 
	e:             [^]f32, 
	lde:           i64, 
	f:             ^f32, 
	ldf:           i64, 
	scale:         [^]f32, 
	dif:           ^f32, 
) -> i64 ---

    stpcon ¶
    Source

    stpcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	rcond:         ^f32, 
) -> i64 ---

    stpmqrt ¶
    Source

    stpmqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	nb:            i64, 
	v:             [^]f32, 
	ldv:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stpqrt ¶
    Source

    stpqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	nb:            i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    stpqrt2 ¶
    Source

    stpqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
) -> i64 ---

    stprfb ¶
    Source

    stprfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	v:             [^]f32, 
	ldv:           i64, 
	t:             [^]f32, 
	ldt:           i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stprfs ¶
    Source

    stprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    stptri ¶
    Source

    stptri :: proc "c" (matrix_layout: i32, uplo: u8, diag: u8, n: i64, ap: [^]f32) -> i64 ---

    stptrs ¶
    Source

    stptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]f32, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    stpttf ¶
    Source

    stpttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	arf:           ^f32, 
) -> i64 ---

    stpttr ¶
    Source

    stpttr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]f32, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    strcon ¶
    Source

    strcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	rcond:         ^f32, 
) -> i64 ---

    strevc ¶
    Source

    strevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f32, 
	ldt:           i64, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    strexc ¶
    Source

    strexc :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	n:             i64, 
	t:             [^]f32, 
	ldt:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	ifst:          ^i64, 
	ilst:          ^i64, 
) -> i64 ---

    strrfs ¶
    Source

    strrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	x:             [^]f32, 
	ldx:           i64, 
	ferr:          [^]f32, 
	berr:          [^]f32, 
) -> i64 ---

    strsen ¶
    Source

    strsen :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f32, 
	ldt:           i64, 
	q:             [^]f32, 
	ldq:           i64, 
	wr:            [^]f32, 
	wi:            [^]f32, 
	m:             ^i64, 
	s:             [^]f32, 
	sep:           [^]f32, 
) -> i64 ---

    strsna ¶
    Source

    strsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]f32, 
	ldt:           i64, 
	vl:            [^]f32, 
	ldvl:          i64, 
	vr:            [^]f32, 
	ldvr:          i64, 
	s:             [^]f32, 
	sep:           [^]f32, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    strsyl ¶
    Source

    strsyl :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
	scale:         [^]f32, 
) -> i64 ---

    strsyl3 ¶
    Source

    strsyl3 :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
	_c:            [^]f32, 
	ldc:           i64, 
	scale:         [^]f32, 
) -> i64 ---

    strtri ¶
    Source

    strtri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
) -> i64 ---

    strtrs ¶
    Source

    strtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]f32, 
	lda:           i64, 
	b:             [^]f32, 
	ldb:           i64, 
) -> i64 ---

    strttf ¶
    Source

    strttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	arf:           ^f32, 
) -> i64 ---

    strttp ¶
    Source

    strttp :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	ap:            [^]f32, 
) -> i64 ---

    stzrzf ¶
    Source

    stzrzf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f32, 
	lda:           i64, 
	tau:           [^]f32, 
) -> i64 ---

    zbbcsd ¶
    Source

    zbbcsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	theta:         ^f64, 
	phi:           ^f64, 
	u1:            ^complex128, 
	ldu1:          i64, 
	u2:            ^complex128, 
	ldu2:          i64, 
	v1t:           ^complex128, 
	ldv1t:         i64, 
	v2t:           ^complex128, 
	ldv2t:         i64, 
	b11d:          ^f64, 
	b11e:          ^f64, 
	b12d:          ^f64, 
	b12e:          ^f64, 
	b21d:          ^f64, 
	b21e:          ^f64, 
	b22d:          ^f64, 
	b22e:          ^f64, 
) -> i64 ---

    zbdsqr ¶
    Source

    zbdsqr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ncvt:          i64, 
	nru:           i64, 
	ncc:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vt:            [^]complex128, 
	ldvt:          i64, 
	u:             [^]complex128, 
	ldu:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zcgesv ¶
    Source

    zcgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	iter:          ^i64, 
) -> i64 ---

    zcposv ¶
    Source

    zcposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	iter:          ^i64, 
) -> i64 ---

    zgbbrd ¶
    Source

    zgbbrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	ncc:           i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	q:             [^]complex128, 
	ldq:           i64, 
	pt:            [^]complex128, 
	ldpt:          i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zgbcon ¶
    Source

    zgbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zgbequ ¶
    Source

    zgbequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zgbequb ¶
    Source

    zgbequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zgbrfs ¶
    Source

    zgbrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zgbrfsx ¶
    Source

    zgbrfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zgbsv ¶
    Source

    zgbsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgbsvx ¶
    Source

    zgbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
	rpivot:        ^f64, 
) -> i64 ---

    zgbsvxx ¶
    Source

    zgbsvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zgbtrf ¶
    Source

    zgbtrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zgbtrs ¶
    Source

    zgbtrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgebak ¶
    Source

    zgebak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	scale:         [^]f64, 
	m:             i64, 
	v:             [^]complex128, 
	ldv:           i64, 
) -> i64 ---

    zgebal ¶
    Source

    zgebal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f64, 
) -> i64 ---

    zgebrd ¶
    Source

    zgebrd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	tauq:          [^]complex128, 
	taup:          [^]complex128, 
) -> i64 ---

    zgecon ¶
    Source

    zgecon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zgeequ ¶
    Source

    zgeequ :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zgeequb ¶
    Source

    zgeequb :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	rowcnd:        ^f64, 
	colcnd:        ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zgees ¶
    Source

    zgees :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_Z_SELECT1, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	sdim:          ^i64, 
	w:             [^]complex128, 
	vs:            [^]complex128, 
	ldvs:          i64, 
) -> i64 ---

    zgeesx ¶
    Source

    zgeesx :: proc "c" (
	matrix_layout: i32, 
	jobvs:         u8, 
	sort:          u8, 
	select:        LAPACK_Z_SELECT1, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	sdim:          ^i64, 
	w:             [^]complex128, 
	vs:            [^]complex128, 
	ldvs:          i64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    zgeev ¶
    Source

    zgeev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
) -> i64 ---

    zgeevx ¶
    Source

    zgeevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	scale:         [^]f64, 
	abnrm:         ^f64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    zgehrd ¶
    Source

    zgehrd :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgejsv ¶
    Source

    zgejsv :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	jobr:          u8, 
	jobt:          u8, 
	jobp:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	sva:           ^f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	stat:          ^f64, 
	istat:         ^i64, 
) -> i64 ---

    zgelq ¶
    Source

    zgelq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	tsize:         i64, 
) -> i64 ---

    zgelq2 ¶
    Source

    zgelq2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgelqf ¶
    Source

    zgelqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgels ¶
    Source

    zgels :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgelsd ¶
    Source

    zgelsd :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	s:             [^]f64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    zgelss ¶
    Source

    zgelss :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	s:             [^]f64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    zgelsy ¶
    Source

    zgelsy :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	jpvt:          ^i64, 
	rcond:         f64, 
	rank:          ^i64, 
) -> i64 ---

    zgemlq ¶
    Source

    zgemlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	tsize:         i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zgemqr ¶
    Source

    zgemqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	tsize:         i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zgemqrt ¶
    Source

    zgemqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	nb:            i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zgeqlf ¶
    Source

    zgeqlf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqp3 ¶
    Source

    zgeqp3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqpf ¶
    Source

    zgeqpf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	jpvt:          ^i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqr ¶
    Source

    zgeqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	tsize:         i64, 
) -> i64 ---

    zgeqr2 ¶
    Source

    zgeqr2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqrf ¶
    Source

    zgeqrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqrfp ¶
    Source

    zgeqrfp :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgeqrt ¶
    Source

    zgeqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zgeqrt2 ¶
    Source

    zgeqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zgeqrt3 ¶
    Source

    zgeqrt3 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zgerfs ¶
    Source

    zgerfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zgerfsx ¶
    Source

    zgerfsx :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zgerqf ¶
    Source

    zgerqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zgesdd ¶
    Source

    zgesdd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	vt:            [^]complex128, 
	ldvt:          i64, 
) -> i64 ---

    zgesv ¶
    Source

    zgesv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgesvd ¶
    Source

    zgesvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	vt:            [^]complex128, 
	ldvt:          i64, 
	superb:        [^]f64, 
) -> i64 ---

    zgesvdq ¶
    Source

    zgesvdq :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobp:          u8, 
	jobr:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	numrank:       ^i64, 
) -> i64 ---

    zgesvdx ¶
    Source

    zgesvdx :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobvt:         u8, 
	range:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	ns:            ^i64, 
	s:             [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	vt:            [^]complex128, 
	ldvt:          i64, 
	superb:        [^]i64, 
) -> i64 ---

    zgesvj ¶
    Source

    zgesvj :: proc "c" (
	matrix_layout: i32, 
	joba:          u8, 
	jobu:          u8, 
	jobv:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	sva:           ^f64, 
	mv:            i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	stat:          ^f64, 
) -> i64 ---

    zgesvx ¶
    Source

    zgesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
	rpivot:        ^f64, 
) -> i64 ---

    zgesvxx ¶
    Source

    zgesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	r:             [^]f64, 
	_c:            [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zgetf2 ¶
    Source

    zgetf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zgetrf ¶
    Source

    zgetrf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zgetrf2 ¶
    Source

    zgetrf2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zgetri ¶
    Source

    zgetri :: proc "c" (matrix_layout: i32, n: i64, a: [^]complex128, lda: i64, ipiv: [^]i64) -> i64 ---

    zgetrs ¶
    Source

    zgetrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgetsls ¶
    Source

    zgetsls :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgetsqrhrt ¶
    Source

    zgetsqrhrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb1:           i64, 
	nb1:           i64, 
	nb2:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zggbak ¶
    Source

    zggbak :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	side:          u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
	m:             i64, 
	v:             [^]complex128, 
	ldv:           i64, 
) -> i64 ---

    zggbal ¶
    Source

    zggbal :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
) -> i64 ---

    zgges ¶
    Source

    zgges :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_Z_SELECT2, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vsl:           ^complex128, 
	ldvsl:         i64, 
	vsr:           ^complex128, 
	ldvsr:         i64, 
) -> i64 ---

    zgges3 ¶
    Source

    zgges3 :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_Z_SELECT2, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vsl:           ^complex128, 
	ldvsl:         i64, 
	vsr:           ^complex128, 
	ldvsr:         i64, 
) -> i64 ---

    zggesx ¶
    Source

    zggesx :: proc "c" (
	matrix_layout: i32, 
	jobvsl:        u8, 
	jobvsr:        u8, 
	sort:          u8, 
	selctg:        LAPACK_Z_SELECT2, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	sdim:          ^i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vsl:           ^complex128, 
	ldvsl:         i64, 
	vsr:           ^complex128, 
	ldvsr:         i64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    zggev ¶
    Source

    zggev :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
) -> i64 ---

    zggev3 ¶
    Source

    zggev3 :: proc "c" (
	matrix_layout: i32, 
	jobvl:         u8, 
	jobvr:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
) -> i64 ---

    zggevx ¶
    Source

    zggevx :: proc "c" (
	matrix_layout: i32, 
	balanc:        u8, 
	jobvl:         u8, 
	jobvr:         u8, 
	sense:         u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	ilo:           ^i64, 
	ihi:           ^i64, 
	lscale:        ^f64, 
	rscale:        ^f64, 
	abnrm:         ^f64, 
	bbnrm:         ^f64, 
	rconde:        ^f64, 
	rcondv:        ^f64, 
) -> i64 ---

    zggglm ¶
    Source

    zggglm :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	d:             [^]complex128, 
	x:             [^]complex128, 
	y:             ^complex128, 
) -> i64 ---

    zgghd3 ¶
    Source

    zgghd3 :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zgghrd ¶
    Source

    zgghrd :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zgglse ¶
    Source

    zgglse :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	_c:            [^]complex128, 
	d:             [^]complex128, 
	x:             [^]complex128, 
) -> i64 ---

    zggqrf ¶
    Source

    zggqrf :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	m:             i64, 
	p:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	taua:          ^complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	taub:          ^complex128, 
) -> i64 ---

    zggrqf ¶
    Source

    zggrqf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	taua:          ^complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	taub:          ^complex128, 
) -> i64 ---

    zggsvd ¶
    Source

    zggsvd :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    zggsvd3 ¶
    Source

    zggsvd3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	n:             i64, 
	p:             i64, 
	k:             ^i64, 
	l:             ^i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	iwork:         [^]i64, 
) -> i64 ---

    zggsvp ¶
    Source

    zggsvp :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
) -> i64 ---

    zggsvp3 ¶
    Source

    zggsvp3 :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	k:             ^i64, 
	l:             ^i64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
) -> i64 ---

    zgtcon ¶
    Source

    zgtcon :: proc "c" (
	norm:  u8, 
	n:     i64, 
	dl:    [^]complex128, 
	d:     [^]complex128, 
	du:    [^]complex128, 
	du2:   [^]complex128, 
	ipiv:  [^]i64, 
	anorm: f64, 
	rcond: ^f64, 
) -> i64 ---

    zgtrfs ¶
    Source

    zgtrfs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex128, 
	d:             [^]complex128, 
	du:            [^]complex128, 
	dlf:           ^complex128, 
	df:            [^]complex128, 
	duf:           ^complex128, 
	du2:           [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zgtsv ¶
    Source

    zgtsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex128, 
	d:             [^]complex128, 
	du:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zgtsvx ¶
    Source

    zgtsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex128, 
	d:             [^]complex128, 
	du:            [^]complex128, 
	dlf:           ^complex128, 
	df:            [^]complex128, 
	duf:           ^complex128, 
	du2:           [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zgttrf ¶
    Source

    zgttrf :: proc "c" (
	n:    i64, 
	dl:   [^]complex128, 
	d:    [^]complex128, 
	du:   [^]complex128, 
	du2:  [^]complex128, 
	ipiv: [^]i64, 
) -> i64 ---

    zgttrs ¶
    Source

    zgttrs :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	n:             i64, 
	nrhs:          i64, 
	dl:            [^]complex128, 
	d:             [^]complex128, 
	du:            [^]complex128, 
	du2:           [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhbev ¶
    Source

    zhbev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbev_2stage ¶
    Source

    zhbev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbevd ¶
    Source

    zhbevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbevd_2stage ¶
    Source

    zhbevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbevx ¶
    Source

    zhbevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhbevx_2stage ¶
    Source

    zhbevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhbgst ¶
    Source

    zhbgst :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	bb:            ^complex128, 
	ldbb:          i64, 
	x:             [^]complex128, 
	ldx:           i64, 
) -> i64 ---

    zhbgv ¶
    Source

    zhbgv :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	bb:            ^complex128, 
	ldbb:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbgvd ¶
    Source

    zhbgvd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	bb:            ^complex128, 
	ldbb:          i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhbgvx ¶
    Source

    zhbgvx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ka:            i64, 
	kb:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	bb:            ^complex128, 
	ldbb:          i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhbtrd ¶
    Source

    zhbtrd :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	q:             [^]complex128, 
	ldq:           i64, 
) -> i64 ---

    zhecon ¶
    Source

    zhecon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zhecon_3 ¶
    Source

    zhecon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zheequb ¶
    Source

    zheequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zheev ¶
    Source

    zheev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zheev_2stage ¶
    Source

    zheev_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zheevd ¶
    Source

    zheevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zheevd_2stage ¶
    Source

    zheevd_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zheevr ¶
    Source

    zheevr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    zheevr_2stage ¶
    Source

    zheevr_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    zheevx ¶
    Source

    zheevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zheevx_2stage ¶
    Source

    zheevx_2stage :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhegst ¶
    Source

    zhegst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhegv ¶
    Source

    zhegv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zhegv_2stage ¶
    Source

    zhegv_2stage :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zhegvd ¶
    Source

    zhegvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	w:             [^]f64, 
) -> i64 ---

    zhegvx ¶
    Source

    zhegvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zherfs ¶
    Source

    zherfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zherfsx ¶
    Source

    zherfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zhesv ¶
    Source

    zhesv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhesv_aa ¶
    Source

    zhesv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhesv_aa_2stage ¶
    Source

    zhesv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhesv_rk ¶
    Source

    zhesv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhesvx ¶
    Source

    zhesvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zhesvxx ¶
    Source

    zhesvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zheswapr ¶
    Source

    zheswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    zhetrd ¶
    Source

    zhetrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	tau:           [^]complex128, 
) -> i64 ---

    zhetrf ¶
    Source

    zhetrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetrf_aa ¶
    Source

    zhetrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetrf_aa_2stage ¶
    Source

    zhetrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    zhetrf_rk ¶
    Source

    zhetrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetrf_rook ¶
    Source

    zhetrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetri ¶
    Source

    zhetri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetri2 ¶
    Source

    zhetri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetri2x ¶
    Source

    zhetri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    zhetri_3 ¶
    Source

    zhetri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
) -> i64 ---

    zhetrs ¶
    Source

    zhetrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhetrs2 ¶
    Source

    zhetrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhetrs_3 ¶
    Source

    zhetrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhetrs_aa ¶
    Source

    zhetrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhetrs_aa_2stage ¶
    Source

    zhetrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhetrs_rook ¶
    Source

    zhetrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhfrk ¶
    Source

    zhfrk :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	trans:         u8, 
	n:             i64, 
	k:             i64, 
	alpha:         f64, 
	a:             [^]complex128, 
	lda:           i64, 
	beta:          f64, 
	_c:            [^]complex128, 
) -> i64 ---

    zhgeqz ¶
    Source

    zhgeqz :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]complex128, 
	ldh:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	q:             [^]complex128, 
	ldq:           i64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhpcon ¶
    Source

    zhpcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zhpev ¶
    Source

    zhpev :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhpevd ¶
    Source

    zhpevd :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhpevx ¶
    Source

    zhpevx :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhpgst ¶
    Source

    zhpgst :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	bp:            [^]complex128, 
) -> i64 ---

    zhpgv ¶
    Source

    zhpgv :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	bp:            [^]complex128, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhpgvd ¶
    Source

    zhpgvd :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	bp:            [^]complex128, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zhpgvx ¶
    Source

    zhpgvx :: proc "c" (
	matrix_layout: i32, 
	itype:         i64, 
	jobz:          u8, 
	range:         u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	bp:            [^]complex128, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifail:         [^]i64, 
) -> i64 ---

    zhprfs ¶
    Source

    zhprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zhpsv ¶
    Source

    zhpsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhpsvx ¶
    Source

    zhpsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zhptrd ¶
    Source

    zhptrd :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	d:             [^]f64, 
	e:             [^]f64, 
	tau:           [^]complex128, 
) -> i64 ---

    zhptrf ¶
    Source

    zhptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128, ipiv: [^]i64) -> i64 ---

    zhptri ¶
    Source

    zhptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128, ipiv: [^]i64) -> i64 ---

    zhptrs ¶
    Source

    zhptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zhsein ¶
    Source

    zhsein :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	eigsrc:        u8, 
	initv:         u8, 
	select:        [^]i64, 
	n:             i64, 
	h:             [^]complex128, 
	ldh:           i64, 
	w:             [^]complex128, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
	ifaill:        ^i64, 
	ifailr:        ^i64, 
) -> i64 ---

    zhseqr ¶
    Source

    zhseqr :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compz:         u8, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	h:             [^]complex128, 
	ldh:           i64, 
	w:             [^]complex128, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zlacgv ¶
    Source

    zlacgv :: proc "c" (n: i64, x: [^]complex128, incx: i64) -> i64 ---

    zlacn2 ¶
    Source

    zlacn2 :: proc "c" (
	n:     i64, 
	v:     [^]complex128, 
	x:     [^]complex128, 
	est:   ^f64, 
	kase:  ^i64, 
	isave: ^i64, 
) -> i64 ---

    zlacp2 ¶
    Source

    zlacp2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zlacpy ¶
    Source

    zlacpy :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zlacrm ¶
    Source

    zlacrm :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]f64, 
	ldb:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zlag2c ¶
    Source

    zlag2c :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	sa:            ^complex64, 
	ldsa:          i64, 
) -> i64 ---

    zlagge ¶
    Source

    zlagge :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	d:             [^]f64, 
	a:             [^]complex128, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    zlaghe ¶
    Source

    zlaghe :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f64, 
	a:             [^]complex128, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    zlagsy ¶
    Source

    zlagsy :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	k:             i64, 
	d:             [^]f64, 
	a:             [^]complex128, 
	lda:           i64, 
	iseed:         [^]i64, 
) -> i64 ---

    zlangb ¶
    Source

    zlangb :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	n:             i64, 
	kl:            i64, 
	ku:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
) -> f64 ---

    zlange ¶
    Source

    zlange :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> f64 ---

    zlanhe ¶
    Source

    zlanhe :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> f64 ---

    zlansy ¶
    Source

    zlansy :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> f64 ---

    zlantr ¶
    Source

    zlantr :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> f64 ---

    zlapmr ¶
    Source

    zlapmr :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    zlapmt ¶
    Source

    zlapmt :: proc "c" (
	matrix_layout: i32, 
	forwrd:        i64, 
	m:             i64, 
	n:             i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	k:             ^i64, 
) -> i64 ---

    zlarcm ¶
    Source

    zlarcm :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]f64, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zlarfb ¶
    Source

    zlarfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zlarfg ¶
    Source

    zlarfg :: proc "c" (n: i64, alpha: [^]complex128, x: [^]complex128, incx: i64, tau: [^]complex128) -> i64 ---

    zlarft ¶
    Source

    zlarft :: proc "c" (
	matrix_layout: i32, 
	direct:        u8, 
	storev:        u8, 
	n:             i64, 
	k:             i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	tau:           [^]complex128, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zlarfx ¶
    Source

    zlarfx :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	m:             i64, 
	n:             i64, 
	v:             [^]complex128, 
	tau:           complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
	work:          [^]complex128, 
) -> i64 ---

    zlarnv ¶
    Source

    zlarnv :: proc "c" (idist: i64, iseed: [^]i64, n: i64, x: [^]complex128) -> i64 ---

    zlascl ¶
    Source

    zlascl :: proc "c" (
	matrix_layout: i32, 
	type:          u8, 
	kl:            i64, 
	ku:            i64, 
	cfrom:         f64, 
	cto:           f64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    zlaset ¶
    Source

    zlaset :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         complex128, 
	beta:          complex128, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    zlassq ¶
    Source

    zlassq :: proc "c" (n: i64, x: [^]complex128, incx: i64, scale: [^]f64, sumsq: ^f64) -> i64 ---

    zlaswp ¶
    Source

    zlaswp :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	k1:            i64, 
	k2:            i64, 
	ipiv:          [^]i64, 
	incx:          i64, 
) -> i64 ---

    zlatms ¶
    Source

    zlatms :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	dist:          u8, 
	iseed:         [^]i64, 
	sym:           u8, 
	d:             [^]f64, 
	mode:          i64, 
	cond:          f64, 
	dmax:          f64, 
	kl:            i64, 
	ku:            i64, 
	pack:          u8, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    zlauum ¶
    Source

    zlauum :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex128, lda: i64) -> i64 ---

    zpbcon ¶
    Source

    zpbcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zpbequ ¶
    Source

    zpbequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zpbrfs ¶
    Source

    zpbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zpbstf ¶
    Source

    zpbstf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kb:            i64, 
	bb:            ^complex128, 
	ldbb:          i64, 
) -> i64 ---

    zpbsv ¶
    Source

    zpbsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zpbsvx ¶
    Source

    zpbsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	afb:           [^]complex128, 
	ldafb:         i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zpbtrf ¶
    Source

    zpbtrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
) -> i64 ---

    zpbtrs ¶
    Source

    zpbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zpftrf ¶
    Source

    zpftrf :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]complex128) -> i64 ---

    zpftri ¶
    Source

    zpftri :: proc "c" (matrix_layout: i32, transr: u8, uplo: u8, n: i64, a: [^]complex128) -> i64 ---

    zpftrs ¶
    Source

    zpftrs :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zpocon ¶
    Source

    zpocon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zpoequ ¶
    Source

    zpoequ :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zpoequb ¶
    Source

    zpoequb :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zporfs ¶
    Source

    zporfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zporfsx ¶
    Source

    zporfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zposv ¶
    Source

    zposv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zposvx ¶
    Source

    zposvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zposvxx ¶
    Source

    zposvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zpotrf ¶
    Source

    zpotrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex128, lda: i64) -> i64 ---

    zpotrf2 ¶
    Source

    zpotrf2 :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex128, lda: i64) -> i64 ---

    zpotri ¶
    Source

    zpotri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, a: [^]complex128, lda: i64) -> i64 ---

    zpotrs ¶
    Source

    zpotrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zppcon ¶
    Source

    zppcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zppequ ¶
    Source

    zppequ :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zpprfs ¶
    Source

    zpprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zppsv ¶
    Source

    zppsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zppsvx ¶
    Source

    zppsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zpptrf ¶
    Source

    zpptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128) -> i64 ---

    zpptri ¶
    Source

    zpptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128) -> i64 ---

    zpptrs ¶
    Source

    zpptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zpstrf ¶
    Source

    zpstrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	piv:           ^i64, 
	rank:          ^i64, 
	tol:           f64, 
) -> i64 ---

    zptcon ¶
    Source

    zptcon :: proc "c" (n: i64, d: [^]f64, e: [^]complex128, anorm: f64, rcond: ^f64) -> i64 ---

    zpteqr ¶
    Source

    zpteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zptrfs ¶
    Source

    zptrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]complex128, 
	df:            [^]f64, 
	ef:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zptsv ¶
    Source

    zptsv :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zptsvx ¶
    Source

    zptsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]complex128, 
	df:            [^]f64, 
	ef:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zpttrf ¶
    Source

    zpttrf :: proc "c" (n: i64, d: [^]f64, e: [^]complex128) -> i64 ---

    zpttrs ¶
    Source

    zpttrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	d:             [^]f64, 
	e:             [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zspcon ¶
    Source

    zspcon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zsprfs ¶
    Source

    zsprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zspsv ¶
    Source

    zspsv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zspsvx ¶
    Source

    zspsvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	afp:           ^complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zsptrf ¶
    Source

    zsptrf :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128, ipiv: [^]i64) -> i64 ---

    zsptri ¶
    Source

    zsptri :: proc "c" (matrix_layout: i32, uplo: u8, n: i64, ap: [^]complex128, ipiv: [^]i64) -> i64 ---

    zsptrs ¶
    Source

    zsptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zstedc ¶
    Source

    zstedc :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zstegr ¶
    Source

    zstegr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	abstol:        f64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	isuppz:        [^]i64, 
) -> i64 ---

    zstein ¶
    Source

    zstein :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	m:             i64, 
	w:             [^]f64, 
	iblock:        ^i64, 
	isplit:        ^i64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifailv:        ^i64, 
) -> i64 ---

    zstemr ¶
    Source

    zstemr :: proc "c" (
	matrix_layout: i32, 
	jobz:          u8, 
	range:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	vl:            f64, 
	vu:            f64, 
	il:            i64, 
	iu:            i64, 
	m:             ^i64, 
	w:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
	nzc:           i64, 
	isuppz:        [^]i64, 
	tryrac:        ^i64, 
) -> i64 ---

    zsteqr ¶
    Source

    zsteqr :: proc "c" (
	matrix_layout: i32, 
	compz:         u8, 
	n:             i64, 
	d:             [^]f64, 
	e:             [^]f64, 
	z:             [^]complex128, 
	ldz:           i64, 
) -> i64 ---

    zsycon ¶
    Source

    zsycon :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zsycon_3 ¶
    Source

    zsycon_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	anorm:         f64, 
	rcond:         ^f64, 
) -> i64 ---

    zsyconv ¶
    Source

    zsyconv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	way:           u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	e:             [^]complex128, 
) -> i64 ---

    zsyequb ¶
    Source

    zsyequb :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	s:             [^]f64, 
	scond:         ^f64, 
	amax:          ^f64, 
) -> i64 ---

    zsyr ¶
    Source

    zsyr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	alpha:         complex128, 
	x:             [^]complex128, 
	incx:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    zsyrfs ¶
    Source

    zsyrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zsyrfsx ¶
    Source

    zsyrfsx :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	equed:         u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zsysv ¶
    Source

    zsysv :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsysv_aa ¶
    Source

    zsysv_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsysv_aa_2stage ¶
    Source

    zsysv_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsysv_rk ¶
    Source

    zsysv_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsysv_rook ¶
    Source

    zsysv_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsysvx ¶
    Source

    zsysvx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    zsysvxx ¶
    Source

    zsysvxx :: proc "c" (
	matrix_layout: i32, 
	fact:          u8, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	af:            ^complex128, 
	ldaf:          i64, 
	ipiv:          [^]i64, 
	equed:         cstring, 
	s:             [^]f64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	rcond:         ^f64, 
	rpvgrw:        ^f64, 
	berr:          [^]f64, 
	n_err_bnds:    i64, 
	err_bnds_norm: [^]f64, 
	err_bnds_comp: [^]f64, 
	nparams:       i64, 
	params:        [^]f64, 
) -> i64 ---

    zsyswapr ¶
    Source

    zsyswapr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	i1:            i64, 
	i2:            i64, 
) -> i64 ---

    zsytrf ¶
    Source

    zsytrf :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytrf_aa ¶
    Source

    zsytrf_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytrf_aa_2stage ¶
    Source

    zsytrf_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
) -> i64 ---

    zsytrf_rk ¶
    Source

    zsytrf_rk :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytrf_rook ¶
    Source

    zsytrf_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytri ¶
    Source

    zsytri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytri2 ¶
    Source

    zsytri2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytri2x ¶
    Source

    zsytri2x :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	nb:            i64, 
) -> i64 ---

    zsytri_3 ¶
    Source

    zsytri_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
) -> i64 ---

    zsytrs ¶
    Source

    zsytrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsytrs2 ¶
    Source

    zsytrs2 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsytrs_3 ¶
    Source

    zsytrs_3 :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	e:             [^]complex128, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsytrs_aa ¶
    Source

    zsytrs_aa :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsytrs_aa_2stage ¶
    Source

    zsytrs_aa_2stage :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tb:            ^complex128, 
	ltb:           i64, 
	ipiv:          [^]i64, 
	ipiv2:         ^i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    zsytrs_rook ¶
    Source

    zsytrs_rook :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ipiv:          [^]i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztbcon ¶
    Source

    ztbcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	rcond:         ^f64, 
) -> i64 ---

    ztbrfs ¶
    Source

    ztbrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    ztbtrs ¶
    Source

    ztbtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	kd:            i64, 
	nrhs:          i64, 
	ab:            [^]complex128, 
	ldab:          i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztfsm ¶
    Source

    ztfsm :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	m:             i64, 
	n:             i64, 
	alpha:         complex128, 
	a:             [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztftri ¶
    Source

    ztftri :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex128, 
) -> i64 ---

    ztfttp ¶
    Source

    ztfttp :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^complex128, 
	ap:            [^]complex128, 
) -> i64 ---

    ztfttr ¶
    Source

    ztfttr :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	arf:           ^complex128, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    ztgevc ¶
    Source

    ztgevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	s:             [^]complex128, 
	lds:           i64, 
	p:             ^complex128, 
	ldp:           i64, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ztgexc ¶
    Source

    ztgexc :: proc "c" (
	matrix_layout: i32, 
	wantq:         i64, 
	wantz:         i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	z:             [^]complex128, 
	ldz:           i64, 
	ifst:          i64, 
	ilst:          i64, 
) -> i64 ---

    ztgsen ¶
    Source

    ztgsen :: proc "c" (
	matrix_layout: i32, 
	ijob:          i64, 
	wantq:         i64, 
	wantz:         i64, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	alpha:         [^]complex128, 
	beta:          [^]complex128, 
	q:             [^]complex128, 
	ldq:           i64, 
	z:             [^]complex128, 
	ldz:           i64, 
	m:             ^i64, 
	pl:            ^f64, 
	pr:            ^f64, 
	dif:           ^f64, 
) -> i64 ---

    ztgsja ¶
    Source

    ztgsja :: proc "c" (
	matrix_layout: i32, 
	jobu:          u8, 
	jobv:          u8, 
	jobq:          u8, 
	m:             i64, 
	p:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	tola:          f64, 
	tolb:          f64, 
	alpha:         [^]f64, 
	beta:          [^]f64, 
	u:             [^]complex128, 
	ldu:           i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	ncycle:        ^i64, 
) -> i64 ---

    ztgsna ¶
    Source

    ztgsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	s:             [^]f64, 
	dif:           ^f64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ztgsyl ¶
    Source

    ztgsyl :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	ijob:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
	d:             [^]complex128, 
	ldd:           i64, 
	e:             [^]complex128, 
	lde:           i64, 
	f:             ^complex128, 
	ldf:           i64, 
	scale:         [^]f64, 
	dif:           ^f64, 
) -> i64 ---

    ztpcon ¶
    Source

    ztpcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	rcond:         ^f64, 
) -> i64 ---

    ztpmqrt ¶
    Source

    ztpmqrt :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	nb:            i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztpqrt ¶
    Source

    ztpqrt :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	nb:            i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    ztpqrt2 ¶
    Source

    ztpqrt2 :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	l:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    ztprfb ¶
    Source

    ztprfb :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	direct:        u8, 
	storev:        u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	v:             [^]complex128, 
	ldv:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztprfs ¶
    Source

    ztprfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    ztptri ¶
    Source

    ztptri :: proc "c" (matrix_layout: i32, uplo: u8, diag: u8, n: i64, ap: [^]complex128) -> i64 ---

    ztptrs ¶
    Source

    ztptrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	ap:            [^]complex128, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztpttf ¶
    Source

    ztpttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	arf:           ^complex128, 
) -> i64 ---

    ztpttr ¶
    Source

    ztpttr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    ztrcon ¶
    Source

    ztrcon :: proc "c" (
	matrix_layout: i32, 
	norm:          u8, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	rcond:         ^f64, 
) -> i64 ---

    ztrevc ¶
    Source

    ztrevc :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ztrexc ¶
    Source

    ztrexc :: proc "c" (
	matrix_layout: i32, 
	compq:         u8, 
	n:             i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	ifst:          i64, 
	ilst:          i64, 
) -> i64 ---

    ztrrfs ¶
    Source

    ztrrfs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	x:             [^]complex128, 
	ldx:           i64, 
	ferr:          [^]f64, 
	berr:          [^]f64, 
) -> i64 ---

    ztrsen ¶
    Source

    ztrsen :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	compq:         u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	q:             [^]complex128, 
	ldq:           i64, 
	w:             [^]complex128, 
	m:             ^i64, 
	s:             [^]f64, 
	sep:           [^]f64, 
) -> i64 ---

    ztrsna ¶
    Source

    ztrsna :: proc "c" (
	matrix_layout: i32, 
	job:           u8, 
	howmny:        u8, 
	select:        [^]i64, 
	n:             i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	vl:            [^]complex128, 
	ldvl:          i64, 
	vr:            [^]complex128, 
	ldvr:          i64, 
	s:             [^]f64, 
	sep:           [^]f64, 
	mm:            i64, 
	m:             ^i64, 
) -> i64 ---

    ztrsyl ¶
    Source

    ztrsyl :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
	scale:         [^]f64, 
) -> i64 ---

    ztrsyl3 ¶
    Source

    ztrsyl3 :: proc "c" (
	matrix_layout: i32, 
	trana:         u8, 
	tranb:         u8, 
	isgn:          i64, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
	_c:            [^]complex128, 
	ldc:           i64, 
	scale:         [^]f64, 
) -> i64 ---

    ztrtri ¶
    Source

    ztrtri :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	diag:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
) -> i64 ---

    ztrtrs ¶
    Source

    ztrtrs :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	trans:         u8, 
	diag:          u8, 
	n:             i64, 
	nrhs:          i64, 
	a:             [^]complex128, 
	lda:           i64, 
	b:             [^]complex128, 
	ldb:           i64, 
) -> i64 ---

    ztrttf ¶
    Source

    ztrttf :: proc "c" (
	matrix_layout: i32, 
	transr:        u8, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	arf:           ^complex128, 
) -> i64 ---

    ztrttp ¶
    Source

    ztrttp :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	ap:            [^]complex128, 
) -> i64 ---

    ztzrzf ¶
    Source

    ztzrzf :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zunbdb ¶
    Source

    zunbdb :: proc "c" (
	matrix_layout: i32, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex128, 
	ldx11:         i64, 
	x12:           ^complex128, 
	ldx12:         i64, 
	x21:           ^complex128, 
	ldx21:         i64, 
	x22:           ^complex128, 
	ldx22:         i64, 
	theta:         ^f64, 
	phi:           ^f64, 
	taup1:         ^complex128, 
	taup2:         ^complex128, 
	tauq1:         ^complex128, 
	tauq2:         ^complex128, 
) -> i64 ---

    zuncsd ¶
    Source

    zuncsd :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	jobv2t:        u8, 
	trans:         u8, 
	signs:         u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex128, 
	ldx11:         i64, 
	x12:           ^complex128, 
	ldx12:         i64, 
	x21:           ^complex128, 
	ldx21:         i64, 
	x22:           ^complex128, 
	ldx22:         i64, 
	theta:         ^f64, 
	u1:            ^complex128, 
	ldu1:          i64, 
	u2:            ^complex128, 
	ldu2:          i64, 
	v1t:           ^complex128, 
	ldv1t:         i64, 
	v2t:           ^complex128, 
	ldv2t:         i64, 
) -> i64 ---

    zuncsd2by1 ¶
    Source

    zuncsd2by1 :: proc "c" (
	matrix_layout: i32, 
	jobu1:         u8, 
	jobu2:         u8, 
	jobv1t:        u8, 
	m:             i64, 
	p:             i64, 
	q:             i64, 
	x11:           ^complex128, 
	ldx11:         i64, 
	x21:           ^complex128, 
	ldx21:         i64, 
	theta:         ^f64, 
	u1:            ^complex128, 
	ldu1:          i64, 
	u2:            ^complex128, 
	ldu2:          i64, 
	v1t:           ^complex128, 
	ldv1t:         i64, 
) -> i64 ---

    zungbr ¶
    Source

    zungbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zunghr ¶
    Source

    zunghr :: proc "c" (
	matrix_layout: i32, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zunglq ¶
    Source

    zunglq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zungql ¶
    Source

    zungql :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zungqr ¶
    Source

    zungqr :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zungrq ¶
    Source

    zungrq :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zungtr ¶
    Source

    zungtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
) -> i64 ---

    zungtsqr_row ¶
    Source

    zungtsqr_row :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	mb:            i64, 
	nb:            i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
) -> i64 ---

    zunhr_col ¶
    Source

    zunhr_col :: proc "c" (
	matrix_layout: i32, 
	m:             i64, 
	n:             i64, 
	nb:            i64, 
	a:             [^]complex128, 
	lda:           i64, 
	t:             [^]complex128, 
	ldt:           i64, 
	d:             [^]complex128, 
) -> i64 ---

    zunmbr ¶
    Source

    zunmbr :: proc "c" (
	matrix_layout: i32, 
	vect:          u8, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmhr ¶
    Source

    zunmhr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ilo:           i64, 
	ihi:           i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmlq ¶
    Source

    zunmlq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmql ¶
    Source

    zunmql :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmqr ¶
    Source

    zunmqr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmrq ¶
    Source

    zunmrq :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmrz ¶
    Source

    zunmrz :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	k:             i64, 
	l:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zunmtr ¶
    Source

    zunmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	a:             [^]complex128, 
	lda:           i64, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    zupgtr ¶
    Source

    zupgtr :: proc "c" (
	matrix_layout: i32, 
	uplo:          u8, 
	n:             i64, 
	ap:            [^]complex128, 
	tau:           [^]complex128, 
	q:             [^]complex128, 
	ldq:           i64, 
) -> i64 ---

    zupmtr ¶
    Source

    zupmtr :: proc "c" (
	matrix_layout: i32, 
	side:          u8, 
	uplo:          u8, 
	trans:         u8, 
	m:             i64, 
	n:             i64, 
	ap:            [^]complex128, 
	tau:           [^]complex128, 
	_c:            [^]complex128, 
	ldc:           i64, 
) -> i64 ---

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2025-11 (vendor "odin") Linux_amd64 @ 2025-11-15 02:28:15.925608069 +0000 UTC