ggrqf(3)

📦

version 3.12.1 · 9 versions

3.12.1 · arch rolling (latest)
3.12.0 · opensuse-leap 16.0
3.12.1 · ubuntu stonking
3.12.1 · ubuntu questing
3.12.0 · ubuntu noble
3.12.0 · ubuntu noble
3.12.0 · centos-stream 10, fedora 43, fedora 44
3.12.1 · ubuntu resolute
3.12.1 · debian trixie

🎀 ggrqf(3) — Library Functions Manual 🎀

okay bestie, buckle up, because this is the ggrqf page — yes, the whole generalized RQ factor of it — and she is long. Grab a strawberry drink 🍓 and let's go.

✨ NAME ✨

ggrqf — the generalized RQ factor. that's it, that's the name. short, sweet, iconic. 👑

🌸 SYNOPSIS 🌸

💅 Functions

subroutine cggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork,
    info)
    CGGRQF
subroutine dggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork,
    info)
    DGGRQF
subroutine sggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork,
    info)
    SGGRQF
subroutine zggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork,
    info)
    ZGGRQF

four flavors, one vibe — C, D, S, Z, pick your letter, slay. ✨

🦋 Detailed Description 🦋

okay so this section is literally empty on the page. nothing here. we move. 💀

🔥 Function Documentation 🔥

💜 subroutine cggrqf

subroutine cggrqf (integer m, integer p, integer n, complex, dimension( lda,
    * ) a, integer lda, complex, dimension( * ) taua, complex, dimension(
    ldb, * ) b, integer ldb, complex, dimension( * ) taub, complex,
    dimension( * ) work, integer lwork, integer info)

CGGRQF

🫶 Purpose:

!> — yes the comments keep their !>, that's just how she lives, no cap.

so basically CGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B:

A = R*Q,        B = Z*T*Q,

where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of these forms — lowkey the shapes are the whole personality:

if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,
                 N-M  M                           ( R21 ) N
                                                     N

where R12 or R21 is upper triangular. and also:

if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,
                (  0  ) P-N                         P   N-P
                   N

where T11 is upper triangular. ✨

and the flex? in particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of A*inv(B):

A*inv(B) = (R*inv(T))*Z**H

where inv(B) denotes the inverse of the matrix B, and Z**H denotes the conjugate transpose of the matrix Z. it's giving math main character energy, honestly. 👑

🎀 Parameters

M — M is INTEGER, the number of rows of the matrix A. constraint: M >= 0. no negativity allowed.
P — P is INTEGER, the number of rows of the matrix B. constraint: P >= 0.
N — N is INTEGER, the number of columns of the matrices A and B. constraint: N >= 0.
A — A is COMPLEX array, dimension (LDA,N). On entry, it's the M-by-N matrix A. On exit, if M <= N, the upper triangle of the subarray A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R; if M > N, the elements on and above the (M-N)-th subdiagonal contain the M-by-N upper trapezoidal matrix R. the remaining elements, together with the array TAUA, represent the unitary matrix Q as a product of elementary reflectors (see Further Details). 🦋
LDA — LDA is INTEGER, the leading dimension of the array A. constraint: LDA >= max(1,M).
TAUA — TAUA is COMPLEX array, dimension (min(M,N)). the scalar factors of the elementary reflectors which represent the unitary matrix Q (see Further Details).
B — B is COMPLEX array, dimension (LDB,N). On entry, the P-by-N matrix B. On exit, the elements on and above the diagonal of the array contain the min(P,N)-by-N upper trapezoidal matrix T (T is upper triangular if P >= N); the elements below the diagonal, together with the array TAUB, represent the unitary matrix Z as a product of elementary reflectors (see Further Details). 🌈
LDB — LDB is INTEGER, the leading dimension of the array B. constraint: LDB >= max(1,P).
TAUB — TAUB is COMPLEX array, dimension (min(P,N)). the scalar factors of the elementary reflectors which represent the unitary matrix Z (see Further Details).
WORK — WORK is COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. king behavior. 👑
LWORK — LWORK is INTEGER, the dimension of the array WORK. constraint: LWORK >= max(1,N,M,P). for optimum performance, LWORK >= max(N,M,P)*max(NB1,NB2,NB3), where NB1 is the optimal blocksize for the RQ factorization of an M-by-N matrix, NB2 is the optimal blocksize for the QR factorization of a P-by-N matrix, and NB3 is the optimal blocksize for a call of CUNMRQ. and bestie, listen: if LWORK = -1, then a workspace query is assumed — the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. so don't come for her, she's just answering the question you asked. 🙈
INFO — INFO is INTEGER, and it's the vibe check:
- = 0: successful exit ✨
- < 0: if INFO=-i, the i-th argument had an illegal value. 💀

🌸 Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

like, an absolute supergroup of institutions. we stan. 🫶

⭐ Further Details:

!> — more reflective goodness incoming:

the matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(m,n).

each H(i) has the form

H(i) = I - taua * v * v**H

where taua is a complex scalar, and v is a complex vector with v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in A(m-k+i,1:n-k+i-1), and taua in TAUA(i). to form Q explicitly, use LAPACK subroutine CUNGRQ. to use Q to update another matrix, use LAPACK subroutine CUNMRQ.

the matrix Z is represented as a product of elementary reflectors

Z = H(1) H(2) . . . H(k), where k = min(p,n).

each H(i) has the form

H(i) = I - taub * v * v**H

where taub is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i), and taub in TAUB(i). to form Z explicitly, use LAPACK subroutine CUNGQR. to use Z to update another matrix, use LAPACK subroutine CUNMQR.

Definition at line 212 of file cggrqf.f. 📍

🧚 subroutine dggrqf

subroutine dggrqf (integer m, integer p, integer n, double precision,
    dimension( lda, * ) a, integer lda, double precision, dimension( * )
    taua, double precision, dimension( ldb, * ) b, integer ldb, double
    precision, dimension( * ) taub, double precision, dimension( * ) work,
    integer lwork, integer info)

DGGRQF

🫶 Purpose:

!> — same !> energy, different letter, we love consistency.

so DGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B:

A = R*Q,        B = Z*T*Q,

where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms:

if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,
                 N-M  M                           ( R21 ) N
                                                     N

where R12 or R21 is upper triangular, and

if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,
                (  0  ) P-N                         P   N-P
                   N

where T11 is upper triangular.

in particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of A*inv(B):

A*inv(B) = (R*inv(T))*Z**T

where inv(B) denotes the inverse of the matrix B, and Z**T denotes the transpose of the matrix Z. (note: Z**T here, not Z**H — the real version is built different, literally.) 🔥

🎀 Parameters

M — M is INTEGER, the number of rows of the matrix A. constraint: M >= 0.
P — P is INTEGER, the number of rows of the matrix B. constraint: P >= 0.
N — N is INTEGER, the number of columns of the matrices A and B. constraint: N >= 0.
A — A is DOUBLE PRECISION array, dimension (LDA,N). On entry, the M-by-N matrix A. On exit, if M <= N, the upper triangle of the subarray A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R; if M > N, the elements on and above the (M-N)-th subdiagonal contain the M-by-N upper trapezoidal matrix R. the remaining elements, together with the array TAUA, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details). 🦋
LDA — LDA is INTEGER, the leading dimension of the array A. constraint: LDA >= max(1,M).
TAUA — TAUA is DOUBLE PRECISION array, dimension (min(M,N)). the scalar factors of the elementary reflectors which represent the orthogonal matrix Q (see Further Details).
B — B is DOUBLE PRECISION array, dimension (LDB,N). On entry, the P-by-N matrix B. On exit, the elements on and above the diagonal of the array contain the min(P,N)-by-N upper trapezoidal matrix T (T is upper triangular if P >= N); the elements below the diagonal, together with the array TAUB, represent the orthogonal matrix Z as a product of elementary reflectors (see Further Details). 🌈
LDB — LDB is INTEGER, the leading dimension of the array B. constraint: LDB >= max(1,P).
TAUB — TAUB is DOUBLE PRECISION array, dimension (min(P,N)). the scalar factors of the elementary reflectors which represent the orthogonal matrix Z (see Further Details).
WORK — WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK

First up, still inside dggrqf's parameter list — we're so back 💅

LWORK — INTEGER. This is the dimension of the array WORK. The minimum is LWORK >= max(1,N,M,P). For optimum performance, you want LWORK >= max(N,M,P)*max(NB1,NB2,NB3), where NB1 is the optimal blocksize for the RQ factorization of an M-by-N matrix, NB2 is the optimal blocksize for the QR factorization of a P-by-N matrix, and NB3 is the optimal blocksize for a call of DORMRQ.

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. Literally a little vibe-check-only mode, no drama 😌

INFO — INTEGER. = 0: successful exit. < 0: if INF0= -i, the i-th argument had an illegal value. Yes bestie, the source spells it INF0 with a zero — we keep it exactly, no cap.

Author 💖

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details 🧚

The matrix Q is represented as a product of elementary reflectors:

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form:

H(i) = I - taua * v * v**T

where taua is a real scalar, and v is a real vector with v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in A(m-k+i,1:n-k+i-1), and taua in TAUA(i).

To form Q explicitly, use LAPACK subroutine DORGRQ. To use Q to update another matrix, use LAPACK subroutine DORMRQ.

The matrix Z is represented as a product of elementary reflectors:

Z = H(1) H(2) . . . H(k), where k = min(p,n).

Each H(i) has the form:

H(i) = I - taub * v * v**T

where taub is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i), and taub in TAUB(i).

To form Z explicitly, use LAPACK subroutine DORGQR. To use Z to update another matrix, use LAPACK subroutine DORMQR.

Definition at line 212 of file dggrqf.f.

✨ `subroutine sggrqf` ✨

subroutine sggrqf (integer m, integer p, integer n, real, dimension( lda, * ) a, integer lda, real, dimension( * ) taua, real, dimension( ldb, * ) b, integer ldb, real, dimension( * ) taub, real, dimension( * ) work, integer lwork, integer info)

SGGRQF is right here, same energy, different letter 🫶

Purpose 💅

SGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B:

A = R*Q,        B = Z*T*Q,

where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms:

if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,
                 N-M  M                           ( R21 ) N
                                                     N

where R12 or R21 is upper triangular, and

if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,
                (  0  ) P-N                         P   N-P
                   N

where T11 is upper triangular.

In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of A*inv(B):

A*inv(B) = (R*inv(T))*Z**T

where inv(B) denotes the inverse of the matrix B, and Z**T denotes the transpose of the matrix Z.

Parameters 🌸

M — INTEGER. The number of rows of the matrix A. M >= 0.
P — INTEGER. The number of rows of the matrix B. P >= 0.
N — INTEGER. The number of columns of the matrices A and B. N >= 0.
A — REAL array, dimension (LDA,N). On entry, the M-by-N matrix A. On exit, if M <= N, the upper triangle of the subarray A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R; if M > N, the elements on and above the (M-N)-th subdiagonal contain the M-by-N upper trapezoidal matrix R; the remaining elements, with the array TAUA, represent the orthogonal matrix Q as a product of elementary reflectors (see Further Details).
LDA — INTEGER. The leading dimension of the array A. LDA >= max(1,M).
TAUA — REAL array, dimension (min(M,N)). The scalar factors of the elementary reflectors which represent the orthogonal matrix Q (see Further Details).
B — REAL array, dimension (LDB,N). On entry, the P-by-N matrix B. On exit, the elements on and above the diagonal of the array contain the min(P,N)-by-N upper trapezoidal matrix T (T is upper triangular if P >= N); the elements below the diagonal, with the array TAUB, represent the orthogonal matrix Z as a product of elementary reflectors (see Further Details).
LDB — INTEGER. The leading dimension of the array B. LDB >= max(1,P).
TAUB — REAL array, dimension (min(P,N)). The scalar factors of the elementary reflectors which represent the orthogonal matrix Z (see Further Details).
WORK — REAL array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — INTEGER. The dimension of the array WORK. LWORK >= max(1,N,M,P). For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3), where NB1 is the optimal blocksize for the RQ factorization of an M-by-N matrix, NB2 is the optimal blocksize for the QR factorization of a P-by-N matrix, and NB3 is the optimal blocksize for a call of SORMRQ.

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. Same iconic query behavior, zero notes 💀

INFO — INTEGER. = 0: successful exit. < 0: if INF0= -i, the i-th argument had an illegal value. Again: INF0, with a zero, we are not touching it 🙈

Author 💖

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Further Details ✨

The matrix Q is represented as a product of elementary reflectors:

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form:

H(i) = I - taua * v * v**T

where taua is a real scalar, and v is a real vector with v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in A(m-k+i,1:n-k+i-1), and taua in TAUA(i).

To form Q explicitly, use LAPACK subroutine SORGRQ. To use Q to update another matrix, use LAPACK subroutine SORMRQ.

The matrix Z is represented as a product of elementary reflectors:

Z = H(1) H(2) . . . H(k), where k = min(p,n).

Each H(i) has the form:

H(i) = I - taub * v * v**T

where taub is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i), and taub in TAUB(i).

To form Z explicitly, use LAPACK subroutine SORGQR. To use Z to update another matrix, use LAPACK subroutine SORMQR.

Definition at line 212 of file sggrqf.f.

🦋 `subroutine zggrqf` 🦋

subroutine zggrqf (integer m, integer p, integer n, complex*16, dimension( lda, * ) a, integer lda, complex*16, dimension( * ) taua, complex*16, dimension( ldb, * ) b, integer ldb, complex*16, dimension( * ) taub, complex*16, dimension( * ) work, integer lwork, integer info)

ZGGRQF has entered the chat, and it's giving complex*16 royalty 👑

Purpose 💜

ZGGRQF computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B:

A = R*Q,        B = Z*T*Q,

where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms:

if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,
                 N-M  M                           ( R21 ) N
                                                     N

where R12 or R21 is upper triangular, and

if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,
                (  0  ) P-N                         P   N-P
                   N

where T11 is upper triangular.

In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of A*inv(B):

A*inv(B) = (R*inv(T))*Z**H

where inv(B) denotes the inverse of the matrix B, and Z**H denotes the conjugate transpose of the matrix Z.

Parameters 🌈

M — INTEGER. The number of rows of the matrix A. M >= 0.
P — INTEGER. The number of rows of the matrix B. P >= 0.
N — INTEGER. The number of columns of the matrices A and B. N >= 0.

🫧 `A` 🫧

okay so A is a COMPLEX*16 array, dimension (LDA,N).

On entry? that's literally the M-by-N matrix A, bestie.

On exit it's giving two different eras depending on your shapes:

if M <= N, the upper triangle of the subarray A(1:M,N-M+1:N) holds the M-by-M upper triangular matrix R ✨
if M > N, the elements on and above the (M-N)-th subdiagonal hold the M-by-N upper trapezoidal matrix R 💅

and the remaining elements, together with the array TAUA, represent the unitary matrix Q as a product of elementary reflectors (peep Further Details for the receipts).

🦋 `LDA` 🦋

LDA is INTEGER — the leading dimension of the array A. and the vibe check is: LDA >= max(1,M). no cap, it's non-negotiable 🙈

🎀 `TAUA` 🎀

TAUA is COMPLEX*16 array, dimension (min(M,N)).

these are the scalar factors of the elementary reflectors that represent the unitary matrix Q (again, Further Details has the lore).

🌸 `B` 🌸

B is COMPLEX*16 array, dimension (LDB,N).

On entry, it's the P-by-N matrix B.

On exit, the elements on and above the diagonal of the array hold the min(P,N)-by-N upper trapezoidal matrix T (and T is upper triangular if P >= N). the elements below the diagonal, chillin' with the array TAUB, represent the unitary matrix Z as a product of elementary reflectors (Further Details, bestie, Further Details).

⭐ `LDB` ⭐

LDB is INTEGER — the leading dimension of the array B, and it must satisfy LDB >= max(1,P). rules are rules 💅

🧚 `TAUB` 🧚

TAUB is COMPLEX*16 array, dimension (min(P,N)).

the scalar factors of the elementary reflectors which represent the unitary matrix Z (Further Details!! it's iconique).

🔥 `WORK` 🔥

WORK is COMPLEX*16 array, dimension (MAX(1,LWORK)).

On exit, if INFO = 0, then WORK(1) returns the optimal LWORK. yes, it reports back. main character behavior.

👑 `LWORK` 👑

LWORK is INTEGER — the dimension of the array WORK.

the bare minimum is LWORK >= max(1,N,M,P).

but for optimum performance, you want

LWORK >= max(N,M,P)*max(NB1,NB2,NB3)

where:

NB1 is the optimal blocksize for the RQ factorization of an M-by-N matrix
NB2 is the optimal blocksize for the QR factorization of a P-by-N matrix
NB3 is the optimal blocksize for a call of ZUNMRQ

⚠️ and if LWORK = -1, then a workspace query is assumed — the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. so like, don't go expecting a complaint, it's literally built different.

💜 `INFO` 💜

INFO is INTEGER, your little status report:

= 0: successful exit 🎉 slay
< 0: if INFO=-i, the i-th argument had an illegal value 💀

🌈 Author 🌈

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

the whole squad really said "we made this" and honestly? respect 🫶

✨ Further Details ✨

okay this is the part where it gets GOOD, strap in 🎀

The matrix Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form

H(i) = I - taua * v * v**H

where taua is a complex scalar, and v is a complex vector with v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in A(m-k+i,1:n-k+i-1), and taua in TAUA(i).

To form Q explicitly, use LAPACK subroutine ZUNGRQ 💖
To use Q to update another matrix, use LAPACK subroutine ZUNMRQ 💖

The matrix Z is represented as a product of elementary reflectors

Z = H(1) H(2) . . . H(k), where k = min(p,n).

Each H(i) has the form

H(i) = I - taub * v * v**H

where taub is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i), and taub in TAUB(i).

To form Z explicitly, use LAPACK subroutine ZUNGQR 💖
To use Z to update another matrix, use LAPACK subroutine ZUNMQR 💖

and one last lil footnote for the completionists: this is defined at line 212 of file zggrqf.f, and this whole author bit was generated automatically by Doxygen for LAPACK from the source code 🌸

okay that's the whole page bestie, you're officially a zggrqf girlie now 💅 this was LAPACK, Version 3.12.0 — the ggrqf(3) girlies stay winning, and yes the date lives in that footer too, go check the source code if you need the exact timestamp 🎀 mwah, study hard, hydrate, and may all your arguments be legal ✨

📦 where this page comes from

arch rolling: lapack-doc 3.12.1-2 · custom
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

ggrqf(3)

🎀 ggrqf(3) — Library Functions Manual 🎀

✨ NAME ✨

🌸 SYNOPSIS 🌸

💅 Functions

🦋 Detailed Description 🦋

🔥 Function Documentation 🔥

💜 subroutine cggrqf

🫶 Purpose:

🎀 Parameters

🌸 Author

⭐ Further Details:

🧚 subroutine dggrqf

🫶 Purpose:

🎀 Parameters

Author 💖

Further Details 🧚

✨ subroutine sggrqf ✨

Purpose 💅

Parameters 🌸

Author 💖

Further Details ✨

🦋 subroutine zggrqf 🦋

Purpose 💜

Parameters 🌈

🫧 A 🫧

🦋 LDA 🦋

🎀 TAUA 🎀

🌸 B 🌸

⭐ LDB ⭐

🧚 TAUB 🧚

🔥 WORK 🔥

👑 LWORK 👑

💜 INFO 💜

🌈 Author 🌈

✨ Further Details ✨

✨ `subroutine sggrqf` ✨

🦋 `subroutine zggrqf` 🦋

🫧 `A` 🫧

🦋 `LDA` 🦋

🎀 `TAUA` 🎀

🌸 `B` 🌸

⭐ `LDB` ⭐

🧚 `TAUB` 🧚

🔥 `WORK` 🔥

👑 `LWORK` 👑

💜 `INFO` 💜