lapack-carray 0.0.2.1 → 0.0.3

raw patch · 6 files changed

+50687/−50683 lines, 6 filesdep ~netlib-carraydep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: netlib-carray, transformers

API changes (from Hackage documentation)

Files

• lapack-carray.cabal +3/−3
• src/Numeric/LAPACK/CArray/ComplexDouble.hs +11955/−11955
• src/Numeric/LAPACK/CArray/ComplexFloat.hs +11850/−11850
• src/Numeric/LAPACK/CArray/Double.hs +13486/−13486
• src/Numeric/LAPACK/CArray/Example.hs +8/−4
• src/Numeric/LAPACK/CArray/Float.hs +13385/−13385

@@ -1,5 +1,5 @@ Name:             lapack-carray-Version:          0.0.2.1+Version:          0.0.3 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -40,7 +40,7 @@ Build-Type:       Simple  Source-Repository this-  Tag:         0.0.2.1+  Tag:         0.0.3   Type:        darcs   Location:    http://hub.darcs.net/thielema/lapack-carray/ @@ -51,7 +51,7 @@ Library   Build-Depends:     lapack-ffi >=0.0 && <0.1,-    netlib-carray >=0.0 && <0.1,+    netlib-carray >=0.1 && <0.2,     netlib-ffi >=0.0 && <0.2,     carray >=0.1.5 && <0.2,     storable-complex >=0.2.2 && <0.3,

@@ -82,11961 +82,11961 @@       ldv1tPtr <- Call.cint ldv1t       v2tPtr <- Call.ioarray v2t       ldv2tPtr <- Call.cint ldv2t-      b11dPtr <- Call.array b11d-      b11ePtr <- Call.array b11e-      b12dPtr <- Call.array b12d-      b12ePtr <- Call.array b12e-      b21dPtr <- Call.array b21d-      b21ePtr <- Call.array b21e-      b22dPtr <- Call.array b22d-      b22ePtr <- Call.array b22e-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      infoPtr <- Call.alloca-      liftIO $ FFI.bbcsd jobu1Ptr jobu2Ptr jobv1tPtr jobv2tPtr transPtr mPtr pPtr qPtr thetaPtr phiPtr u1Ptr ldu1Ptr u2Ptr ldu2Ptr v1tPtr ldv1tPtr v2tPtr ldv2tPtr b11dPtr b11ePtr b12dPtr b12ePtr b21dPtr b21ePtr b22dPtr b22ePtr rworkPtr lrworkPtr infoPtr-      liftIO $ pure (,,,,,,,,)-         <*> pure b11d-         <*> pure b11e-         <*> pure b12d-         <*> pure b12e-         <*> pure b21d-         <*> pure b21e-         <*> pure b22d-         <*> pure b22e-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zbdsqr.f>-bdsqr ::-   Char {- ^ uplo -} ->-   Int {- ^ nru -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vt -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ u -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   IO (Int)-bdsqr uplo nru d e vt u c = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (vtDim0,vtDim1) <- Call.sizes2 <$> getBounds vt-   (uDim0,uDim1) <- Call.sizes2 <$> getBounds u-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let n = dDim0-   let ncvt = vtDim0-   let ldvt = vtDim1-   let ldu = uDim1-   let ncc = cDim0-   let ldc = cDim1-   Call.assert "bdsqr: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "bdsqr: n == uDim0" (n == uDim0)-   rwork <- Call.newArray1 (4*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      ncvtPtr <- Call.cint ncvt-      nruPtr <- Call.cint nru-      nccPtr <- Call.cint ncc-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      vtPtr <- Call.ioarray vt-      ldvtPtr <- Call.cint ldvt-      uPtr <- Call.ioarray u-      lduPtr <- Call.cint ldu-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.bdsqr uploPtr nPtr ncvtPtr nruPtr nccPtr dPtr ePtr vtPtr ldvtPtr uPtr lduPtr cPtr ldcPtr rworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zcgesv.f>-cgesv ::-   Int {- ^ n -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray Int CInt, CArray (Int,Int) (Complex Double), Int, Int)-cgesv n a b ldx = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let _aSize = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   ipiv <- Call.newArray1 n-   x <- Call.newArray2 nrhs ldx-   work <- Call.newArray2 nrhs n-   swork <- Call.newArray1 (n*(n+nrhs))-   rwork <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      workPtr <- Call.array work-      sworkPtr <- Call.array swork-      rworkPtr <- Call.array rwork-      iterPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.cgesv nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr xPtr ldxPtr workPtr sworkPtr rworkPtr iterPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure ipiv-         <*> pure x-         <*> fmap fromIntegral (peek iterPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zcposv.f>-cposv ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Int, Int)-cposv uplo n a b ldx = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let _aSize = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   x <- Call.newArray2 nrhs ldx-   work <- Call.newArray2 nrhs n-   swork <- Call.newArray1 (n*(n+nrhs))-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      workPtr <- Call.array work-      sworkPtr <- Call.array swork-      rworkPtr <- Call.array rwork-      iterPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.cposv uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr xPtr ldxPtr workPtr sworkPtr rworkPtr iterPtr infoPtr-      liftIO $ pure (,,)-         <*> pure x-         <*> fmap fromIntegral (peek iterPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbbrd.f>-gbbrd ::-   Char {- ^ vect -} ->-   Int {- ^ m -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ ldq -} ->-   Int {- ^ ldpt -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   IO (CArray Int Double, CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-gbbrd vect m kl ku ab ldq ldpt c = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let n = abDim0-   let ldab = abDim1-   let ncc = cDim0-   let ldc = cDim1-   d <- Call.newArray1 (minimum[m,n])-   e <- Call.newArray1 (minimum[m,n]-1)-   q <- Call.newArray2 m ldq-   pt <- Call.newArray2 n ldpt-   work <- Call.newArray1 (maximum[m,n])-   rwork <- Call.newArray1 (maximum[m,n])-   evalContT $ do-      vectPtr <- Call.char vect-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nccPtr <- Call.cint ncc-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      dPtr <- Call.array d-      ePtr <- Call.array e-      qPtr <- Call.array q-      ldqPtr <- Call.cint ldq-      ptPtr <- Call.array pt-      ldptPtr <- Call.cint ldpt-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gbbrd vectPtr mPtr nPtr nccPtr klPtr kuPtr abPtr ldabPtr dPtr ePtr qPtr ldqPtr ptPtr ldptPtr cPtr ldcPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure d-         <*> pure e-         <*> pure q-         <*> pure pt-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbcon.f>-gbcon ::-   Char {- ^ norm -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-gbcon norm kl ku ab ipiv anorm = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = abDim0-   let ldab = abDim1-   Call.assert "gbcon: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gbcon normPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr anormPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbequ.f>-gbequ ::-   Int {- ^ m -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)-gbequ m kl ku ab = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   r <- Call.newArray1 m-   c <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.alloca-      colcndPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.gbequ mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure r-         <*> pure c-         <*> peek rowcndPtr-         <*> peek colcndPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbequb.f>-gbequb ::-   Int {- ^ m -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)-gbequb m kl ku ab = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   r <- Call.newArray1 m-   c <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.alloca-      colcndPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.gbequb mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure r-         <*> pure c-         <*> peek rowcndPtr-         <*> peek colcndPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbrfs.f>-gbrfs ::-   Char {- ^ trans -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray (Int,Int) (Complex Double) {- ^ afb -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-gbrfs trans kl ku ab afb ipiv b x = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let (afbDim0,afbDim1) = Call.sizes2 $ bounds afb-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = abDim0-   let ldab = abDim1-   let ldafb = afbDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "gbrfs: n == afbDim0" (n == afbDim0)-   Call.assert "gbrfs: n == ipivDim0" (n == ipivDim0)-   Call.assert "gbrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      afbPtr <- Call.array afb-      ldafbPtr <- Call.cint ldafb-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gbrfs transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbsv.f>-gbsv ::-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (CArray Int CInt, Int)-gbsv kl ku ab b = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   ipiv <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.gbsv nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbsvx.f>-gbsvx ::-   Char {- ^ fact -} ->-   Char {- ^ trans -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ afb -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   Char {- ^ equed -} ->-   IOCArray Int Double {- ^ r -} ->-   IOCArray Int Double {- ^ c -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-gbsvx fact trans kl ku ab afb ipiv equed r c b ldx = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (afbDim0,afbDim1) <- Call.sizes2 <$> getBounds afb-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   rDim0 <- Call.sizes1 <$> getBounds r-   cDim0 <- Call.sizes1 <$> getBounds c-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let ldafb = afbDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gbsvx: n == afbDim0" (n == afbDim0)-   Call.assert "gbsvx: n == ipivDim0" (n == ipivDim0)-   Call.assert "gbsvx: n == rDim0" (n == rDim0)-   Call.assert "gbsvx: n == cDim0" (n == cDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      afbPtr <- Call.ioarray afb-      ldafbPtr <- Call.cint ldafb-      ipivPtr <- Call.ioarray ipiv-      equedPtr <- Call.char equed-      rPtr <- Call.ioarray r-      cPtr <- Call.ioarray c-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gbsvx factPtr transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr ipivPtr equedPtr rPtr cPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap castCCharToChar (peek equedPtr)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtf2.f>-gbtf2 ::-   Int {- ^ m -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (CArray Int CInt, Int)-gbtf2 m kl ku ab = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   ipiv <- Call.newArray1 (minimum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.gbtf2 mPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtrf.f>-gbtrf ::-   Int {- ^ m -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (CArray Int CInt, Int)-gbtrf m kl ku ab = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   ipiv <- Call.newArray1 (minimum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.gbtrf mPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtrs.f>-gbtrs ::-   Char {- ^ trans -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-gbtrs trans kl ku ab ipiv b = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gbtrs: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.gbtrs transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebak.f>-gebak ::-   Char {- ^ job -} ->-   Char {- ^ side -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   CArray Int Double {- ^ scale -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->-   IO (Int)-gebak job side ilo ihi scale v = do-   let scaleDim0 = Call.sizes1 $ bounds scale-   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v-   let n = scaleDim0-   let m = vDim0-   let ldv = vDim1-   evalContT $ do-      jobPtr <- Call.char job-      sidePtr <- Call.char side-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      scalePtr <- Call.array scale-      mPtr <- Call.cint m-      vPtr <- Call.ioarray v-      ldvPtr <- Call.cint ldv-      infoPtr <- Call.alloca-      liftIO $ FFI.gebak jobPtr sidePtr nPtr iloPtr ihiPtr scalePtr mPtr vPtr ldvPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebal.f>-gebal ::-   Char {- ^ job -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int, Int, CArray Int Double, Int)-gebal job a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   scale <- Call.newArray1 n-   evalContT $ do-      jobPtr <- Call.char job-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      iloPtr <- Call.alloca-      ihiPtr <- Call.alloca-      scalePtr <- Call.array scale-      infoPtr <- Call.alloca-      liftIO $ FFI.gebal jobPtr nPtr aPtr ldaPtr iloPtr ihiPtr scalePtr infoPtr-      liftIO $ pure (,,,)-         <*> fmap fromIntegral (peek iloPtr)-         <*> fmap fromIntegral (peek ihiPtr)-         <*> pure scale-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebd2.f>-gebd2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), Int)-gebd2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   d <- Call.newArray1 (minimum[m,n])-   e <- Call.newArray1 (minimum[m,n]-1)-   tauq <- Call.newArray1 (minimum[m,n])-   taup <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauqPtr <- Call.array tauq-      taupPtr <- Call.array taup-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.gebd2 mPtr nPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr workPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure d-         <*> pure e-         <*> pure tauq-         <*> pure taup-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebrd.f>-gebrd ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), Int)-gebrd m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   d <- Call.newArray1 (minimum[m,n])-   e <- Call.newArray1 (minimum[m,n]-1)-   tauq <- Call.newArray1 (minimum[m,n])-   taup <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauqPtr <- Call.array tauq-      taupPtr <- Call.array taup-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gebrd mPtr nPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure d-         <*> pure e-         <*> pure tauq-         <*> pure taup-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgecon.f>-gecon ::-   Char {- ^ norm -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-gecon norm a anorm = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gecon normPtr nPtr aPtr ldaPtr anormPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeequ.f>-geequ ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)-geequ m a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   r <- Call.newArray1 m-   c <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.alloca-      colcndPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.geequ mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure r-         <*> pure c-         <*> peek rowcndPtr-         <*> peek colcndPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeequb.f>-geequb ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)-geequb m a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   r <- Call.newArray1 m-   c <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.alloca-      colcndPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.geequb mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure r-         <*> pure c-         <*> peek rowcndPtr-         <*> peek colcndPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgees.f>-gees ::-   Char {- ^ jobvs -} ->-   Char {- ^ sort -} ->-   FunPtr (Ptr (Complex Double) -> IO Bool) {- ^ select -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldvs -} ->-   Int {- ^ lwork -} ->-   IO (Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), Int)-gees jobvs sort select a ldvs lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   vs <- Call.newArray2 n ldvs-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 n-   bwork <- Call.newArray1 n-   evalContT $ do-      jobvsPtr <- Call.char jobvs-      sortPtr <- Call.char sort-      selectPtr <- pure select-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sdimPtr <- Call.alloca-      wPtr <- Call.array w-      vsPtr <- Call.array vs-      ldvsPtr <- Call.cint ldvs-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      bworkPtr <- Call.array bwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gees jobvsPtr sortPtr selectPtr nPtr aPtr ldaPtr sdimPtr wPtr vsPtr ldvsPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> fmap fromIntegral (peek sdimPtr)-         <*> pure w-         <*> pure vs-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeesx.f>-geesx ::-   Char {- ^ jobvs -} ->-   Char {- ^ sort -} ->-   FunPtr (Ptr (Complex Double) -> IO Bool) {- ^ select -} ->-   Char {- ^ sense -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldvs -} ->-   Int {- ^ lwork -} ->-   IO (Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), Double, Double, Int)-geesx jobvs sort select sense a ldvs lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   vs <- Call.newArray2 n ldvs-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 n-   bwork <- Call.newArray1 n-   evalContT $ do-      jobvsPtr <- Call.char jobvs-      sortPtr <- Call.char sort-      selectPtr <- pure select-      sensePtr <- Call.char sense-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sdimPtr <- Call.alloca-      wPtr <- Call.array w-      vsPtr <- Call.array vs-      ldvsPtr <- Call.cint ldvs-      rcondePtr <- Call.alloca-      rcondvPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      bworkPtr <- Call.array bwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geesx jobvsPtr sortPtr selectPtr sensePtr nPtr aPtr ldaPtr sdimPtr wPtr vsPtr ldvsPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap fromIntegral (peek sdimPtr)-         <*> pure w-         <*> pure vs-         <*> peek rcondePtr-         <*> peek rcondvPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeev.f>-geev ::-   Char {- ^ jobvl -} ->-   Char {- ^ jobvr -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldvl -} ->-   Int {- ^ ldvr -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-geev jobvl jobvr a ldvl ldvr lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   vl <- Call.newArray2 n ldvl-   vr <- Call.newArray2 n ldvr-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      jobvlPtr <- Call.char jobvl-      jobvrPtr <- Call.char jobvr-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      wPtr <- Call.array w-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geev jobvlPtr jobvrPtr nPtr aPtr ldaPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure w-         <*> pure vl-         <*> pure vr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeevx.f>-geevx ::-   Char {- ^ balanc -} ->-   Char {- ^ jobvl -} ->-   Char {- ^ jobvr -} ->-   Char {- ^ sense -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldvl -} ->-   Int {- ^ ldvr -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int, Int, CArray Int Double, Double, CArray Int Double, CArray Int Double, Int)-geevx balanc jobvl jobvr sense a ldvl ldvr lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   vl <- Call.newArray2 n ldvl-   vr <- Call.newArray2 n ldvr-   scale <- Call.newArray1 n-   rconde <- Call.newArray1 n-   rcondv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      balancPtr <- Call.char balanc-      jobvlPtr <- Call.char jobvl-      jobvrPtr <- Call.char jobvr-      sensePtr <- Call.char sense-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      wPtr <- Call.array w-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      iloPtr <- Call.alloca-      ihiPtr <- Call.alloca-      scalePtr <- Call.array scale-      abnrmPtr <- Call.alloca-      rcondePtr <- Call.array rconde-      rcondvPtr <- Call.array rcondv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geevx balancPtr jobvlPtr jobvrPtr sensePtr nPtr aPtr ldaPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr iloPtr ihiPtr scalePtr abnrmPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,,,,,)-         <*> pure w-         <*> pure vl-         <*> pure vr-         <*> fmap fromIntegral (peek iloPtr)-         <*> fmap fromIntegral (peek ihiPtr)-         <*> pure scale-         <*> peek abnrmPtr-         <*> pure rconde-         <*> pure rcondv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgehd2.f>-gehd2 ::-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-gehd2 ilo ihi a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (n-1)-   work <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.gehd2 nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgehrd.f>-gehrd ::-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-gehrd ilo ihi a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (n-1)-   work <- Call.newArray1 lwork-   evalContT $ do-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gehrd nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelq2.f>-gelq2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-gelq2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 m-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.gelq2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelqf.f>-gelqf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-gelqf m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gelqf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgels.f>-gels ::-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (Int)-gels trans m a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gels transPtr mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelsd.f>-gelsd ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Double {- ^ rcond -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, Int, Int)-gelsd m a b rcond lwork lrwork liwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   s <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      sPtr <- Call.array s-      rcondPtr <- Call.double rcond-      rankPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gelsd mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr sPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure s-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelss.f>-gelss ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Double {- ^ rcond -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, Int, Int)-gelss m a b rcond lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   s <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (5*minimum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      sPtr <- Call.array s-      rcondPtr <- Call.double rcond-      rankPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gelss mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr sPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure s-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelsy.f>-gelsy ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray Int CInt {- ^ jpvt -} ->-   Double {- ^ rcond -} ->-   Int {- ^ lwork -} ->-   IO (Int, Int)-gelsy m a b jpvt rcond lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gelsy: n == jpvtDim0" (n == jpvtDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      jpvtPtr <- Call.ioarray jpvt-      rcondPtr <- Call.double rcond-      rankPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gelsy mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr jpvtPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeql2.f>-geql2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-geql2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.geql2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqlf.f>-geqlf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-geqlf m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geqlf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqp3.f>-geqp3 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray Int CInt {- ^ jpvt -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-geqp3 m a jpvt lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt-   let n = aDim0-   let lda = aDim1-   Call.assert "geqp3: n == jpvtDim0" (n == jpvtDim0)-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      jpvtPtr <- Call.ioarray jpvt-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geqp3 mPtr nPtr aPtr ldaPtr jpvtPtr tauPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqr2.f>-geqr2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-geqr2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.geqr2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqr2p.f>-geqr2p ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-geqr2p m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.geqr2p mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqrf.f>-geqrf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-geqrf m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geqrf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqrfp.f>-geqrfp ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-geqrfp m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.geqrfp mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerfs.f>-gerfs ::-   Char {- ^ trans -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ af -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-gerfs trans a af ipiv b x = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (afDim0,afDim1) = Call.sizes2 $ bounds af-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "gerfs: n == afDim0" (n == afDim0)-   Call.assert "gerfs: n == ipivDim0" (n == ipivDim0)-   Call.assert "gerfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.array af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gerfs transPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerq2.f>-gerq2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-gerq2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 m-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.gerq2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerqf.f>-gerqf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-gerqf m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gerqf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesc2.f>-gesc2 ::-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray Int (Complex Double) {- ^ rhs -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray Int CInt {- ^ jpiv -} ->-   IO (Double)-gesc2 a rhs ipiv jpiv = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   rhsDim0 <- Call.sizes1 <$> getBounds rhs-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let jpivDim0 = Call.sizes1 $ bounds jpiv-   let n = aDim0-   let lda = aDim1-   let _rhsSize = rhsDim0-   Call.assert "gesc2: n == ipivDim0" (n == ipivDim0)-   Call.assert "gesc2: n == jpivDim0" (n == jpivDim0)-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      rhsPtr <- Call.ioarray rhs-      ipivPtr <- Call.array ipiv-      jpivPtr <- Call.array jpiv-      scalePtr <- Call.alloca-      liftIO $ FFI.gesc2 nPtr aPtr ldaPtr rhsPtr ipivPtr jpivPtr scalePtr-      liftIO $ peek scalePtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesdd.f>-gesdd ::-   Char {- ^ jobz -} ->-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ucol -} ->-   Int {- ^ ldu -} ->-   Int {- ^ ldvt -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-gesdd jobz m a ucol ldu ldvt lwork lrwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 (minimum[m,n])-   u <- Call.newArray2 ucol ldu-   vt <- Call.newArray2 n ldvt-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (8*minimum[m,n])-   evalContT $ do-      jobzPtr <- Call.char jobz-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      uPtr <- Call.array u-      lduPtr <- Call.cint ldu-      vtPtr <- Call.array vt-      ldvtPtr <- Call.cint ldvt-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gesdd jobzPtr mPtr nPtr aPtr ldaPtr sPtr uPtr lduPtr vtPtr ldvtPtr workPtr lworkPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> pure u-         <*> pure vt-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesv.f>-gesv ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (CArray Int CInt, Int)-gesv a b = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   ipiv <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.gesv nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesvd.f>-gesvd ::-   Char {- ^ jobu -} ->-   Char {- ^ jobvt -} ->-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ucol -} ->-   Int {- ^ ldu -} ->-   Int {- ^ ldvt -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-gesvd jobu jobvt m a ucol ldu ldvt lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 (minimum[m,n])-   u <- Call.newArray2 ucol ldu-   vt <- Call.newArray2 n ldvt-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (5*minimum[m,n])-   evalContT $ do-      jobuPtr <- Call.char jobu-      jobvtPtr <- Call.char jobvt-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      uPtr <- Call.array u-      lduPtr <- Call.cint ldu-      vtPtr <- Call.array vt-      ldvtPtr <- Call.cint ldvt-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gesvd jobuPtr jobvtPtr mPtr nPtr aPtr ldaPtr sPtr uPtr lduPtr vtPtr ldvtPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> pure u-         <*> pure vt-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesvx.f>-gesvx ::-   Char {- ^ fact -} ->-   Char {- ^ trans -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   Char {- ^ equed -} ->-   IOCArray Int Double {- ^ r -} ->-   IOCArray Int Double {- ^ c -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-gesvx fact trans a af ipiv equed r c b ldx = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   rDim0 <- Call.sizes1 <$> getBounds r-   cDim0 <- Call.sizes1 <$> getBounds c-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gesvx: n == afDim0" (n == afDim0)-   Call.assert "gesvx: n == ipivDim0" (n == ipivDim0)-   Call.assert "gesvx: n == rDim0" (n == rDim0)-   Call.assert "gesvx: n == cDim0" (n == cDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      factPtr <- Call.char fact-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      afPtr <- Call.ioarray af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.ioarray ipiv-      equedPtr <- Call.char equed-      rPtr <- Call.ioarray r-      cPtr <- Call.ioarray c-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gesvx factPtr transPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr equedPtr rPtr cPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap castCCharToChar (peek equedPtr)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetc2.f>-getc2 ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int CInt, CArray Int CInt, Int)-getc2 a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   jpiv <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      jpivPtr <- Call.array jpiv-      infoPtr <- Call.alloca-      liftIO $ FFI.getc2 nPtr aPtr ldaPtr ipivPtr jpivPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ipiv-         <*> pure jpiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetf2.f>-getf2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int CInt, Int)-getf2 m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 (minimum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.getf2 mPtr nPtr aPtr ldaPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetrf.f>-getrf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int CInt, Int)-getrf m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 (minimum[m,n])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.getrf mPtr nPtr aPtr ldaPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetri.f>-getri ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ lwork -} ->-   IO (Int)-getri a ipiv lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "getri: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.getri nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetrs.f>-getrs ::-   Char {- ^ trans -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-getrs trans a ipiv b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "getrs: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.getrs transPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggbak.f>-ggbak ::-   Char {- ^ job -} ->-   Char {- ^ side -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   CArray Int Double {- ^ lscale -} ->-   CArray Int Double {- ^ rscale -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->-   IO (Int)-ggbak job side ilo ihi lscale rscale v = do-   let lscaleDim0 = Call.sizes1 $ bounds lscale-   let rscaleDim0 = Call.sizes1 $ bounds rscale-   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v-   let n = lscaleDim0-   let m = vDim0-   let ldv = vDim1-   Call.assert "ggbak: n == rscaleDim0" (n == rscaleDim0)-   evalContT $ do-      jobPtr <- Call.char job-      sidePtr <- Call.char side-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      lscalePtr <- Call.array lscale-      rscalePtr <- Call.array rscale-      mPtr <- Call.cint m-      vPtr <- Call.ioarray v-      ldvPtr <- Call.cint ldv-      infoPtr <- Call.alloca-      liftIO $ FFI.ggbak jobPtr sidePtr nPtr iloPtr ihiPtr lscalePtr rscalePtr mPtr vPtr ldvPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggbal.f>-ggbal ::-   Char {- ^ job -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (Int, Int, CArray Int Double, CArray Int Double, Int)-ggbal job a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "ggbal: n == bDim0" (n == bDim0)-   lscale <- Call.newArray1 n-   rscale <- Call.newArray1 n-   work <- Call.newArray1 lwork-   evalContT $ do-      jobPtr <- Call.char job-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      iloPtr <- Call.alloca-      ihiPtr <- Call.alloca-      lscalePtr <- Call.array lscale-      rscalePtr <- Call.array rscale-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.ggbal jobPtr nPtr aPtr ldaPtr bPtr ldbPtr iloPtr ihiPtr lscalePtr rscalePtr workPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek iloPtr)-         <*> fmap fromIntegral (peek ihiPtr)-         <*> pure lscale-         <*> pure rscale-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgges.f>-gges ::-   Char {- ^ jobvsl -} ->-   Char {- ^ jobvsr -} ->-   Char {- ^ sort -} ->-   FunPtr (Ptr (Complex Double) -> Ptr (Complex Double) -> IO Bool) {- ^ selctg -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldvsl -} ->-   Int {- ^ ldvsr -} ->-   Int {- ^ lwork -} ->-   IO (Int, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-gges jobvsl jobvsr sort selctg a b ldvsl ldvsr lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "gges: n == bDim0" (n == bDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   vsl <- Call.newArray2 n ldvsl-   vsr <- Call.newArray2 n ldvsr-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (8*n)-   bwork <- Call.newArray1 n-   evalContT $ do-      jobvslPtr <- Call.char jobvsl-      jobvsrPtr <- Call.char jobvsr-      sortPtr <- Call.char sort-      selctgPtr <- pure selctg-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      sdimPtr <- Call.alloca-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      vslPtr <- Call.array vsl-      ldvslPtr <- Call.cint ldvsl-      vsrPtr <- Call.array vsr-      ldvsrPtr <- Call.cint ldvsr-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      bworkPtr <- Call.array bwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gges jobvslPtr jobvsrPtr sortPtr selctgPtr nPtr aPtr ldaPtr bPtr ldbPtr sdimPtr alphaPtr betaPtr vslPtr ldvslPtr vsrPtr ldvsrPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap fromIntegral (peek sdimPtr)-         <*> pure alpha-         <*> pure beta-         <*> pure vsl-         <*> pure vsr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggesx.f>-ggesx ::-   Char {- ^ jobvsl -} ->-   Char {- ^ jobvsr -} ->-   Char {- ^ sort -} ->-   FunPtr (Ptr (Complex Double) -> Ptr (Complex Double) -> IO Bool) {- ^ selctg -} ->-   Char {- ^ sense -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldvsl -} ->-   Int {- ^ ldvsr -} ->-   Int {- ^ lwork -} ->-   Int {- ^ liwork -} ->-   IO (Int, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray Int Double, CArray Int Double, Int)-ggesx jobvsl jobvsr sort selctg sense a b ldvsl ldvsr lwork liwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "ggesx: n == bDim0" (n == bDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   vsl <- Call.newArray2 n ldvsl-   vsr <- Call.newArray2 n ldvsr-   rconde <- Call.newArray1 2-   rcondv <- Call.newArray1 2-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (8*n)-   iwork <- Call.newArray1 (maximum[1,liwork])-   bwork <- Call.newArray1 n-   evalContT $ do-      jobvslPtr <- Call.char jobvsl-      jobvsrPtr <- Call.char jobvsr-      sortPtr <- Call.char sort-      selctgPtr <- pure selctg-      sensePtr <- Call.char sense-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      sdimPtr <- Call.alloca-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      vslPtr <- Call.array vsl-      ldvslPtr <- Call.cint ldvsl-      vsrPtr <- Call.array vsr-      ldvsrPtr <- Call.cint ldvsr-      rcondePtr <- Call.array rconde-      rcondvPtr <- Call.array rcondv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      bworkPtr <- Call.array bwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggesx jobvslPtr jobvsrPtr sortPtr selctgPtr sensePtr nPtr aPtr ldaPtr bPtr ldbPtr sdimPtr alphaPtr betaPtr vslPtr ldvslPtr vsrPtr ldvsrPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr iworkPtr liworkPtr bworkPtr infoPtr-      liftIO $ pure (,,,,,,,)-         <*> fmap fromIntegral (peek sdimPtr)-         <*> pure alpha-         <*> pure beta-         <*> pure vsl-         <*> pure vsr-         <*> pure rconde-         <*> pure rcondv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggev.f>-ggev ::-   Char {- ^ jobvl -} ->-   Char {- ^ jobvr -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldvl -} ->-   Int {- ^ ldvr -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-ggev jobvl jobvr a b ldvl ldvr lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "ggev: n == bDim0" (n == bDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   vl <- Call.newArray2 n ldvl-   vr <- Call.newArray2 n ldvr-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (8*n)-   evalContT $ do-      jobvlPtr <- Call.char jobvl-      jobvrPtr <- Call.char jobvr-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggev jobvlPtr jobvrPtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr vlPtr ldvlPtr vrPtr ldvrPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure alpha-         <*> pure beta-         <*> pure vl-         <*> pure vr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggevx.f>-ggevx ::-   Char {- ^ balanc -} ->-   Char {- ^ jobvl -} ->-   Char {- ^ jobvr -} ->-   Char {- ^ sense -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldvl -} ->-   Int {- ^ ldvr -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int, Int, CArray Int Double, CArray Int Double, Double, Double, CArray Int Double, CArray Int Double, Int)-ggevx balanc jobvl jobvr sense a b ldvl ldvr lwork lrwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "ggevx: n == bDim0" (n == bDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   vl <- Call.newArray2 n ldvl-   vr <- Call.newArray2 n ldvr-   lscale <- Call.newArray1 n-   rscale <- Call.newArray1 n-   rconde <- Call.newArray1 n-   rcondv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 lrwork-   iwork <- Call.newArray1 (n+2)-   bwork <- Call.newArray1 n-   evalContT $ do-      balancPtr <- Call.char balanc-      jobvlPtr <- Call.char jobvl-      jobvrPtr <- Call.char jobvr-      sensePtr <- Call.char sense-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      iloPtr <- Call.alloca-      ihiPtr <- Call.alloca-      lscalePtr <- Call.array lscale-      rscalePtr <- Call.array rscale-      abnrmPtr <- Call.alloca-      bbnrmPtr <- Call.alloca-      rcondePtr <- Call.array rconde-      rcondvPtr <- Call.array rcondv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      bworkPtr <- Call.array bwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggevx balancPtr jobvlPtr jobvrPtr sensePtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr vlPtr ldvlPtr vrPtr ldvrPtr iloPtr ihiPtr lscalePtr rscalePtr abnrmPtr bbnrmPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr iworkPtr bworkPtr infoPtr-      liftIO $ pure (,,,,,,,,,,,,)-         <*> pure alpha-         <*> pure beta-         <*> pure vl-         <*> pure vr-         <*> fmap fromIntegral (peek iloPtr)-         <*> fmap fromIntegral (peek ihiPtr)-         <*> pure lscale-         <*> pure rscale-         <*> peek abnrmPtr-         <*> peek bbnrmPtr-         <*> pure rconde-         <*> pure rcondv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggglm.f>-ggglm ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray Int (Complex Double) {- ^ d -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)-ggglm a b d lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   dDim0 <- Call.sizes1 <$> getBounds d-   let m = aDim0-   let lda = aDim1-   let p = bDim0-   let ldb = bDim1-   let n = dDim0-   x <- Call.newArray1 m-   y <- Call.newArray1 p-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      nPtr <- Call.cint n-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      dPtr <- Call.ioarray d-      xPtr <- Call.array x-      yPtr <- Call.array y-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggglm nPtr mPtr pPtr aPtr ldaPtr bPtr ldbPtr dPtr xPtr yPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure x-         <*> pure y-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgghrd.f>-gghrd ::-   Char {- ^ compq -} ->-   Char {- ^ compz -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   IO (Int)-gghrd compq compz ilo ihi a b q z = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   let ldq = qDim1-   let ldz = zDim1-   Call.assert "gghrd: n == bDim0" (n == bDim0)-   Call.assert "gghrd: n == qDim0" (n == qDim0)-   Call.assert "gghrd: n == zDim0" (n == zDim0)-   evalContT $ do-      compqPtr <- Call.char compq-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      infoPtr <- Call.alloca-      liftIO $ FFI.gghrd compqPtr compzPtr nPtr iloPtr ihiPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgglse.f>-gglse ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray Int (Complex Double) {- ^ c -} ->-   IOCArray Int (Complex Double) {- ^ d -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-gglse a b c d lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   cDim0 <- Call.sizes1 <$> getBounds c-   dDim0 <- Call.sizes1 <$> getBounds d-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   let m = cDim0-   let p = dDim0-   Call.assert "gglse: n == bDim0" (n == bDim0)-   x <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      pPtr <- Call.cint p-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.ioarray c-      dPtr <- Call.ioarray d-      xPtr <- Call.array x-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gglse mPtr nPtr pPtr aPtr ldaPtr bPtr ldbPtr cPtr dPtr xPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure x-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggqrf.f>-ggqrf ::-   Int {- ^ n -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)-ggqrf n a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let m = aDim0-   let lda = aDim1-   let p = bDim0-   let ldb = bDim1-   taua <- Call.newArray1 (minimum[n,m])-   taub <- Call.newArray1 (minimum[n,p])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      nPtr <- Call.cint n-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauaPtr <- Call.array taua-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      taubPtr <- Call.array taub-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggqrf nPtr mPtr pPtr aPtr ldaPtr tauaPtr bPtr ldbPtr taubPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure taua-         <*> pure taub-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggrqf.f>-ggrqf ::-   Int {- ^ m -} ->-   Int {- ^ p -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)-ggrqf m p a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "ggrqf: n == bDim0" (n == bDim0)-   taua <- Call.newArray1 (minimum[m,n])-   taub <- Call.newArray1 (minimum[p,n])-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauaPtr <- Call.array taua-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      taubPtr <- Call.array taub-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ggrqf mPtr pPtr nPtr aPtr ldaPtr tauaPtr bPtr ldbPtr taubPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure taua-         <*> pure taub-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtcon.f>-gtcon ::-   Char {- ^ norm -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   CArray Int (Complex Double) {- ^ du2 -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-gtcon norm dl d du du2 ipiv anorm = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let du2Dim0 = Call.sizes1 $ bounds du2-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = dDim0-   Call.assert "gtcon: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gtcon: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "gtcon: n-2 == du2Dim0" (n-2 == du2Dim0)-   Call.assert "gtcon: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      du2Ptr <- Call.array du2-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.gtcon normPtr nPtr dlPtr dPtr duPtr du2Ptr ipivPtr anormPtr rcondPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtrfs.f>-gtrfs ::-   Char {- ^ trans -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   CArray Int (Complex Double) {- ^ dlf -} ->-   CArray Int (Complex Double) {- ^ df -} ->-   CArray Int (Complex Double) {- ^ duf -} ->-   CArray Int (Complex Double) {- ^ du2 -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-gtrfs trans dl d du dlf df duf du2 ipiv b x = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let dlfDim0 = Call.sizes1 $ bounds dlf-   let dfDim0 = Call.sizes1 $ bounds df-   let dufDim0 = Call.sizes1 $ bounds duf-   let du2Dim0 = Call.sizes1 $ bounds du2-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "gtrfs: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gtrfs: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "gtrfs: n-1 == dlfDim0" (n-1 == dlfDim0)-   Call.assert "gtrfs: n == dfDim0" (n == dfDim0)-   Call.assert "gtrfs: n-1 == dufDim0" (n-1 == dufDim0)-   Call.assert "gtrfs: n-2 == du2Dim0" (n-2 == du2Dim0)-   Call.assert "gtrfs: n == ipivDim0" (n == ipivDim0)-   Call.assert "gtrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      dlfPtr <- Call.array dlf-      dfPtr <- Call.array df-      dufPtr <- Call.array duf-      du2Ptr <- Call.array du2-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gtrfs transPtr nPtr nrhsPtr dlPtr dPtr duPtr dlfPtr dfPtr dufPtr du2Ptr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtsv.f>-gtsv ::-   IOCArray Int (Complex Double) {- ^ dl -} ->-   IOCArray Int (Complex Double) {- ^ d -} ->-   IOCArray Int (Complex Double) {- ^ du -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-gtsv dl d du b = do-   dlDim0 <- Call.sizes1 <$> getBounds dl-   dDim0 <- Call.sizes1 <$> getBounds d-   duDim0 <- Call.sizes1 <$> getBounds du-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gtsv: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gtsv: n-1 == duDim0" (n-1 == duDim0)-   evalContT $ do-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dlPtr <- Call.ioarray dl-      dPtr <- Call.ioarray d-      duPtr <- Call.ioarray du-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.gtsv nPtr nrhsPtr dlPtr dPtr duPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtsvx.f>-gtsvx ::-   Char {- ^ fact -} ->-   Char {- ^ trans -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   IOCArray Int (Complex Double) {- ^ dlf -} ->-   IOCArray Int (Complex Double) {- ^ df -} ->-   IOCArray Int (Complex Double) {- ^ duf -} ->-   IOCArray Int (Complex Double) {- ^ du2 -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-gtsvx fact trans dl d du dlf df duf du2 ipiv b ldx = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   dlfDim0 <- Call.sizes1 <$> getBounds dlf-   dfDim0 <- Call.sizes1 <$> getBounds df-   dufDim0 <- Call.sizes1 <$> getBounds duf-   du2Dim0 <- Call.sizes1 <$> getBounds du2-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gtsvx: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gtsvx: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "gtsvx: n-1 == dlfDim0" (n-1 == dlfDim0)-   Call.assert "gtsvx: n == dfDim0" (n == dfDim0)-   Call.assert "gtsvx: n-1 == dufDim0" (n-1 == dufDim0)-   Call.assert "gtsvx: n-2 == du2Dim0" (n-2 == du2Dim0)-   Call.assert "gtsvx: n == ipivDim0" (n == ipivDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      dlfPtr <- Call.ioarray dlf-      dfPtr <- Call.ioarray df-      dufPtr <- Call.ioarray duf-      du2Ptr <- Call.ioarray du2-      ipivPtr <- Call.ioarray ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.gtsvx factPtr transPtr nPtr nrhsPtr dlPtr dPtr duPtr dlfPtr dfPtr dufPtr du2Ptr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgttrf.f>-gttrf ::-   IOCArray Int (Complex Double) {- ^ dl -} ->-   IOCArray Int (Complex Double) {- ^ d -} ->-   IOCArray Int (Complex Double) {- ^ du -} ->-   IO (CArray Int (Complex Double), CArray Int CInt, Int)-gttrf dl d du = do-   dlDim0 <- Call.sizes1 <$> getBounds dl-   dDim0 <- Call.sizes1 <$> getBounds d-   duDim0 <- Call.sizes1 <$> getBounds du-   let n = dDim0-   Call.assert "gttrf: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gttrf: n-1 == duDim0" (n-1 == duDim0)-   du2 <- Call.newArray1 (n-2)-   ipiv <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      dlPtr <- Call.ioarray dl-      dPtr <- Call.ioarray d-      duPtr <- Call.ioarray du-      du2Ptr <- Call.array du2-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.gttrf nPtr dlPtr dPtr duPtr du2Ptr ipivPtr infoPtr-      liftIO $ pure (,,)-         <*> pure du2-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgttrs.f>-gttrs ::-   Char {- ^ trans -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   CArray Int (Complex Double) {- ^ du2 -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-gttrs trans dl d du du2 ipiv b = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let du2Dim0 = Call.sizes1 $ bounds du2-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gttrs: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gttrs: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "gttrs: n-2 == du2Dim0" (n-2 == du2Dim0)-   Call.assert "gttrs: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      du2Ptr <- Call.array du2-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.gttrs transPtr nPtr nrhsPtr dlPtr dPtr duPtr du2Ptr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtts2.f>-gtts2 ::-   Int {- ^ itrans -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   CArray Int (Complex Double) {- ^ du2 -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO ()-gtts2 itrans dl d du du2 ipiv b = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let du2Dim0 = Call.sizes1 $ bounds du2-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "gtts2: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "gtts2: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "gtts2: n-2 == du2Dim0" (n-2 == du2Dim0)-   Call.assert "gtts2: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      itransPtr <- Call.cint itrans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      du2Ptr <- Call.array du2-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.gtts2 itransPtr nPtr nrhsPtr dlPtr dPtr duPtr du2Ptr ipivPtr bPtr ldbPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbev.f>-hbev ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ ldz -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hbev jobz uplo kd ab ldz = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 n-   rwork <- Call.newArray1 (maximum[1,3*n-2])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hbev jobzPtr uploPtr nPtr kdPtr abPtr ldabPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbevd.f>-hbevd ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ rworkSize -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hbevd jobz uplo kd ab ldz lwork rworkSize lrwork liwork = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hbevd jobzPtr uploPtr nPtr kdPtr abPtr ldabPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbevx.f>-hbevx ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ ldq -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   IO (CArray (Int,Int) (Complex Double), Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-hbevx jobz range uplo kd ab ldq vl vu il iu abstol m ldz = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   q <- Call.newArray2 n ldq-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   work <- Call.newArray1 n-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      qPtr <- Call.array q-      ldqPtr <- Call.cint ldq-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.hbevx jobzPtr rangePtr uploPtr nPtr kdPtr abPtr ldabPtr qPtr ldqPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure q-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgst.f>-hbgst ::-   Char {- ^ vect -} ->-   Char {- ^ uplo -} ->-   Int {- ^ ka -} ->-   Int {- ^ kb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray (Int,Int) (Complex Double) {- ^ bb -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-hbgst vect uplo ka kb ab bb ldx = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let (bbDim0,bbDim1) = Call.sizes2 $ bounds bb-   let n = abDim0-   let ldab = abDim1-   let ldbb = bbDim1-   Call.assert "hbgst: n == bbDim0" (n == bbDim0)-   x <- Call.newArray2 n ldx-   work <- Call.newArray1 n-   rwork <- Call.newArray1 n-   evalContT $ do-      vectPtr <- Call.char vect-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kaPtr <- Call.cint ka-      kbPtr <- Call.cint kb-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      bbPtr <- Call.array bb-      ldbbPtr <- Call.cint ldbb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hbgst vectPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr xPtr ldxPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure x-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgv.f>-hbgv ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ ka -} ->-   Int {- ^ kb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->-   Int {- ^ ldz -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hbgv jobz uplo ka kb ab bb ldz = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb-   let n = abDim0-   let ldab = abDim1-   let ldbb = bbDim1-   Call.assert "hbgv: n == bbDim0" (n == bbDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 n-   rwork <- Call.newArray1 (3*n)-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kaPtr <- Call.cint ka-      kbPtr <- Call.cint kb-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      bbPtr <- Call.ioarray bb-      ldbbPtr <- Call.cint ldbb-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hbgv jobzPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgvd.f>-hbgvd ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ ka -} ->-   Int {- ^ kb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hbgvd jobz uplo ka kb ab bb ldz lwork lrwork liwork = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb-   let n = abDim0-   let ldab = abDim1-   let ldbb = bbDim1-   Call.assert "hbgvd: n == bbDim0" (n == bbDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kaPtr <- Call.cint ka-      kbPtr <- Call.cint kb-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      bbPtr <- Call.ioarray bb-      ldbbPtr <- Call.cint ldbb-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hbgvd jobzPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgvx.f>-hbgvx ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   Int {- ^ ka -} ->-   Int {- ^ kb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->-   Int {- ^ ldq -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ ldz -} ->-   IO (CArray (Int,Int) (Complex Double), Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-hbgvx jobz range uplo ka kb ab bb ldq vl vu il iu abstol ldz = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb-   let n = abDim0-   let ldab = abDim1-   let ldbb = bbDim1-   Call.assert "hbgvx: n == bbDim0" (n == bbDim0)-   q <- Call.newArray2 n ldq-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 n-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kaPtr <- Call.cint ka-      kbPtr <- Call.cint kb-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      bbPtr <- Call.ioarray bb-      ldbbPtr <- Call.cint ldbb-      qPtr <- Call.array q-      ldqPtr <- Call.cint ldq-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.hbgvx jobzPtr rangePtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr qPtr ldqPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure q-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbtrd.f>-hbtrd ::-   Char {- ^ vect -} ->-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IO (CArray Int Double, CArray Int Double, Int)-hbtrd vect uplo kd ab q = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   let n = abDim0-   let ldab = abDim1-   let ldq = qDim1-   Call.assert "hbtrd: n == qDim0" (n == qDim0)-   d <- Call.newArray1 n-   e <- Call.newArray1 (n-1)-   work <- Call.newArray1 n-   evalContT $ do-      vectPtr <- Call.char vect-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      dPtr <- Call.array d-      ePtr <- Call.array e-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hbtrd vectPtr uploPtr nPtr kdPtr abPtr ldabPtr dPtr ePtr qPtr ldqPtr workPtr infoPtr-      liftIO $ pure (,,)-         <*> pure d-         <*> pure e-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhecon.f>-hecon ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-hecon uplo a ipiv anorm = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "hecon: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hecon uploPtr nPtr aPtr ldaPtr ipivPtr anormPtr rcondPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheequb.f>-heequb ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, Double, Double, Int)-heequb uplo a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 n-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.heequb uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr workPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheev.f>-heev ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, Int)-heev jobz uplo a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,3*n-2])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      wPtr <- Call.array w-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.heev jobzPtr uploPtr nPtr aPtr ldaPtr wPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevd.f>-heevd ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   Int {- ^ rworkSize -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, Int)-heevd jobz uplo a lwork rworkSize lrwork liwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      wPtr <- Call.array w-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.heevd jobzPtr uploPtr nPtr aPtr ldaPtr wPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevr.f>-heevr ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-heevr jobz range uplo a vl vu il iu abstol m ldz lwork lrwork liwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   isuppz <- Call.newArray1 (2*maximum[1,m])-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      isuppzPtr <- Call.array isuppz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.heevr jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr isuppzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure isuppz-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevx.f>-heevx ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-heevx jobz range uplo a vl vu il iu abstol m ldz lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.heevx jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegs2.f>-hegs2 ::-   Int {- ^ itype -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-hegs2 itype uplo a b = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "hegs2: n == bDim0" (n == bDim0)-   evalContT $ do-      itypePtr <- Call.cint itype-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.hegs2 itypePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegst.f>-hegst ::-   Int {- ^ itype -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-hegst itype uplo a b = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "hegst: n == bDim0" (n == bDim0)-   evalContT $ do-      itypePtr <- Call.cint itype-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.hegst itypePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegv.f>-hegv ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, Int)-hegv itype jobz uplo a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "hegv: n == bDim0" (n == bDim0)-   w <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,3*n-2])-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      wPtr <- Call.array w-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hegv itypePtr jobzPtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr wPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegvd.f>-hegvd ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, Int)-hegvd itype jobz uplo a b lwork lrwork liwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "hegvd: n == bDim0" (n == bDim0)-   w <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      wPtr <- Call.array w-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hegvd itypePtr jobzPtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr wPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegvx.f>-hegvx ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-hegvx itype jobz range uplo a b vl vu il iu abstol m ldz lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "hegvx: n == bDim0" (n == bDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.hegvx itypePtr jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zherfs.f>-herfs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ af -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-herfs uplo a af ipiv b x = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (afDim0,afDim1) = Call.sizes2 $ bounds af-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "herfs: n == afDim0" (n == afDim0)-   Call.assert "herfs: n == ipivDim0" (n == ipivDim0)-   Call.assert "herfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.array af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.herfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhesv.f>-hesv ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int CInt, Int)-hesv uplo a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   ipiv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hesv uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhesvx.f>-hesvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   Int {- ^ lwork -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-hesvx fact uplo a af ipiv b ldx lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hesvx: n == afDim0" (n == afDim0)-   Call.assert "hesvx: n == ipivDim0" (n == ipivDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.ioarray af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.ioarray ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hesvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheswapr.f>-heswapr ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ i1 -} ->-   Int {- ^ i2 -} ->-   IO ()-heswapr uplo a i1 i2 = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      i1Ptr <- Call.cint i1-      i2Ptr <- Call.cint i2-      liftIO $ FFI.heswapr uploPtr nPtr aPtr ldaPtr i1Ptr i2Ptr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetd2.f>-hetd2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)-hetd2 uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   d <- Call.newArray1 n-   e <- Call.newArray1 (n-1)-   tau <- Call.newArray1 (n-1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauPtr <- Call.array tau-      infoPtr <- Call.alloca-      liftIO $ FFI.hetd2 uploPtr nPtr aPtr ldaPtr dPtr ePtr tauPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure d-         <*> pure e-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetf2.f>-hetf2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int CInt, Int)-hetf2 uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.hetf2 uploPtr nPtr aPtr ldaPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrd.f>-hetrd ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)-hetrd uplo a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   d <- Call.newArray1 n-   e <- Call.newArray1 (n-1)-   tau <- Call.newArray1 (n-1)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hetrd uploPtr nPtr aPtr ldaPtr dPtr ePtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure d-         <*> pure e-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrf.f>-hetrf ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int CInt, Int)-hetrf uplo a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hetrf uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri.f>-hetri ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IO (Int)-hetri uplo a ipiv = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "hetri: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hetri uploPtr nPtr aPtr ldaPtr ipivPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri2.f>-hetri2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ nb -} ->-   Int {- ^ lwork -} ->-   IO (Int)-hetri2 uplo a ipiv nb lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "hetri2: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (n+nb+1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hetri2 uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri2x.f>-hetri2x ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ nb -} ->-   IO (Int)-hetri2x uplo a ipiv nb = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "hetri2x: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray2 (nb+3) (n+nb+1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      nbPtr <- Call.cint nb-      infoPtr <- Call.alloca-      liftIO $ FFI.hetri2x uploPtr nPtr aPtr ldaPtr ipivPtr workPtr nbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrs.f>-hetrs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-hetrs uplo a ipiv b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hetrs: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.hetrs uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrs2.f>-hetrs2 ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-hetrs2 uplo a ipiv b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hetrs2: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hetrs2 uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhfrk.f>-hfrk ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Int {- ^ n -} ->-   Int {- ^ k -} ->-   Double {- ^ alpha -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ beta -} ->-   IOCArray Int (Complex Double) {- ^ c -} ->-   IO ()-hfrk transr uplo trans n k alpha a beta c = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   cDim0 <- Call.sizes1 <$> getBounds c-   let _ka = aDim0-   let lda = aDim1-   Call.assert "hfrk: n*(n+1)`div`2 == cDim0" (n*(n+1)`div`2 == cDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      alphaPtr <- Call.double alpha-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      betaPtr <- Call.double beta-      cPtr <- Call.ioarray c-      liftIO $ FFI.hfrk transrPtr uploPtr transPtr nPtr kPtr alphaPtr aPtr ldaPtr betaPtr cPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhgeqz.f>-hgeqz ::-   Char {- ^ job -} ->-   Char {- ^ compq -} ->-   Char {- ^ compz -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)-hgeqz job compq compz ilo ihi h t q z lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ldt = tDim1-   let ldq = qDim1-   let ldz = zDim1-   Call.assert "hgeqz: n == tDim0" (n == tDim0)-   Call.assert "hgeqz: n == qDim0" (n == qDim0)-   Call.assert "hgeqz: n == zDim0" (n == zDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 n-   evalContT $ do-      jobPtr <- Call.char job-      compqPtr <- Call.char compq-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      tPtr <- Call.ioarray t-      ldtPtr <- Call.cint ldt-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hgeqz jobPtr compqPtr compzPtr nPtr iloPtr ihiPtr hPtr ldhPtr tPtr ldtPtr alphaPtr betaPtr qPtr ldqPtr zPtr ldzPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure alpha-         <*> pure beta-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpcon.f>-hpcon ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-hpcon uplo ap ipiv anorm = do-   let apDim0 = Call.sizes1 $ bounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = ipivDim0-   Call.assert "hpcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hpcon uploPtr nPtr apPtr ipivPtr anormPtr rcondPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpev.f>-hpev ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ ldz -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hpev jobz uplo n ap ldz = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "hpev: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,2*n-1])-   rwork <- Call.newArray1 (maximum[1,3*n-2])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hpev jobzPtr uploPtr nPtr apPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpevd.f>-hpevd ::-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hpevd jobz uplo n ap ldz lwork lrwork liwork = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "hpevd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hpevd jobzPtr uploPtr nPtr apPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpevx.f>-hpevx ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-hpevx jobz range uplo n ap vl vu il iu abstol m ldz = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "hpevx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.hpevx jobzPtr rangePtr uploPtr nPtr apPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgst.f>-hpgst ::-   Int {- ^ itype -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ bp -} ->-   IO (Int)-hpgst itype uplo n ap bp = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   let bpDim0 = Call.sizes1 $ bounds bp-   Call.assert "hpgst: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hpgst: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)-   evalContT $ do-      itypePtr <- Call.cint itype-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      bpPtr <- Call.array bp-      infoPtr <- Call.alloca-      liftIO $ FFI.hpgst itypePtr uploPtr nPtr apPtr bpPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgv.f>-hpgv ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ bp -} ->-   Int {- ^ ldz -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hpgv itype jobz uplo n ap bp ldz = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   bpDim0 <- Call.sizes1 <$> getBounds bp-   Call.assert "hpgv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hpgv: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,2*n-1])-   rwork <- Call.newArray1 (maximum[1,3*n-2])-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      bpPtr <- Call.ioarray bp-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hpgv itypePtr jobzPtr uploPtr nPtr apPtr bpPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgvd.f>-hpgvd ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ bp -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)-hpgvd itype jobz uplo n ap bp ldz lwork lrwork liwork = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   bpDim0 <- Call.sizes1 <$> getBounds bp-   Call.assert "hpgvd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hpgvd: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      bpPtr <- Call.ioarray bp-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hpgvd itypePtr jobzPtr uploPtr nPtr apPtr bpPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure w-         <*> pure z-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgvx.f>-hpgvx ::-   Int {- ^ itype -} ->-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ bp -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ ldz -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-hpgvx itype jobz range uplo n ap bp vl vu il iu abstol ldz = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   bpDim0 <- Call.sizes1 <$> getBounds bp-   Call.assert "hpgvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hpgvx: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 n ldz-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 (7*n)-   iwork <- Call.newArray1 (5*n)-   ifail <- Call.newArray1 n-   evalContT $ do-      itypePtr <- Call.cint itype-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      bpPtr <- Call.ioarray bp-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.hpgvx itypePtr jobzPtr rangePtr uploPtr nPtr apPtr bpPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhprfs.f>-hprfs ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ afp -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-hprfs uplo ap afp ipiv b x = do-   let apDim0 = Call.sizes1 $ bounds ap-   let afpDim0 = Call.sizes1 $ bounds afp-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "hprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   Call.assert "hprfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      afpPtr <- Call.array afp-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hprfs uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpsv.f>-hpsv ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (CArray Int CInt, Int)-hpsv uplo n ap b = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hpsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.hpsv uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpsvx.f>-hpsvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ afp -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-hpsvx fact uplo ap afp ipiv b ldx = do-   let apDim0 = Call.sizes1 $ bounds ap-   afpDim0 <- Call.sizes1 <$> getBounds afp-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hpsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "hpsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      afpPtr <- Call.ioarray afp-      ipivPtr <- Call.ioarray ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hpsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrd.f>-hptrd ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)-hptrd uplo n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "hptrd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   d <- Call.newArray1 n-   e <- Call.newArray1 (n-1)-   tau <- Call.newArray1 (n-1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauPtr <- Call.array tau-      infoPtr <- Call.alloca-      liftIO $ FFI.hptrd uploPtr nPtr apPtr dPtr ePtr tauPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure d-         <*> pure e-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrf.f>-hptrf ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (CArray Int CInt, Int)-hptrf uplo n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "hptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.hptrf uploPtr nPtr apPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptri.f>-hptri ::-   Char {- ^ uplo -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IO (Int)-hptri uplo ap ipiv = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = ipivDim0-   Call.assert "hptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.hptri uploPtr nPtr apPtr ipivPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrs.f>-hptrs ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-hptrs uplo ap ipiv b = do-   let apDim0 = Call.sizes1 $ bounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "hptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.hptrs uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhsein.f>-hsein ::-   Char {- ^ side -} ->-   Char {- ^ eigsrc -} ->-   Char {- ^ initv -} ->-   CArray Int Bool {- ^ select -} ->-   CArray (Int,Int) (Complex Double) {- ^ h -} ->-   IOCArray Int (Complex Double) {- ^ w -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->-   IO (Int, CArray Int CInt, CArray Int CInt, Int)-hsein side eigsrc initv select h w vl vr = do-   let selectDim0 = Call.sizes1 $ bounds select-   let (hDim0,hDim1) = Call.sizes2 $ bounds h-   wDim0 <- Call.sizes1 <$> getBounds w-   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl-   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr-   let n = selectDim0-   let ldh = hDim1-   let mm = vlDim0-   let ldvl = vlDim1-   let ldvr = vrDim1-   Call.assert "hsein: n == hDim0" (n == hDim0)-   Call.assert "hsein: n == wDim0" (n == wDim0)-   Call.assert "hsein: mm == vrDim0" (mm == vrDim0)-   work <- Call.newArray1 (n*n)-   rwork <- Call.newArray1 n-   ifaill <- Call.newArray1 mm-   ifailr <- Call.newArray1 mm-   evalContT $ do-      sidePtr <- Call.char side-      eigsrcPtr <- Call.char eigsrc-      initvPtr <- Call.char initv-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      hPtr <- Call.array h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.ioarray w-      vlPtr <- Call.ioarray vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.ioarray vr-      ldvrPtr <- Call.cint ldvr-      mmPtr <- Call.cint mm-      mPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      ifaillPtr <- Call.array ifaill-      ifailrPtr <- Call.array ifailr-      infoPtr <- Call.alloca-      liftIO $ FFI.hsein sidePtr eigsrcPtr initvPtr selectPtr nPtr hPtr ldhPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr ifaillPtr ifailrPtr infoPtr-      liftIO $ pure (,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure ifaill-         <*> pure ifailr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhseqr.f>-hseqr ::-   Char {- ^ job -} ->-   Char {- ^ compz -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-hseqr job compz ilo ihi h z lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ldz = zDim1-   Call.assert "hseqr: n == zDim0" (n == zDim0)-   w <- Call.newArray1 n-   work <- Call.newArray1 lwork-   evalContT $ do-      jobPtr <- Call.char job-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.array w-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.hseqr jobPtr compzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr zPtr ldzPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ilazlc.f>-ilalc ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO CInt-ilalc m a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      liftIO $ FFI.ilalc mPtr nPtr aPtr ldaPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ilazlr.f>-ilalr ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO CInt-ilalr m a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      liftIO $ FFI.ilalr mPtr nPtr aPtr ldaPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/izmax1.f>-imax1 ::-   CArray Int (Complex Double) {- ^ zx -} ->-   Int {- ^ incx -} ->-   IO CInt-imax1 zx incx = do-   let zxDim0 = Call.sizes1 $ bounds zx-   let n = zxDim0-   evalContT $ do-      nPtr <- Call.cint n-      zxPtr <- Call.array zx-      incxPtr <- Call.cint incx-      liftIO $ FFI.imax1 nPtr zxPtr incxPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlabrd.f>-labrd ::-   Int {- ^ m -} ->-   Int {- ^ nb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldx -} ->-   Int {- ^ ldy -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))-labrd m nb a ldx ldy = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   d <- Call.newArray1 nb-   e <- Call.newArray1 nb-   tauq <- Call.newArray1 nb-   taup <- Call.newArray1 nb-   x <- Call.newArray2 nb ldx-   y <- Call.newArray2 nb ldy-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      nbPtr <- Call.cint nb-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      dPtr <- Call.array d-      ePtr <- Call.array e-      tauqPtr <- Call.array tauq-      taupPtr <- Call.array taup-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      yPtr <- Call.array y-      ldyPtr <- Call.cint ldy-      liftIO $ FFI.labrd mPtr nPtr nbPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr xPtr ldxPtr yPtr ldyPtr-      liftIO $ pure (,,,,,)-         <*> pure d-         <*> pure e-         <*> pure tauq-         <*> pure taup-         <*> pure x-         <*> pure y---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacgv.f>-lacgv ::-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IO ()-lacgv n x incx = do-   xDim0 <- Call.sizes1 <$> getBounds x-   let _xSize = xDim0-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      liftIO $ FFI.lacgv nPtr xPtr incxPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacn2.f>-lacn2 ::-   IOCArray Int (Complex Double) {- ^ x -} ->-   Double {- ^ est -} ->-   Int {- ^ kase -} ->-   IOCArray Int CInt {- ^ isave -} ->-   IO (CArray Int (Complex Double), Double, Int)-lacn2 x est kase isave = do-   xDim0 <- Call.sizes1 <$> getBounds x-   isaveDim0 <- Call.sizes1 <$> getBounds isave-   let n = xDim0-   Call.assert "lacn2: 3 == isaveDim0" (3 == isaveDim0)-   v <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      vPtr <- Call.array v-      xPtr <- Call.ioarray x-      estPtr <- Call.double est-      kasePtr <- Call.cint kase-      isavePtr <- Call.ioarray isave-      liftIO $ FFI.lacn2 nPtr vPtr xPtr estPtr kasePtr isavePtr-      liftIO $ pure (,,)-         <*> pure v-         <*> peek estPtr-         <*> fmap fromIntegral (peek kasePtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacon.f>-lacon ::-   IOCArray Int (Complex Double) {- ^ x -} ->-   Double {- ^ est -} ->-   Int {- ^ kase -} ->-   IO (CArray Int (Complex Double), Double, Int)-lacon x est kase = do-   xDim0 <- Call.sizes1 <$> getBounds x-   let n = xDim0-   v <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      vPtr <- Call.array v-      xPtr <- Call.ioarray x-      estPtr <- Call.double est-      kasePtr <- Call.cint kase-      liftIO $ FFI.lacon nPtr vPtr xPtr estPtr kasePtr-      liftIO $ pure (,,)-         <*> pure v-         <*> peek estPtr-         <*> fmap fromIntegral (peek kasePtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacp2.f>-lacp2 ::-   Char {- ^ uplo -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) Double {- ^ a -} ->-   Int {- ^ ldb -} ->-   IO (CArray (Int,Int) (Complex Double))-lacp2 uplo m a ldb = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   b <- Call.newArray2 n ldb-   evalContT $ do-      uploPtr <- Call.char uplo-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.lacp2 uploPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr-      liftIO $ pure b---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacpy.f>-lacpy ::-   Char {- ^ uplo -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldb -} ->-   IO (CArray (Int,Int) (Complex Double))-lacpy uplo m a ldb = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   b <- Call.newArray2 n ldb-   evalContT $ do-      uploPtr <- Call.char uplo-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.lacpy uploPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr-      liftIO $ pure b---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacrm.f>-lacrm ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) Double {- ^ b -} ->-   Int {- ^ ldc -} ->-   IO (CArray (Int,Int) (Complex Double))-lacrm m a b ldc = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   Call.assert "lacrm: n == bDim0" (n == bDim0)-   c <- Call.newArray2 n ldc-   rwork <- Call.newArray1 (2*m*n)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.array c-      ldcPtr <- Call.cint ldc-      rworkPtr <- Call.array rwork-      liftIO $ FFI.lacrm mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr rworkPtr-      liftIO $ pure c---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacrt.f>-lacrt ::-   IOCArray Int (Complex Double) {- ^ cx -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ cy -} ->-   Int {- ^ incy -} ->-   Complex Double {- ^ c -} ->-   Complex Double {- ^ s -} ->-   IO ()-lacrt cx incx cy incy c s = do-   cxDim0 <- Call.sizes1 <$> getBounds cx-   cyDim0 <- Call.sizes1 <$> getBounds cy-   let n = cxDim0-   Call.assert "lacrt: n == cyDim0" (n == cyDim0)-   evalContT $ do-      nPtr <- Call.cint n-      cxPtr <- Call.ioarray cx-      incxPtr <- Call.cint incx-      cyPtr <- Call.ioarray cy-      incyPtr <- Call.cint incy-      cPtr <- Call.complexDouble c-      sPtr <- Call.complexDouble s-      liftIO $ FFI.lacrt nPtr cxPtr incxPtr cyPtr incyPtr cPtr sPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed0.f>-laed0 ::-   Int {- ^ qsiz -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   Int {- ^ ldqs -} ->-   Int {- ^ rworkSize -} ->-   Int {- ^ iworkSize -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-laed0 qsiz d e q ldqs rworkSize iworkSize = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   let n = dDim0-   let ldq = qDim1-   Call.assert "laed0: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "laed0: n == qDim0" (n == qDim0)-   qstore <- Call.newArray2 n ldqs-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 iworkSize-   evalContT $ do-      qsizPtr <- Call.cint qsiz-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      qstorePtr <- Call.array qstore-      ldqsPtr <- Call.cint ldqs-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.laed0 qsizPtr nPtr dPtr ePtr qPtr ldqPtr qstorePtr ldqsPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure qstore-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed7.f>-laed7 ::-   Int {- ^ cutpnt -} ->-   Int {- ^ qsiz -} ->-   Int {- ^ tlvls -} ->-   Int {- ^ curlvl -} ->-   Int {- ^ curpbm -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   Double {- ^ rho -} ->-   IOCArray Int Double {- ^ qstore -} ->-   IOCArray Int CInt {- ^ qptr -} ->-   CArray Int CInt {- ^ prmptr -} ->-   CArray Int CInt {- ^ perm -} ->-   CArray Int CInt {- ^ givptr -} ->-   CArray (Int,Int) CInt {- ^ givcol -} ->-   CArray (Int,Int) Double {- ^ givnum -} ->-   Int {- ^ rworkSize -} ->-   IO (CArray Int CInt, Int)-laed7 cutpnt qsiz tlvls curlvl curpbm d q rho qstore qptr prmptr perm givptr givcol givnum rworkSize = do-   dDim0 <- Call.sizes1 <$> getBounds d-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   qstoreDim0 <- Call.sizes1 <$> getBounds qstore-   qptrDim0 <- Call.sizes1 <$> getBounds qptr-   let prmptrDim0 = Call.sizes1 $ bounds prmptr-   let permDim0 = Call.sizes1 $ bounds perm-   let givptrDim0 = Call.sizes1 $ bounds givptr-   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol-   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum-   let n = dDim0-   let ldq = qDim1-   let nlgn = prmptrDim0-   Call.assert "laed7: n == qDim0" (n == qDim0)-   Call.assert "laed7: n^!2+1 == qstoreDim0" (n^!2+1 == qstoreDim0)-   Call.assert "laed7: n+2 == qptrDim0" (n+2 == qptrDim0)-   Call.assert "laed7: nlgn == permDim0" (nlgn == permDim0)-   Call.assert "laed7: nlgn == givptrDim0" (nlgn == givptrDim0)-   Call.assert "laed7: nlgn == givcolDim0" (nlgn == givcolDim0)-   Call.assert "laed7: 2 == givcolDim1" (2 == givcolDim1)-   Call.assert "laed7: nlgn == givnumDim0" (nlgn == givnumDim0)-   Call.assert "laed7: 2 == givnumDim1" (2 == givnumDim1)-   indxq <- Call.newArray1 n-   work <- Call.newArray1 (qsiz*n)-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 (4*n)-   evalContT $ do-      nPtr <- Call.cint n-      cutpntPtr <- Call.cint cutpnt-      qsizPtr <- Call.cint qsiz-      tlvlsPtr <- Call.cint tlvls-      curlvlPtr <- Call.cint curlvl-      curpbmPtr <- Call.cint curpbm-      dPtr <- Call.ioarray d-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      rhoPtr <- Call.double rho-      indxqPtr <- Call.array indxq-      qstorePtr <- Call.ioarray qstore-      qptrPtr <- Call.ioarray qptr-      prmptrPtr <- Call.array prmptr-      permPtr <- Call.array perm-      givptrPtr <- Call.array givptr-      givcolPtr <- Call.array givcol-      givnumPtr <- Call.array givnum-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.laed7 nPtr cutpntPtr qsizPtr tlvlsPtr curlvlPtr curpbmPtr dPtr qPtr ldqPtr rhoPtr indxqPtr qstorePtr qptrPtr prmptrPtr permPtr givptrPtr givcolPtr givnumPtr workPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure indxq-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed8.f>-laed8 ::-   Int {- ^ qsiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray Int Double {- ^ d -} ->-   Double {- ^ rho -} ->-   Int {- ^ cutpnt -} ->-   CArray Int Double {- ^ z -} ->-   Int {- ^ ldq2 -} ->-   CArray Int CInt {- ^ indxq -} ->-   IO (Int, Double, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int Double, CArray Int CInt, CArray Int CInt, CArray Int CInt, Int, CArray (Int,Int) CInt, CArray (Int,Int) Double, Int)-laed8 qsiz q d rho cutpnt z ldq2 indxq = do-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   dDim0 <- Call.sizes1 <$> getBounds d-   let zDim0 = Call.sizes1 $ bounds z-   let indxqDim0 = Call.sizes1 $ bounds indxq-   let n = qDim0-   let ldq = qDim1-   Call.assert "laed8: n == dDim0" (n == dDim0)-   Call.assert "laed8: n == zDim0" (n == zDim0)-   Call.assert "laed8: n == indxqDim0" (n == indxqDim0)-   dlamda <- Call.newArray1 n-   q2 <- Call.newArray2 n ldq2-   w <- Call.newArray1 n-   indxp <- Call.newArray1 n-   indx <- Call.newArray1 n-   perm <- Call.newArray1 n-   givcol <- Call.newArray2 n 2-   givnum <- Call.newArray2 n 2-   evalContT $ do-      kPtr <- Call.alloca-      nPtr <- Call.cint n-      qsizPtr <- Call.cint qsiz-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      dPtr <- Call.ioarray d-      rhoPtr <- Call.double rho-      cutpntPtr <- Call.cint cutpnt-      zPtr <- Call.array z-      dlamdaPtr <- Call.array dlamda-      q2Ptr <- Call.array q2-      ldq2Ptr <- Call.cint ldq2-      wPtr <- Call.array w-      indxpPtr <- Call.array indxp-      indxPtr <- Call.array indx-      indxqPtr <- Call.array indxq-      permPtr <- Call.array perm-      givptrPtr <- Call.alloca-      givcolPtr <- Call.array givcol-      givnumPtr <- Call.array givnum-      infoPtr <- Call.alloca-      liftIO $ FFI.laed8 kPtr nPtr qsizPtr qPtr ldqPtr dPtr rhoPtr cutpntPtr zPtr dlamdaPtr q2Ptr ldq2Ptr wPtr indxpPtr indxPtr indxqPtr permPtr givptrPtr givcolPtr givnumPtr infoPtr-      liftIO $ pure (,,,,,,,,,,,)-         <*> fmap fromIntegral (peek kPtr)-         <*> peek rhoPtr-         <*> pure dlamda-         <*> pure q2-         <*> pure w-         <*> pure indxp-         <*> pure indx-         <*> pure perm-         <*> fmap fromIntegral (peek givptrPtr)-         <*> pure givcol-         <*> pure givnum-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaein.f>-laein ::-   Bool {- ^ rightv -} ->-   Bool {- ^ noinit -} ->-   CArray (Int,Int) (Complex Double) {- ^ h -} ->-   Complex Double {- ^ w -} ->-   IOCArray Int (Complex Double) {- ^ v -} ->-   Int {- ^ ldb -} ->-   Double {- ^ eps3 -} ->-   Double {- ^ smlnum -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-laein rightv noinit h w v ldb eps3 smlnum = do-   let (hDim0,hDim1) = Call.sizes2 $ bounds h-   vDim0 <- Call.sizes1 <$> getBounds v-   let n = hDim0-   let ldh = hDim1-   Call.assert "laein: n == vDim0" (n == vDim0)-   b <- Call.newArray2 n ldb-   rwork <- Call.newArray1 n-   evalContT $ do-      rightvPtr <- Call.bool rightv-      noinitPtr <- Call.bool noinit-      nPtr <- Call.cint n-      hPtr <- Call.array h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.complexDouble w-      vPtr <- Call.ioarray v-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      rworkPtr <- Call.array rwork-      eps3Ptr <- Call.double eps3-      smlnumPtr <- Call.double smlnum-      infoPtr <- Call.alloca-      liftIO $ FFI.laein rightvPtr noinitPtr nPtr hPtr ldhPtr wPtr vPtr bPtr ldbPtr rworkPtr eps3Ptr smlnumPtr infoPtr-      liftIO $ pure (,)-         <*> pure b-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaesy.f>-laesy ::-   Complex Double {- ^ a -} ->-   Complex Double {- ^ b -} ->-   Complex Double {- ^ c -} ->-   IO (Complex Double, Complex Double, Complex Double, Complex Double, Complex Double)-laesy a b c = do-   evalContT $ do-      aPtr <- Call.complexDouble a-      bPtr <- Call.complexDouble b-      cPtr <- Call.complexDouble c-      rt1Ptr <- Call.alloca-      rt2Ptr <- Call.alloca-      evscalPtr <- Call.alloca-      cs1Ptr <- Call.alloca-      sn1Ptr <- Call.alloca-      liftIO $ FFI.laesy aPtr bPtr cPtr rt1Ptr rt2Ptr evscalPtr cs1Ptr sn1Ptr-      liftIO $ pure (,,,,)-         <*> peek rt1Ptr-         <*> peek rt2Ptr-         <*> peek evscalPtr-         <*> peek cs1Ptr-         <*> peek sn1Ptr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaev2.f>-laev2 ::-   Complex Double {- ^ a -} ->-   Complex Double {- ^ b -} ->-   Complex Double {- ^ c -} ->-   IO (Double, Double, Double, Complex Double)-laev2 a b c = do-   evalContT $ do-      aPtr <- Call.complexDouble a-      bPtr <- Call.complexDouble b-      cPtr <- Call.complexDouble c-      rt1Ptr <- Call.alloca-      rt2Ptr <- Call.alloca-      cs1Ptr <- Call.alloca-      sn1Ptr <- Call.alloca-      liftIO $ FFI.laev2 aPtr bPtr cPtr rt1Ptr rt2Ptr cs1Ptr sn1Ptr-      liftIO $ pure (,,,)-         <*> peek rt1Ptr-         <*> peek rt2Ptr-         <*> peek cs1Ptr-         <*> peek sn1Ptr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlag2c.f>-lag2c ::-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldsa -} ->-   IO (CArray (Int,Int) (Complex Float), Int)-lag2c m a ldsa = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   sa <- Call.newArray2 n ldsa-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      saPtr <- Call.array sa-      ldsaPtr <- Call.cint ldsa-      infoPtr <- Call.alloca-      liftIO $ FFI.lag2c mPtr nPtr aPtr ldaPtr saPtr ldsaPtr infoPtr-      liftIO $ pure (,)-         <*> pure sa-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlags2.f>-lags2 ::-   Bool {- ^ upper -} ->-   Double {- ^ a1 -} ->-   Complex Double {- ^ a2 -} ->-   Double {- ^ a3 -} ->-   Double {- ^ b1 -} ->-   Complex Double {- ^ b2 -} ->-   Double {- ^ b3 -} ->-   IO (Double, Complex Double, Double, Complex Double, Double, Complex Double)-lags2 upper a1 a2 a3 b1 b2 b3 = do-   evalContT $ do-      upperPtr <- Call.bool upper-      a1Ptr <- Call.double a1-      a2Ptr <- Call.complexDouble a2-      a3Ptr <- Call.double a3-      b1Ptr <- Call.double b1-      b2Ptr <- Call.complexDouble b2-      b3Ptr <- Call.double b3-      csuPtr <- Call.alloca-      snuPtr <- Call.alloca-      csvPtr <- Call.alloca-      snvPtr <- Call.alloca-      csqPtr <- Call.alloca-      snqPtr <- Call.alloca-      liftIO $ FFI.lags2 upperPtr a1Ptr a2Ptr a3Ptr b1Ptr b2Ptr b3Ptr csuPtr snuPtr csvPtr snvPtr csqPtr snqPtr-      liftIO $ pure (,,,,,)-         <*> peek csuPtr-         <*> peek snuPtr-         <*> peek csvPtr-         <*> peek snvPtr-         <*> peek csqPtr-         <*> peek snqPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlagtm.f>-lagtm ::-   Char {- ^ trans -} ->-   Double {- ^ alpha -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   CArray (Int,Int) (Complex Double) {- ^ x -} ->-   Double {- ^ beta -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO ()-lagtm trans alpha dl d du x beta b = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let (xDim0,xDim1) = Call.sizes2 $ bounds x-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = xDim0-   let ldx = xDim1-   let ldb = bDim1-   Call.assert "lagtm: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "lagtm: n-1 == duDim0" (n-1 == duDim0)-   Call.assert "lagtm: nrhs == bDim0" (nrhs == bDim0)-   evalContT $ do-      transPtr <- Call.char trans-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      alphaPtr <- Call.double alpha-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      betaPtr <- Call.double beta-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.lagtm transPtr nPtr nrhsPtr alphaPtr dlPtr dPtr duPtr xPtr ldxPtr betaPtr bPtr ldbPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahef.f>-lahef ::-   Char {- ^ uplo -} ->-   Int {- ^ nb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldw -} ->-   IO (Int, CArray Int CInt, CArray (Int,Int) (Complex Double), Int)-lahef uplo nb a ldw = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   w <- Call.newArray2 nb ldw-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nbPtr <- Call.cint nb-      kbPtr <- Call.alloca-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      wPtr <- Call.array w-      ldwPtr <- Call.cint ldw-      infoPtr <- Call.alloca-      liftIO $ FFI.lahef uploPtr nPtr nbPtr kbPtr aPtr ldaPtr ipivPtr wPtr ldwPtr infoPtr-      liftIO $ pure (,,,)-         <*> fmap fromIntegral (peek kbPtr)-         <*> pure ipiv-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahqr.f>-lahqr ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   Int {- ^ ihiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   IO (CArray Int (Complex Double), Int)-lahqr wantt wantz ilo ihi h iloz ihiz z = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ldz = zDim1-   Call.assert "lahqr: n == zDim0" (n == zDim0)-   w <- Call.newArray1 n-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.array w-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      infoPtr <- Call.alloca-      liftIO $ FFI.lahqr wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahr2.f>-lahr2 ::-   Int {- ^ n -} ->-   Int {- ^ k -} ->-   Int {- ^ nb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldt -} ->-   Int {- ^ ldy -} ->-   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))-lahr2 n k nb a ldt ldy = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let lda = aDim1-   Call.assert "lahr2: n-k+1 == aDim0" (n-k+1 == aDim0)-   tau <- Call.newArray1 nb-   t <- Call.newArray2 nb ldt-   y <- Call.newArray2 nb ldy-   evalContT $ do-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      nbPtr <- Call.cint nb-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      yPtr <- Call.array y-      ldyPtr <- Call.cint ldy-      liftIO $ FFI.lahr2 nPtr kPtr nbPtr aPtr ldaPtr tauPtr tPtr ldtPtr yPtr ldyPtr-      liftIO $ pure (,,)-         <*> pure tau-         <*> pure t-         <*> pure y---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaic1.f>-laic1 ::-   Int {- ^ job -} ->-   CArray Int (Complex Double) {- ^ x -} ->-   Double {- ^ sest -} ->-   CArray Int (Complex Double) {- ^ w -} ->-   Complex Double {- ^ gamma -} ->-   IO (Double, Complex Double, Complex Double)-laic1 job x sest w gamma = do-   let xDim0 = Call.sizes1 $ bounds x-   let wDim0 = Call.sizes1 $ bounds w-   let j = xDim0-   Call.assert "laic1: j == wDim0" (j == wDim0)-   evalContT $ do-      jobPtr <- Call.cint job-      jPtr <- Call.cint j-      xPtr <- Call.array x-      sestPtr <- Call.double sest-      wPtr <- Call.array w-      gammaPtr <- Call.complexDouble gamma-      sestprPtr <- Call.alloca-      sPtr <- Call.alloca-      cPtr <- Call.alloca-      liftIO $ FFI.laic1 jobPtr jPtr xPtr sestPtr wPtr gammaPtr sestprPtr sPtr cPtr-      liftIO $ pure (,,)-         <*> peek sestprPtr-         <*> peek sPtr-         <*> peek cPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlals0.f>-lals0 ::-   Int {- ^ icompq -} ->-   Int {- ^ nl -} ->-   Int {- ^ nr -} ->-   Int {- ^ sqre -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldbx -} ->-   CArray Int CInt {- ^ perm -} ->-   Int {- ^ givptr -} ->-   CArray (Int,Int) CInt {- ^ givcol -} ->-   CArray (Int,Int) Double {- ^ givnum -} ->-   CArray (Int,Int) Double {- ^ poles -} ->-   CArray Int Double {- ^ difl -} ->-   CArray (Int,Int) Double {- ^ difr -} ->-   CArray Int Double {- ^ z -} ->-   Double {- ^ c -} ->-   Double {- ^ s -} ->-   Int {- ^ rworkSize -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-lals0 icompq nl nr sqre b ldbx perm givptr givcol givnum poles difl difr z c s rworkSize = do-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let permDim0 = Call.sizes1 $ bounds perm-   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol-   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum-   let (polesDim0,polesDim1) = Call.sizes2 $ bounds poles-   let diflDim0 = Call.sizes1 $ bounds difl-   let (difrDim0,difrDim1) = Call.sizes2 $ bounds difr-   let zDim0 = Call.sizes1 $ bounds z-   let nrhs = bDim0-   let ldb = bDim1-   let _n = permDim0-   let ldgcol = givcolDim1-   let ldgnum = givnumDim1-   let k = diflDim0-   Call.assert "lals0: 2 == givcolDim0" (2 == givcolDim0)-   Call.assert "lals0: 2 == givnumDim0" (2 == givnumDim0)-   Call.assert "lals0: 2 == polesDim0" (2 == polesDim0)-   Call.assert "lals0: ldgnum == polesDim1" (ldgnum == polesDim1)-   Call.assert "lals0: 2 == difrDim0" (2 == difrDim0)-   Call.assert "lals0: ldgnum == difrDim1" (ldgnum == difrDim1)-   Call.assert "lals0: k == zDim0" (k == zDim0)-   bx <- Call.newArray2 nrhs ldbx-   rwork <- Call.newArray1 rworkSize-   evalContT $ do-      icompqPtr <- Call.cint icompq-      nlPtr <- Call.cint nl-      nrPtr <- Call.cint nr-      sqrePtr <- Call.cint sqre-      nrhsPtr <- Call.cint nrhs-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      bxPtr <- Call.array bx-      ldbxPtr <- Call.cint ldbx-      permPtr <- Call.array perm-      givptrPtr <- Call.cint givptr-      givcolPtr <- Call.array givcol-      ldgcolPtr <- Call.cint ldgcol-      givnumPtr <- Call.array givnum-      ldgnumPtr <- Call.cint ldgnum-      polesPtr <- Call.array poles-      diflPtr <- Call.array difl-      difrPtr <- Call.array difr-      zPtr <- Call.array z-      kPtr <- Call.cint k-      cPtr <- Call.double c-      sPtr <- Call.double s-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.lals0 icompqPtr nlPtr nrPtr sqrePtr nrhsPtr bPtr ldbPtr bxPtr ldbxPtr permPtr givptrPtr givcolPtr ldgcolPtr givnumPtr ldgnumPtr polesPtr diflPtr difrPtr zPtr kPtr cPtr sPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure bx-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlalsa.f>-lalsa ::-   Int {- ^ icompq -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldbx -} ->-   CArray (Int,Int) Double {- ^ u -} ->-   CArray (Int,Int) Double {- ^ vt -} ->-   CArray Int CInt {- ^ k -} ->-   CArray (Int,Int) Double {- ^ difl -} ->-   CArray (Int,Int) Double {- ^ difr -} ->-   CArray (Int,Int) Double {- ^ z -} ->-   CArray (Int,Int) Double {- ^ poles -} ->-   CArray Int CInt {- ^ givptr -} ->-   CArray (Int,Int) CInt {- ^ givcol -} ->-   CArray (Int,Int) CInt {- ^ perm -} ->-   CArray (Int,Int) Double {- ^ givnum -} ->-   CArray Int Double {- ^ c -} ->-   CArray Int Double {- ^ s -} ->-   Int {- ^ rworkSize -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-lalsa icompq b ldbx u vt k difl difr z poles givptr givcol perm givnum c s rworkSize = do-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let (uDim0,uDim1) = Call.sizes2 $ bounds u-   let (vtDim0,vtDim1) = Call.sizes2 $ bounds vt-   let kDim0 = Call.sizes1 $ bounds k-   let (diflDim0,diflDim1) = Call.sizes2 $ bounds difl-   let (difrDim0,difrDim1) = Call.sizes2 $ bounds difr-   let (zDim0,zDim1) = Call.sizes2 $ bounds z-   let (polesDim0,polesDim1) = Call.sizes2 $ bounds poles-   let givptrDim0 = Call.sizes1 $ bounds givptr-   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol-   let (permDim0,permDim1) = Call.sizes2 $ bounds perm-   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum-   let cDim0 = Call.sizes1 $ bounds c-   let sDim0 = Call.sizes1 $ bounds s-   let nrhs = bDim0-   let ldb = bDim1-   let smlsiz = uDim0-   let ldu = uDim1-   let n = kDim0-   let nlvl = diflDim0-   let ldgcol = givcolDim1-   Call.assert "lalsa: smlsiz+1 == vtDim0" (smlsiz+1 == vtDim0)-   Call.assert "lalsa: ldu == vtDim1" (ldu == vtDim1)-   Call.assert "lalsa: ldu == diflDim1" (ldu == diflDim1)-   Call.assert "lalsa: 2*nlvl == difrDim0" (2*nlvl == difrDim0)-   Call.assert "lalsa: ldu == difrDim1" (ldu == difrDim1)-   Call.assert "lalsa: nlvl == zDim0" (nlvl == zDim0)-   Call.assert "lalsa: ldu == zDim1" (ldu == zDim1)-   Call.assert "lalsa: 2*nlvl == polesDim0" (2*nlvl == polesDim0)-   Call.assert "lalsa: ldu == polesDim1" (ldu == polesDim1)-   Call.assert "lalsa: n == givptrDim0" (n == givptrDim0)-   Call.assert "lalsa: 2*nlvl == givcolDim0" (2*nlvl == givcolDim0)-   Call.assert "lalsa: nlvl == permDim0" (nlvl == permDim0)-   Call.assert "lalsa: ldgcol == permDim1" (ldgcol == permDim1)-   Call.assert "lalsa: 2*nlvl == givnumDim0" (2*nlvl == givnumDim0)-   Call.assert "lalsa: ldu == givnumDim1" (ldu == givnumDim1)-   Call.assert "lalsa: n == cDim0" (n == cDim0)-   Call.assert "lalsa: n == sDim0" (n == sDim0)-   bx <- Call.newArray2 nrhs ldbx-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 (3*n)-   evalContT $ do-      icompqPtr <- Call.cint icompq-      smlsizPtr <- Call.cint smlsiz-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      bxPtr <- Call.array bx-      ldbxPtr <- Call.cint ldbx-      uPtr <- Call.array u-      lduPtr <- Call.cint ldu-      vtPtr <- Call.array vt-      kPtr <- Call.array k-      diflPtr <- Call.array difl-      difrPtr <- Call.array difr-      zPtr <- Call.array z-      polesPtr <- Call.array poles-      givptrPtr <- Call.array givptr-      givcolPtr <- Call.array givcol-      ldgcolPtr <- Call.cint ldgcol-      permPtr <- Call.array perm-      givnumPtr <- Call.array givnum-      cPtr <- Call.array c-      sPtr <- Call.array s-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.lalsa icompqPtr smlsizPtr nPtr nrhsPtr bPtr ldbPtr bxPtr ldbxPtr uPtr lduPtr vtPtr kPtr diflPtr difrPtr zPtr polesPtr givptrPtr givcolPtr ldgcolPtr permPtr givnumPtr cPtr sPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure bx-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlalsd.f>-lalsd ::-   Char {- ^ uplo -} ->-   Int {- ^ smlsiz -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Double {- ^ rcond -} ->-   Int {- ^ rworkSize -} ->-   Int {- ^ iworkSize -} ->-   IO (Int, Int)-lalsd uplo smlsiz d e b rcond rworkSize iworkSize = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "lalsd: n-1 == eDim0" (n-1 == eDim0)-   work <- Call.newArray1 (n*nrhs)-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 iworkSize-   evalContT $ do-      uploPtr <- Call.char uplo-      smlsizPtr <- Call.cint smlsiz-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      rcondPtr <- Call.double rcond-      rankPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.lalsd uploPtr smlsizPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr rcondPtr rankPtr workPtr rworkPtr iworkPtr infoPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlangb.f>-langb ::-   Char {- ^ norm -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ lwork -} ->-   IO Double-langb norm kl ku ab lwork = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      workPtr <- Call.array work-      liftIO $ FFI.langb normPtr nPtr klPtr kuPtr abPtr ldabPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlange.f>-lange ::-   Char {- ^ norm -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lange norm m a lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      workPtr <- Call.array work-      liftIO $ FFI.lange normPtr mPtr nPtr aPtr ldaPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlangt.f>-langt ::-   Char {- ^ norm -} ->-   CArray Int (Complex Double) {- ^ dl -} ->-   CArray Int (Complex Double) {- ^ d -} ->-   CArray Int (Complex Double) {- ^ du -} ->-   IO Double-langt norm dl d du = do-   let dlDim0 = Call.sizes1 $ bounds dl-   let dDim0 = Call.sizes1 $ bounds d-   let duDim0 = Call.sizes1 $ bounds du-   let n = dDim0-   Call.assert "langt: n-1 == dlDim0" (n-1 == dlDim0)-   Call.assert "langt: n-1 == duDim0" (n-1 == duDim0)-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      dlPtr <- Call.array dl-      dPtr <- Call.array d-      duPtr <- Call.array du-      liftIO $ FFI.langt normPtr nPtr dlPtr dPtr duPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhb.f>-lanhb ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Int {- ^ k -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ lwork -} ->-   IO Double-lanhb norm uplo k ab lwork = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      workPtr <- Call.array work-      liftIO $ FFI.lanhb normPtr uploPtr nPtr kPtr abPtr ldabPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhe.f>-lanhe ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lanhe norm uplo a lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      workPtr <- Call.array work-      liftIO $ FFI.lanhe normPtr uploPtr nPtr aPtr ldaPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhf.f>-lanhf ::-   Char {- ^ norm -} ->-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lanhf norm transr uplo n a lwork = do-   let aDim0 = Call.sizes1 $ bounds a-   Call.assert "lanhf: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   work <- Call.newArray1 lwork-   evalContT $ do-      normPtr <- Call.char norm-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      workPtr <- Call.array work-      liftIO $ FFI.lanhf normPtr transrPtr uploPtr nPtr aPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhp.f>-lanhp ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ lwork -} ->-   IO Double-lanhp norm uplo n ap lwork = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "lanhp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      workPtr <- Call.array work-      liftIO $ FFI.lanhp normPtr uploPtr nPtr apPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhs.f>-lanhs ::-   Char {- ^ norm -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lanhs norm a lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      workPtr <- Call.array work-      liftIO $ FFI.lanhs normPtr nPtr aPtr ldaPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanht.f>-lanht ::-   Char {- ^ norm -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   IO Double-lanht norm d e = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   let n = dDim0-   Call.assert "lanht: n-1 == eDim0" (n-1 == eDim0)-   evalContT $ do-      normPtr <- Call.char norm-      nPtr <- Call.cint n-      dPtr <- Call.array d-      ePtr <- Call.array e-      liftIO $ FFI.lanht normPtr nPtr dPtr ePtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansb.f>-lansb ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Int {- ^ k -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ lwork -} ->-   IO Double-lansb norm uplo k ab lwork = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      workPtr <- Call.array work-      liftIO $ FFI.lansb normPtr uploPtr nPtr kPtr abPtr ldabPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansp.f>-lansp ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ lwork -} ->-   IO Double-lansp norm uplo n ap lwork = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "lansp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      workPtr <- Call.array work-      liftIO $ FFI.lansp normPtr uploPtr nPtr apPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansy.f>-lansy ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lansy norm uplo a lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      workPtr <- Call.array work-      liftIO $ FFI.lansy normPtr uploPtr nPtr aPtr ldaPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantb.f>-lantb ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ k -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Int {- ^ lwork -} ->-   IO Double-lantb norm uplo diag k ab lwork = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      workPtr <- Call.array work-      liftIO $ FFI.lantb normPtr uploPtr diagPtr nPtr kPtr abPtr ldabPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantp.f>-lantp ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ lwork -} ->-   IO Double-lantp norm uplo diag n ap lwork = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "lantp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      workPtr <- Call.array work-      liftIO $ FFI.lantp normPtr uploPtr diagPtr nPtr apPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantr.f>-lantr ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO Double-lantr norm uplo diag m a lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      workPtr <- Call.array work-      liftIO $ FFI.lantr normPtr uploPtr diagPtr mPtr nPtr aPtr ldaPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapll.f>-lapll ::-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   Int {- ^ incy -} ->-   IO (Double)-lapll n x incx y incy = do-   xDim0 <- Call.sizes1 <$> getBounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   Call.assert "lapll: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)-   Call.assert "lapll: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      yPtr <- Call.ioarray y-      incyPtr <- Call.cint incy-      ssminPtr <- Call.alloca-      liftIO $ FFI.lapll nPtr xPtr incxPtr yPtr incyPtr ssminPtr-      liftIO $ peek ssminPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapmr.f>-lapmr ::-   Bool {- ^ forwrd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IOCArray Int CInt {- ^ k -} ->-   IO ()-lapmr forwrd x k = do-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   kDim0 <- Call.sizes1 <$> getBounds k-   let n = xDim0-   let ldx = xDim1-   let m = kDim0-   evalContT $ do-      forwrdPtr <- Call.bool forwrd-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      kPtr <- Call.ioarray k-      liftIO $ FFI.lapmr forwrdPtr mPtr nPtr xPtr ldxPtr kPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapmt.f>-lapmt ::-   Bool {- ^ forwrd -} ->-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IOCArray Int CInt {- ^ k -} ->-   IO ()-lapmt forwrd m x k = do-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   kDim0 <- Call.sizes1 <$> getBounds k-   let n = xDim0-   let ldx = xDim1-   Call.assert "lapmt: n == kDim0" (n == kDim0)-   evalContT $ do-      forwrdPtr <- Call.bool forwrd-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      kPtr <- Call.ioarray k-      liftIO $ FFI.lapmt forwrdPtr mPtr nPtr xPtr ldxPtr kPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqgb.f>-laqgb ::-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray Int Double {- ^ r -} ->-   CArray Int Double {- ^ c -} ->-   Double {- ^ rowcnd -} ->-   Double {- ^ colcnd -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqgb kl ku ab r c rowcnd colcnd amax = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let rDim0 = Call.sizes1 $ bounds r-   let cDim0 = Call.sizes1 $ bounds c-   let n = abDim0-   let ldab = abDim1-   let m = rDim0-   Call.assert "laqgb: n == cDim0" (n == cDim0)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.double rowcnd-      colcndPtr <- Call.double colcnd-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqgb mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqge.f>-laqge ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int Double {- ^ r -} ->-   CArray Int Double {- ^ c -} ->-   Double {- ^ rowcnd -} ->-   Double {- ^ colcnd -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqge a r c rowcnd colcnd amax = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let rDim0 = Call.sizes1 $ bounds r-   let cDim0 = Call.sizes1 $ bounds c-   let n = aDim0-   let lda = aDim1-   let m = rDim0-   Call.assert "laqge: n == cDim0" (n == cDim0)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      rPtr <- Call.array r-      cPtr <- Call.array c-      rowcndPtr <- Call.double rowcnd-      colcndPtr <- Call.double colcnd-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqge mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhb.f>-laqhb ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (CArray Int Double, Char)-laqhb uplo kd ab scond amax = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   s <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqhb uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ pure (,)-         <*> pure s-         <*> fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhe.f>-laqhe ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int Double {- ^ s -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqhe uplo a s scond amax = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let sDim0 = Call.sizes1 $ bounds s-   let n = aDim0-   let lda = aDim1-   Call.assert "laqhe: n == sDim0" (n == sDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqhe uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhp.f>-laqhp ::-   Char {- ^ uplo -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   CArray Int Double {- ^ s -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqhp uplo ap s scond amax = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   let sDim0 = Call.sizes1 $ bounds s-   let n = sDim0-   Call.assert "laqhp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqhp uploPtr nPtr apPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqp2.f>-laqp2 ::-   Int {- ^ m -} ->-   Int {- ^ offset -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray Int CInt {- ^ jpvt -} ->-   IOCArray Int Double {- ^ vn1 -} ->-   IOCArray Int Double {- ^ vn2 -} ->-   IO (CArray Int (Complex Double))-laqp2 m offset a jpvt vn1 vn2 = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt-   vn1Dim0 <- Call.sizes1 <$> getBounds vn1-   vn2Dim0 <- Call.sizes1 <$> getBounds vn2-   let n = aDim0-   let lda = aDim1-   Call.assert "laqp2: n == jpvtDim0" (n == jpvtDim0)-   Call.assert "laqp2: n == vn1Dim0" (n == vn1Dim0)-   Call.assert "laqp2: n == vn2Dim0" (n == vn2Dim0)-   tau <- Call.newArray1 (minimum[m,n])-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      offsetPtr <- Call.cint offset-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      jpvtPtr <- Call.ioarray jpvt-      tauPtr <- Call.array tau-      vn1Ptr <- Call.ioarray vn1-      vn2Ptr <- Call.ioarray vn2-      workPtr <- Call.array work-      liftIO $ FFI.laqp2 mPtr nPtr offsetPtr aPtr ldaPtr jpvtPtr tauPtr vn1Ptr vn2Ptr workPtr-      liftIO $ pure tau---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqps.f>-laqps ::-   Int {- ^ m -} ->-   Int {- ^ offset -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray Int CInt {- ^ jpvt -} ->-   Int {- ^ kb -} ->-   IOCArray Int Double {- ^ vn1 -} ->-   IOCArray Int Double {- ^ vn2 -} ->-   IOCArray Int (Complex Double) {- ^ auxv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->-   IO (Int, CArray Int (Complex Double))-laqps m offset a jpvt kb vn1 vn2 auxv f = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt-   vn1Dim0 <- Call.sizes1 <$> getBounds vn1-   vn2Dim0 <- Call.sizes1 <$> getBounds vn2-   auxvDim0 <- Call.sizes1 <$> getBounds auxv-   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f-   let n = aDim0-   let lda = aDim1-   let nb = auxvDim0-   let ldf = fDim1-   Call.assert "laqps: n == jpvtDim0" (n == jpvtDim0)-   Call.assert "laqps: n == vn1Dim0" (n == vn1Dim0)-   Call.assert "laqps: n == vn2Dim0" (n == vn2Dim0)-   Call.assert "laqps: nb == fDim0" (nb == fDim0)-   tau <- Call.newArray1 kb-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      offsetPtr <- Call.cint offset-      nbPtr <- Call.cint nb-      kbPtr <- Call.alloca-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      jpvtPtr <- Call.ioarray jpvt-      tauPtr <- Call.array tau-      vn1Ptr <- Call.ioarray vn1-      vn2Ptr <- Call.ioarray vn2-      auxvPtr <- Call.ioarray auxv-      fPtr <- Call.ioarray f-      ldfPtr <- Call.cint ldf-      liftIO $ FFI.laqps mPtr nPtr offsetPtr nbPtr kbPtr aPtr ldaPtr jpvtPtr tauPtr vn1Ptr vn2Ptr auxvPtr fPtr ldfPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek kbPtr)-         <*> pure tau---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr0.f>-laqr0 ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ ilo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   Int {- ^ ihiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ workSize -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-laqr0 wantt wantz ilo h iloz ihiz z workSize lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ihi = zDim0-   let ldz = zDim1-   w <- Call.newArray1 n-   work <- Call.newArray1 workSize-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.array w-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.laqr0 wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr1.f>-laqr1 ::-   CArray (Int,Int) (Complex Double) {- ^ h -} ->-   Complex Double {- ^ s1 -} ->-   Complex Double {- ^ s2 -} ->-   IO (CArray Int (Complex Double))-laqr1 h s1 s2 = do-   let (hDim0,hDim1) = Call.sizes2 $ bounds h-   let n = hDim0-   let ldh = hDim1-   v <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      hPtr <- Call.array h-      ldhPtr <- Call.cint ldh-      s1Ptr <- Call.complexDouble s1-      s2Ptr <- Call.complexDouble s2-      vPtr <- Call.array v-      liftIO $ FFI.laqr1 nPtr hPtr ldhPtr s1Ptr s2Ptr vPtr-      liftIO $ pure v---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr2.f>-laqr2 ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ ktop -} ->-   Int {- ^ kbot -} ->-   Int {- ^ nw -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   Int {- ^ ihiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ ldv -} ->-   Int {- ^ nh -} ->-   Int {- ^ ldt -} ->-   Int {- ^ nv -} ->-   Int {- ^ ldwv -} ->-   Int {- ^ lwork -} ->-   IO (Int, Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))-laqr2 wantt wantz ktop kbot nw h iloz ihiz z ldv nh ldt nv ldwv lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ldz = zDim1-   Call.assert "laqr2: n == zDim0" (n == zDim0)-   sh <- Call.newArray1 kbot-   v <- Call.newArray2 nw ldv-   t <- Call.newArray2 nw ldt-   wv <- Call.newArray2 nw ldwv-   work <- Call.newArray1 lwork-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      ktopPtr <- Call.cint ktop-      kbotPtr <- Call.cint kbot-      nwPtr <- Call.cint nw-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      nsPtr <- Call.alloca-      ndPtr <- Call.alloca-      shPtr <- Call.array sh-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      nhPtr <- Call.cint nh-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      nvPtr <- Call.cint nv-      wvPtr <- Call.array wv-      ldwvPtr <- Call.cint ldwv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      liftIO $ FFI.laqr2 wanttPtr wantzPtr nPtr ktopPtr kbotPtr nwPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr nsPtr ndPtr shPtr vPtr ldvPtr nhPtr tPtr ldtPtr nvPtr wvPtr ldwvPtr workPtr lworkPtr-      liftIO $ pure (,,,,,)-         <*> fmap fromIntegral (peek nsPtr)-         <*> fmap fromIntegral (peek ndPtr)-         <*> pure sh-         <*> pure v-         <*> pure t-         <*> pure wv---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr3.f>-laqr3 ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ ktop -} ->-   Int {- ^ kbot -} ->-   Int {- ^ nw -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   Int {- ^ ihiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ ldv -} ->-   Int {- ^ nh -} ->-   Int {- ^ ldt -} ->-   Int {- ^ nv -} ->-   Int {- ^ ldwv -} ->-   Int {- ^ lwork -} ->-   IO (Int, Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))-laqr3 wantt wantz ktop kbot nw h iloz ihiz z ldv nh ldt nv ldwv lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ldz = zDim1-   Call.assert "laqr3: n == zDim0" (n == zDim0)-   sh <- Call.newArray1 kbot-   v <- Call.newArray2 nw ldv-   t <- Call.newArray2 nw ldt-   wv <- Call.newArray2 nw ldwv-   work <- Call.newArray1 lwork-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      ktopPtr <- Call.cint ktop-      kbotPtr <- Call.cint kbot-      nwPtr <- Call.cint nw-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      nsPtr <- Call.alloca-      ndPtr <- Call.alloca-      shPtr <- Call.array sh-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      nhPtr <- Call.cint nh-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      nvPtr <- Call.cint nv-      wvPtr <- Call.array wv-      ldwvPtr <- Call.cint ldwv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      liftIO $ FFI.laqr3 wanttPtr wantzPtr nPtr ktopPtr kbotPtr nwPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr nsPtr ndPtr shPtr vPtr ldvPtr nhPtr tPtr ldtPtr nvPtr wvPtr ldwvPtr workPtr lworkPtr-      liftIO $ pure (,,,,,)-         <*> fmap fromIntegral (peek nsPtr)-         <*> fmap fromIntegral (peek ndPtr)-         <*> pure sh-         <*> pure v-         <*> pure t-         <*> pure wv---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr4.f>-laqr4 ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ ilo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   Int {- ^ ihiz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ workSize -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-laqr4 wantt wantz ilo h iloz ihiz z workSize lwork = do-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = hDim0-   let ldh = hDim1-   let ihi = zDim0-   let ldz = zDim1-   w <- Call.newArray1 n-   work <- Call.newArray1 workSize-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      wPtr <- Call.array w-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.laqr4 wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr5.f>-laqr5 ::-   Bool {- ^ wantt -} ->-   Bool {- ^ wantz -} ->-   Int {- ^ kacc22 -} ->-   Int {- ^ ktop -} ->-   Int {- ^ kbot -} ->-   IOCArray Int (Complex Double) {- ^ s -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->-   Int {- ^ iloz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ ldv -} ->-   Int {- ^ ldu -} ->-   Int {- ^ nv -} ->-   Int {- ^ ldwv -} ->-   Int {- ^ nh -} ->-   Int {- ^ ldwh -} ->-   IO (CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))-laqr5 wantt wantz kacc22 ktop kbot s h iloz z ldv ldu nv ldwv nh ldwh = do-   sDim0 <- Call.sizes1 <$> getBounds s-   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let nshfts = sDim0-   let n = hDim0-   let ldh = hDim1-   let ihiz = zDim0-   let ldz = zDim1-   v <- Call.newArray2 (nshfts`div`2) ldv-   u <- Call.newArray2 (3*nshfts-3) ldu-   wv <- Call.newArray2 (3*nshfts-3) ldwv-   wh <- Call.newArray2 nh ldwh-   evalContT $ do-      wanttPtr <- Call.bool wantt-      wantzPtr <- Call.bool wantz-      kacc22Ptr <- Call.cint kacc22-      nPtr <- Call.cint n-      ktopPtr <- Call.cint ktop-      kbotPtr <- Call.cint kbot-      nshftsPtr <- Call.cint nshfts-      sPtr <- Call.ioarray s-      hPtr <- Call.ioarray h-      ldhPtr <- Call.cint ldh-      ilozPtr <- Call.cint iloz-      ihizPtr <- Call.cint ihiz-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      uPtr <- Call.array u-      lduPtr <- Call.cint ldu-      nvPtr <- Call.cint nv-      wvPtr <- Call.array wv-      ldwvPtr <- Call.cint ldwv-      nhPtr <- Call.cint nh-      whPtr <- Call.array wh-      ldwhPtr <- Call.cint ldwh-      liftIO $ FFI.laqr5 wanttPtr wantzPtr kacc22Ptr nPtr ktopPtr kbotPtr nshftsPtr sPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr vPtr ldvPtr uPtr lduPtr nvPtr wvPtr ldwvPtr nhPtr whPtr ldwhPtr-      liftIO $ pure (,,,)-         <*> pure v-         <*> pure u-         <*> pure wv-         <*> pure wh---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsb.f>-laqsb ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray Int Double {- ^ s -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqsb uplo kd ab s scond amax = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let sDim0 = Call.sizes1 $ bounds s-   let n = abDim0-   let ldab = abDim1-   Call.assert "laqsb: n == sDim0" (n == sDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqsb uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsp.f>-laqsp ::-   Char {- ^ uplo -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   CArray Int Double {- ^ s -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqsp uplo ap s scond amax = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   let sDim0 = Call.sizes1 $ bounds s-   let n = sDim0-   Call.assert "laqsp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqsp uploPtr nPtr apPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsy.f>-laqsy ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int Double {- ^ s -} ->-   Double {- ^ scond -} ->-   Double {- ^ amax -} ->-   IO (Char)-laqsy uplo a s scond amax = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let sDim0 = Call.sizes1 $ bounds s-   let n = aDim0-   let lda = aDim1-   Call.assert "laqsy: n == sDim0" (n == sDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.double scond-      amaxPtr <- Call.double amax-      equedPtr <- Call.alloca-      liftIO $ FFI.laqsy uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr equedPtr-      liftIO $ fmap castCCharToChar (peek equedPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlar1v.f>-lar1v ::-   Int {- ^ b1 -} ->-   Int {- ^ bn -} ->-   Double {- ^ lambda -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int Double {- ^ l -} ->-   CArray Int Double {- ^ ld -} ->-   CArray Int Double {- ^ lld -} ->-   Double {- ^ pivmin -} ->-   Double {- ^ gaptol -} ->-   IOCArray Int (Complex Double) {- ^ z -} ->-   Bool {- ^ wantnc -} ->-   Int {- ^ r -} ->-   IO (Int, Double, Double, Int, CArray Int CInt, Double, Double, Double)-lar1v b1 bn lambda d l ld lld pivmin gaptol z wantnc r = do-   let dDim0 = Call.sizes1 $ bounds d-   let lDim0 = Call.sizes1 $ bounds l-   let ldDim0 = Call.sizes1 $ bounds ld-   let lldDim0 = Call.sizes1 $ bounds lld-   zDim0 <- Call.sizes1 <$> getBounds z-   let n = dDim0-   Call.assert "lar1v: n-1 == lDim0" (n-1 == lDim0)-   Call.assert "lar1v: n-1 == ldDim0" (n-1 == ldDim0)-   Call.assert "lar1v: n-1 == lldDim0" (n-1 == lldDim0)-   Call.assert "lar1v: n == zDim0" (n == zDim0)-   isuppz <- Call.newArray1 2-   work <- Call.newArray1 (4*n)-   evalContT $ do-      nPtr <- Call.cint n-      b1Ptr <- Call.cint b1-      bnPtr <- Call.cint bn-      lambdaPtr <- Call.double lambda-      dPtr <- Call.array d-      lPtr <- Call.array l-      ldPtr <- Call.array ld-      lldPtr <- Call.array lld-      pivminPtr <- Call.double pivmin-      gaptolPtr <- Call.double gaptol-      zPtr <- Call.ioarray z-      wantncPtr <- Call.bool wantnc-      negcntPtr <- Call.alloca-      ztzPtr <- Call.alloca-      mingmaPtr <- Call.alloca-      rPtr <- Call.cint r-      isuppzPtr <- Call.array isuppz-      nrminvPtr <- Call.alloca-      residPtr <- Call.alloca-      rqcorrPtr <- Call.alloca-      workPtr <- Call.array work-      liftIO $ FFI.lar1v nPtr b1Ptr bnPtr lambdaPtr dPtr lPtr ldPtr lldPtr pivminPtr gaptolPtr zPtr wantncPtr negcntPtr ztzPtr mingmaPtr rPtr isuppzPtr nrminvPtr residPtr rqcorrPtr workPtr-      liftIO $ pure (,,,,,,,)-         <*> fmap fromIntegral (peek negcntPtr)-         <*> peek ztzPtr-         <*> peek mingmaPtr-         <*> fmap fromIntegral (peek rPtr)-         <*> pure isuppz-         <*> peek nrminvPtr-         <*> peek residPtr-         <*> peek rqcorrPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlar2v.f>-lar2v ::-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   IOCArray Int (Complex Double) {- ^ z -} ->-   Int {- ^ incx -} ->-   CArray Int Double {- ^ c -} ->-   CArray Int (Complex Double) {- ^ s -} ->-   Int {- ^ incc -} ->-   IO ()-lar2v n x y z incx c s incc = do-   xDim0 <- Call.sizes1 <$> getBounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   zDim0 <- Call.sizes1 <$> getBounds z-   let cDim0 = Call.sizes1 $ bounds c-   let sDim0 = Call.sizes1 $ bounds s-   Call.assert "lar2v: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)-   Call.assert "lar2v: 1+(n-1)*incx == yDim0" (1+(n-1)*incx == yDim0)-   Call.assert "lar2v: 1+(n-1)*incx == zDim0" (1+(n-1)*incx == zDim0)-   Call.assert "lar2v: 1+(n-1)*incc == cDim0" (1+(n-1)*incc == cDim0)-   Call.assert "lar2v: 1+(n-1)*incc == sDim0" (1+(n-1)*incc == sDim0)-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      yPtr <- Call.ioarray y-      zPtr <- Call.ioarray z-      incxPtr <- Call.cint incx-      cPtr <- Call.array c-      sPtr <- Call.array s-      inccPtr <- Call.cint incc-      liftIO $ FFI.lar2v nPtr xPtr yPtr zPtr incxPtr cPtr sPtr inccPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarcm.f>-larcm ::-   CArray (Int,Int) Double {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldc -} ->-   IO (CArray (Int,Int) (Complex Double))-larcm a b ldc = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let m = aDim0-   let lda = aDim1-   let n = bDim0-   let ldb = bDim1-   c <- Call.newArray2 n ldc-   rwork <- Call.newArray1 (2*m*n)-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.array c-      ldcPtr <- Call.cint ldc-      rworkPtr <- Call.array rwork-      liftIO $ FFI.larcm mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr rworkPtr-      liftIO $ pure c---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarf.f>-larf ::-   Char {- ^ side -} ->-   Int {- ^ m -} ->-   CArray Int (Complex Double) {- ^ v -} ->-   Int {- ^ incv -} ->-   Complex Double {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO ()-larf side m v incv tau c workSize = do-   let vDim0 = Call.sizes1 $ bounds v-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _vSize = vDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      vPtr <- Call.array v-      incvPtr <- Call.cint incv-      tauPtr <- Call.complexDouble tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      liftIO $ FFI.larf sidePtr mPtr nPtr vPtr incvPtr tauPtr cPtr ldcPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfb.f>-larfb ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Char {- ^ direct -} ->-   Char {- ^ storev -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ v -} ->-   CArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ ldwork -} ->-   IO ()-larfb side trans direct storev m v t c ldwork = do-   let (vDim0,vDim1) = Call.sizes2 $ bounds v-   let (tDim0,tDim1) = Call.sizes2 $ bounds t-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _vSize = vDim0-   let ldv = vDim1-   let k = tDim0-   let ldt = tDim1-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray2 k ldwork-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      directPtr <- Call.char direct-      storevPtr <- Call.char storev-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      ldworkPtr <- Call.cint ldwork-      liftIO $ FFI.larfb sidePtr transPtr directPtr storevPtr mPtr nPtr kPtr vPtr ldvPtr tPtr ldtPtr cPtr ldcPtr workPtr ldworkPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfg.f>-larfg ::-   Int {- ^ n -} ->-   Complex Double {- ^ alpha -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IO (Complex Double, Complex Double)-larfg n alpha x incx = do-   xDim0 <- Call.sizes1 <$> getBounds x-   let _xSize = xDim0-   evalContT $ do-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      tauPtr <- Call.alloca-      liftIO $ FFI.larfg nPtr alphaPtr xPtr incxPtr tauPtr-      liftIO $ pure (,)-         <*> peek alphaPtr-         <*> peek tauPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfgp.f>-larfgp ::-   Int {- ^ n -} ->-   Complex Double {- ^ alpha -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IO (Complex Double, Complex Double)-larfgp n alpha x incx = do-   xDim0 <- Call.sizes1 <$> getBounds x-   let _xSize = xDim0-   evalContT $ do-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      tauPtr <- Call.alloca-      liftIO $ FFI.larfgp nPtr alphaPtr xPtr incxPtr tauPtr-      liftIO $ pure (,)-         <*> peek alphaPtr-         <*> peek tauPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarft.f>-larft ::-   Char {- ^ direct -} ->-   Char {- ^ storev -} ->-   Int {- ^ n -} ->-   CArray (Int,Int) (Complex Double) {- ^ v -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ ldt -} ->-   IO (CArray (Int,Int) (Complex Double))-larft direct storev n v tau ldt = do-   let (vDim0,vDim1) = Call.sizes2 $ bounds v-   let tauDim0 = Call.sizes1 $ bounds tau-   let _vSize = vDim0-   let ldv = vDim1-   let k = tauDim0-   t <- Call.newArray2 k ldt-   evalContT $ do-      directPtr <- Call.char direct-      storevPtr <- Call.char storev-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      tauPtr <- Call.array tau-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      liftIO $ FFI.larft directPtr storevPtr nPtr kPtr vPtr ldvPtr tauPtr tPtr ldtPtr-      liftIO $ pure t---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfx.f>-larfx ::-   Char {- ^ side -} ->-   Int {- ^ m -} ->-   CArray Int (Complex Double) {- ^ v -} ->-   Complex Double {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO ()-larfx side m v tau c workSize = do-   let vDim0 = Call.sizes1 $ bounds v-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _vSize = vDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      vPtr <- Call.array v-      tauPtr <- Call.complexDouble tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      liftIO $ FFI.larfx sidePtr mPtr nPtr vPtr tauPtr cPtr ldcPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlargv.f>-largv ::-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   Int {- ^ incy -} ->-   Int {- ^ incc -} ->-   IO (CArray Int Double)-largv n x incx y incy incc = do-   xDim0 <- Call.sizes1 <$> getBounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   Call.assert "largv: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)-   Call.assert "largv: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)-   c <- Call.newArray1 (1+(n-1)*incc)-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      yPtr <- Call.ioarray y-      incyPtr <- Call.cint incy-      cPtr <- Call.array c-      inccPtr <- Call.cint incc-      liftIO $ FFI.largv nPtr xPtr incxPtr yPtr incyPtr cPtr inccPtr-      liftIO $ pure c---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarnv.f>-larnv ::-   Int {- ^ idist -} ->-   IOCArray Int CInt {- ^ iseed -} ->-   Int {- ^ n -} ->-   IO (CArray Int (Complex Double))-larnv idist iseed n = do-   iseedDim0 <- Call.sizes1 <$> getBounds iseed-   Call.assert "larnv: 4 == iseedDim0" (4 == iseedDim0)-   x <- Call.newArray1 n-   evalContT $ do-      idistPtr <- Call.cint idist-      iseedPtr <- Call.ioarray iseed-      nPtr <- Call.cint n-      xPtr <- Call.array x-      liftIO $ FFI.larnv idistPtr iseedPtr nPtr xPtr-      liftIO $ pure x---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarrv.f>-larrv ::-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ l -} ->-   Double {- ^ pivmin -} ->-   CArray Int CInt {- ^ isplit -} ->-   Int {- ^ m -} ->-   Int {- ^ dol -} ->-   Int {- ^ dou -} ->-   Double {- ^ minrgp -} ->-   Double {- ^ rtol1 -} ->-   Double {- ^ rtol2 -} ->-   IOCArray Int Double {- ^ w -} ->-   IOCArray Int Double {- ^ werr -} ->-   IOCArray Int Double {- ^ wgap -} ->-   CArray Int CInt {- ^ iblock -} ->-   CArray Int CInt {- ^ indexw -} ->-   CArray Int Double {- ^ gers -} ->-   Int {- ^ ldz -} ->-   IO (CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-larrv vl vu d l pivmin isplit m dol dou minrgp rtol1 rtol2 w werr wgap iblock indexw gers ldz = do-   dDim0 <- Call.sizes1 <$> getBounds d-   lDim0 <- Call.sizes1 <$> getBounds l-   let isplitDim0 = Call.sizes1 $ bounds isplit-   wDim0 <- Call.sizes1 <$> getBounds w-   werrDim0 <- Call.sizes1 <$> getBounds werr-   wgapDim0 <- Call.sizes1 <$> getBounds wgap-   let iblockDim0 = Call.sizes1 $ bounds iblock-   let indexwDim0 = Call.sizes1 $ bounds indexw-   let gersDim0 = Call.sizes1 $ bounds gers-   let n = dDim0-   Call.assert "larrv: n == lDim0" (n == lDim0)-   Call.assert "larrv: n == isplitDim0" (n == isplitDim0)-   Call.assert "larrv: n == wDim0" (n == wDim0)-   Call.assert "larrv: n == werrDim0" (n == werrDim0)-   Call.assert "larrv: n == wgapDim0" (n == wgapDim0)-   Call.assert "larrv: n == iblockDim0" (n == iblockDim0)-   Call.assert "larrv: n == indexwDim0" (n == indexwDim0)-   Call.assert "larrv: 2*n == gersDim0" (2*n == gersDim0)-   z <- Call.newArray2 (maximum[1,m]) ldz-   isuppz <- Call.newArray1 (2*maximum[1,m])-   work <- Call.newArray1 (12*n)-   iwork <- Call.newArray1 (7*n)-   evalContT $ do-      nPtr <- Call.cint n-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      dPtr <- Call.ioarray d-      lPtr <- Call.ioarray l-      pivminPtr <- Call.double pivmin-      isplitPtr <- Call.array isplit-      mPtr <- Call.cint m-      dolPtr <- Call.cint dol-      douPtr <- Call.cint dou-      minrgpPtr <- Call.double minrgp-      rtol1Ptr <- Call.double rtol1-      rtol2Ptr <- Call.double rtol2-      wPtr <- Call.ioarray w-      werrPtr <- Call.ioarray werr-      wgapPtr <- Call.ioarray wgap-      iblockPtr <- Call.array iblock-      indexwPtr <- Call.array indexw-      gersPtr <- Call.array gers-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      isuppzPtr <- Call.array isuppz-      workPtr <- Call.array work-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.larrv nPtr vlPtr vuPtr dPtr lPtr pivminPtr isplitPtr mPtr dolPtr douPtr minrgpPtr rtol1Ptr rtol2Ptr wPtr werrPtr wgapPtr iblockPtr indexwPtr gersPtr zPtr ldzPtr isuppzPtr workPtr iworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure z-         <*> pure isuppz-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlartg.f>-lartg ::-   Complex Double {- ^ f -} ->-   Complex Double {- ^ g -} ->-   IO (Double, Complex Double, Complex Double)-lartg f g = do-   evalContT $ do-      fPtr <- Call.complexDouble f-      gPtr <- Call.complexDouble g-      csPtr <- Call.alloca-      snPtr <- Call.alloca-      rPtr <- Call.alloca-      liftIO $ FFI.lartg fPtr gPtr csPtr snPtr rPtr-      liftIO $ pure (,,)-         <*> peek csPtr-         <*> peek snPtr-         <*> peek rPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlartv.f>-lartv ::-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   Int {- ^ incy -} ->-   CArray Int Double {- ^ c -} ->-   CArray Int (Complex Double) {- ^ s -} ->-   Int {- ^ incc -} ->-   IO ()-lartv n x incx y incy c s incc = do-   xDim0 <- Call.sizes1 <$> getBounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   let cDim0 = Call.sizes1 $ bounds c-   let sDim0 = Call.sizes1 $ bounds s-   Call.assert "lartv: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)-   Call.assert "lartv: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)-   Call.assert "lartv: 1+(n-1)*incc == cDim0" (1+(n-1)*incc == cDim0)-   Call.assert "lartv: 1+(n-1)*incc == sDim0" (1+(n-1)*incc == sDim0)-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.ioarray x-      incxPtr <- Call.cint incx-      yPtr <- Call.ioarray y-      incyPtr <- Call.cint incy-      cPtr <- Call.array c-      sPtr <- Call.array s-      inccPtr <- Call.cint incc-      liftIO $ FFI.lartv nPtr xPtr incxPtr yPtr incyPtr cPtr sPtr inccPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarz.f>-larz ::-   Char {- ^ side -} ->-   Int {- ^ m -} ->-   Int {- ^ l -} ->-   CArray Int (Complex Double) {- ^ v -} ->-   Int {- ^ incv -} ->-   Complex Double {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO ()-larz side m l v incv tau c workSize = do-   let vDim0 = Call.sizes1 $ bounds v-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let n = cDim0-   let ldc = cDim1-   Call.assert "larz: 1+(l-1)*abs(incv) == vDim0" (1+(l-1)*abs(incv) == vDim0)-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      lPtr <- Call.cint l-      vPtr <- Call.array v-      incvPtr <- Call.cint incv-      tauPtr <- Call.complexDouble tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      liftIO $ FFI.larz sidePtr mPtr nPtr lPtr vPtr incvPtr tauPtr cPtr ldcPtr workPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarzb.f>-larzb ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Char {- ^ direct -} ->-   Char {- ^ storev -} ->-   Int {- ^ m -} ->-   Int {- ^ l -} ->-   CArray (Int,Int) (Complex Double) {- ^ v -} ->-   CArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ ldwork -} ->-   IO ()-larzb side trans direct storev m l v t c ldwork = do-   let (vDim0,vDim1) = Call.sizes2 $ bounds v-   let (tDim0,tDim1) = Call.sizes2 $ bounds t-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _nv = vDim0-   let ldv = vDim1-   let k = tDim0-   let ldt = tDim1-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray2 k ldwork-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      directPtr <- Call.char direct-      storevPtr <- Call.char storev-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      lPtr <- Call.cint l-      vPtr <- Call.array v-      ldvPtr <- Call.cint ldv-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      ldworkPtr <- Call.cint ldwork-      liftIO $ FFI.larzb sidePtr transPtr directPtr storevPtr mPtr nPtr kPtr lPtr vPtr ldvPtr tPtr ldtPtr cPtr ldcPtr workPtr ldworkPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarzt.f>-larzt ::-   Char {- ^ direct -} ->-   Char {- ^ storev -} ->-   Int {- ^ n -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ ldt -} ->-   IO (CArray (Int,Int) (Complex Double))-larzt direct storev n v tau ldt = do-   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v-   let tauDim0 = Call.sizes1 $ bounds tau-   let _vSize = vDim0-   let ldv = vDim1-   let k = tauDim0-   t <- Call.newArray2 k ldt-   evalContT $ do-      directPtr <- Call.char direct-      storevPtr <- Call.char storev-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      vPtr <- Call.ioarray v-      ldvPtr <- Call.cint ldv-      tauPtr <- Call.array tau-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      liftIO $ FFI.larzt directPtr storevPtr nPtr kPtr vPtr ldvPtr tauPtr tPtr ldtPtr-      liftIO $ pure t---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlascl.f>-lascl ::-   Char {- ^ type_ -} ->-   Int {- ^ kl -} ->-   Int {- ^ ku -} ->-   Double {- ^ cfrom -} ->-   Double {- ^ cto -} ->-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-lascl type_ kl ku cfrom cto m a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      type_Ptr <- Call.char type_-      klPtr <- Call.cint kl-      kuPtr <- Call.cint ku-      cfromPtr <- Call.double cfrom-      ctoPtr <- Call.double cto-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.lascl type_Ptr klPtr kuPtr cfromPtr ctoPtr mPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaset.f>-laset ::-   Char {- ^ uplo -} ->-   Int {- ^ m -} ->-   Int {- ^ n -} ->-   Complex Double {- ^ alpha -} ->-   Complex Double {- ^ beta -} ->-   Int {- ^ lda -} ->-   IO (CArray (Int,Int) (Complex Double))-laset uplo m n alpha beta lda = do-   a <- Call.newArray2 n lda-   evalContT $ do-      uploPtr <- Call.char uplo-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      betaPtr <- Call.complexDouble beta-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      liftIO $ FFI.laset uploPtr mPtr nPtr alphaPtr betaPtr aPtr ldaPtr-      liftIO $ pure a---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlasr.f>-lasr ::-   Char {- ^ side -} ->-   Char {- ^ pivot -} ->-   Char {- ^ direct -} ->-   Int {- ^ m -} ->-   CArray Int Double {- ^ c -} ->-   CArray Int Double {- ^ s -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO ()-lasr side pivot direct m c s a = do-   let cDim0 = Call.sizes1 $ bounds c-   let sDim0 = Call.sizes1 $ bounds s-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let _cSize = cDim0-   let _sSize = sDim0-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      sidePtr <- Call.char side-      pivotPtr <- Call.char pivot-      directPtr <- Call.char direct-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      cPtr <- Call.array c-      sPtr <- Call.array s-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      liftIO $ FFI.lasr sidePtr pivotPtr directPtr mPtr nPtr cPtr sPtr aPtr ldaPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlassq.f>-lassq ::-   CArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   Double {- ^ scale -} ->-   Double {- ^ sumsq -} ->-   IO (Double, Double)-lassq x incx scale sumsq = do-   let xDim0 = Call.sizes1 $ bounds x-   let n = xDim0-   evalContT $ do-      nPtr <- Call.cint n-      xPtr <- Call.array x-      incxPtr <- Call.cint incx-      scalePtr <- Call.double scale-      sumsqPtr <- Call.double sumsq-      liftIO $ FFI.lassq nPtr xPtr incxPtr scalePtr sumsqPtr-      liftIO $ pure (,)-         <*> peek scalePtr-         <*> peek sumsqPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaswp.f>-laswp ::-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ k1 -} ->-   Int {- ^ k2 -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ incx -} ->-   IO ()-laswp a k1 k2 ipiv incx = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "laswp: k1+(k2-k1)*abs(incx) == ipivDim0" (k1+(k2-k1)*abs(incx) == ipivDim0)-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      k1Ptr <- Call.cint k1-      k2Ptr <- Call.cint k2-      ipivPtr <- Call.array ipiv-      incxPtr <- Call.cint incx-      liftIO $ FFI.laswp nPtr aPtr ldaPtr k1Ptr k2Ptr ipivPtr incxPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlasyf.f>-lasyf ::-   Char {- ^ uplo -} ->-   Int {- ^ nb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldw -} ->-   IO (Int, CArray Int CInt, CArray (Int,Int) (Complex Double), Int)-lasyf uplo nb a ldw = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   w <- Call.newArray2 nb ldw-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nbPtr <- Call.cint nb-      kbPtr <- Call.alloca-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      wPtr <- Call.array w-      ldwPtr <- Call.cint ldw-      infoPtr <- Call.alloca-      liftIO $ FFI.lasyf uploPtr nPtr nbPtr kbPtr aPtr ldaPtr ipivPtr wPtr ldwPtr infoPtr-      liftIO $ pure (,,,)-         <*> fmap fromIntegral (peek kbPtr)-         <*> pure ipiv-         <*> pure w-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlat2c.f>-lat2c ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldsa -} ->-   IO (CArray (Int,Int) (Complex Float), Int)-lat2c uplo a ldsa = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   sa <- Call.newArray2 n ldsa-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      saPtr <- Call.array sa-      ldsaPtr <- Call.cint ldsa-      infoPtr <- Call.alloca-      liftIO $ FFI.lat2c uploPtr nPtr aPtr ldaPtr saPtr ldsaPtr infoPtr-      liftIO $ pure (,)-         <*> pure sa-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatbs.f>-latbs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Char {- ^ normin -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   IOCArray Int Double {- ^ cnorm -} ->-   IO (Double, Int)-latbs uplo trans diag normin kd ab x cnorm = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   xDim0 <- Call.sizes1 <$> getBounds x-   cnormDim0 <- Call.sizes1 <$> getBounds cnorm-   let n = abDim0-   let ldab = abDim1-   Call.assert "latbs: n == xDim0" (n == xDim0)-   Call.assert "latbs: n == cnormDim0" (n == cnormDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      norminPtr <- Call.char normin-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      xPtr <- Call.ioarray x-      scalePtr <- Call.alloca-      cnormPtr <- Call.ioarray cnorm-      infoPtr <- Call.alloca-      liftIO $ FFI.latbs uploPtr transPtr diagPtr norminPtr nPtr kdPtr abPtr ldabPtr xPtr scalePtr cnormPtr infoPtr-      liftIO $ pure (,)-         <*> peek scalePtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatdf.f>-latdf ::-   Int {- ^ ijob -} ->-   CArray (Int,Int) (Complex Double) {- ^ z -} ->-   IOCArray Int (Complex Double) {- ^ rhs -} ->-   Double {- ^ rdsum -} ->-   Double {- ^ rdscal -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray Int CInt {- ^ jpiv -} ->-   IO (Double, Double)-latdf ijob z rhs rdsum rdscal ipiv jpiv = do-   let (zDim0,zDim1) = Call.sizes2 $ bounds z-   rhsDim0 <- Call.sizes1 <$> getBounds rhs-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let jpivDim0 = Call.sizes1 $ bounds jpiv-   let n = zDim0-   let ldz = zDim1-   Call.assert "latdf: n == rhsDim0" (n == rhsDim0)-   Call.assert "latdf: n == ipivDim0" (n == ipivDim0)-   Call.assert "latdf: n == jpivDim0" (n == jpivDim0)-   evalContT $ do-      ijobPtr <- Call.cint ijob-      nPtr <- Call.cint n-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      rhsPtr <- Call.ioarray rhs-      rdsumPtr <- Call.double rdsum-      rdscalPtr <- Call.double rdscal-      ipivPtr <- Call.array ipiv-      jpivPtr <- Call.array jpiv-      liftIO $ FFI.latdf ijobPtr nPtr zPtr ldzPtr rhsPtr rdsumPtr rdscalPtr ipivPtr jpivPtr-      liftIO $ pure (,)-         <*> peek rdsumPtr-         <*> peek rdscalPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatps.f>-latps ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Char {- ^ normin -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   IOCArray Int Double {- ^ cnorm -} ->-   IO (Double, Int)-latps uplo trans diag normin ap x cnorm = do-   let apDim0 = Call.sizes1 $ bounds ap-   xDim0 <- Call.sizes1 <$> getBounds x-   cnormDim0 <- Call.sizes1 <$> getBounds cnorm-   let n = xDim0-   Call.assert "latps: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "latps: n == cnormDim0" (n == cnormDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      norminPtr <- Call.char normin-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      xPtr <- Call.ioarray x-      scalePtr <- Call.alloca-      cnormPtr <- Call.ioarray cnorm-      infoPtr <- Call.alloca-      liftIO $ FFI.latps uploPtr transPtr diagPtr norminPtr nPtr apPtr xPtr scalePtr cnormPtr infoPtr-      liftIO $ pure (,)-         <*> peek scalePtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrd.f>-latrd ::-   Char {- ^ uplo -} ->-   Int {- ^ nb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ ldw -} ->-   IO (CArray Int Double, CArray Int (Complex Double), CArray (Int,Int) (Complex Double))-latrd uplo nb a ldw = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   e <- Call.newArray1 (n-1)-   tau <- Call.newArray1 (n-1)-   w <- Call.newArray2 nb ldw-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nbPtr <- Call.cint nb-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ePtr <- Call.array e-      tauPtr <- Call.array tau-      wPtr <- Call.array w-      ldwPtr <- Call.cint ldw-      liftIO $ FFI.latrd uploPtr nPtr nbPtr aPtr ldaPtr ePtr tauPtr wPtr ldwPtr-      liftIO $ pure (,,)-         <*> pure e-         <*> pure tau-         <*> pure w---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrs.f>-latrs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Char {- ^ normin -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray Int (Complex Double) {- ^ x -} ->-   IOCArray Int Double {- ^ cnorm -} ->-   IO (Double, Int)-latrs uplo trans diag normin a x cnorm = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   xDim0 <- Call.sizes1 <$> getBounds x-   cnormDim0 <- Call.sizes1 <$> getBounds cnorm-   let n = aDim0-   let lda = aDim1-   Call.assert "latrs: n == xDim0" (n == xDim0)-   Call.assert "latrs: n == cnormDim0" (n == cnormDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      norminPtr <- Call.char normin-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      xPtr <- Call.ioarray x-      scalePtr <- Call.alloca-      cnormPtr <- Call.ioarray cnorm-      infoPtr <- Call.alloca-      liftIO $ FFI.latrs uploPtr transPtr diagPtr norminPtr nPtr aPtr ldaPtr xPtr scalePtr cnormPtr infoPtr-      liftIO $ pure (,)-         <*> peek scalePtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrz.f>-latrz ::-   Int {- ^ m -} ->-   Int {- ^ l -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double))-latrz m l a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 m-   work <- Call.newArray1 m-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      lPtr <- Call.cint l-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      liftIO $ FFI.latrz mPtr nPtr lPtr aPtr ldaPtr tauPtr workPtr-      liftIO $ pure tau---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlauu2.f>-lauu2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-lauu2 uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.lauu2 uploPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlauum.f>-lauum ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-lauum uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.lauum uploPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbcon.f>-pbcon ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-pbcon uplo kd ab anorm = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.pbcon uploPtr nPtr kdPtr abPtr ldabPtr anormPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbequ.f>-pbequ ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (CArray Int Double, Double, Double, Int)-pbequ uplo kd ab = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   s <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.pbequ uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbrfs.f>-pbrfs ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray (Int,Int) (Complex Double) {- ^ afb -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-pbrfs uplo kd ab afb b x = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let (afbDim0,afbDim1) = Call.sizes2 $ bounds afb-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = abDim0-   let ldab = abDim1-   let ldafb = afbDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "pbrfs: n == afbDim0" (n == afbDim0)-   Call.assert "pbrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      afbPtr <- Call.array afb-      ldafbPtr <- Call.cint ldafb-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.pbrfs uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbstf.f>-pbstf ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (Int)-pbstf uplo kd ab = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      infoPtr <- Call.alloca-      liftIO $ FFI.pbstf uploPtr nPtr kdPtr abPtr ldabPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbsv.f>-pbsv ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-pbsv uplo kd ab b = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.pbsv uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbsvx.f>-pbsvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ afb -} ->-   Char {- ^ equed -} ->-   IOCArray Int Double {- ^ s -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-pbsvx fact uplo kd ab afb equed s b ldx = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   (afbDim0,afbDim1) <- Call.sizes2 <$> getBounds afb-   sDim0 <- Call.sizes1 <$> getBounds s-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let ldafb = afbDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "pbsvx: n == afbDim0" (n == afbDim0)-   Call.assert "pbsvx: n == sDim0" (n == sDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      afbPtr <- Call.ioarray afb-      ldafbPtr <- Call.cint ldafb-      equedPtr <- Call.char equed-      sPtr <- Call.ioarray s-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.pbsvx factPtr uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap castCCharToChar (peek equedPtr)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtf2.f>-pbtf2 ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (Int)-pbtf2 uplo kd ab = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      infoPtr <- Call.alloca-      liftIO $ FFI.pbtf2 uploPtr nPtr kdPtr abPtr ldabPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtrf.f>-pbtrf ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (Int)-pbtrf uplo kd ab = do-   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab-   let n = abDim0-   let ldab = abDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.ioarray ab-      ldabPtr <- Call.cint ldab-      infoPtr <- Call.alloca-      liftIO $ FFI.pbtrf uploPtr nPtr kdPtr abPtr ldabPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtrs.f>-pbtrs ::-   Char {- ^ uplo -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-pbtrs uplo kd ab b = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.pbtrs uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftrf.f>-pftrf ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ a -} ->-   IO (Int)-pftrf transr uplo n a = do-   aDim0 <- Call.sizes1 <$> getBounds a-   Call.assert "pftrf: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      infoPtr <- Call.alloca-      liftIO $ FFI.pftrf transrPtr uploPtr nPtr aPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftri.f>-pftri ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ a -} ->-   IO (Int)-pftri transr uplo n a = do-   aDim0 <- Call.sizes1 <$> getBounds a-   Call.assert "pftri: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      infoPtr <- Call.alloca-      liftIO $ FFI.pftri transrPtr uploPtr nPtr aPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftrs.f>-pftrs ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-pftrs transr uplo n a b = do-   let aDim0 = Call.sizes1 $ bounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "pftrs: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.pftrs transrPtr uploPtr nPtr nrhsPtr aPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpocon.f>-pocon ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-pocon uplo a anorm = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.pocon uploPtr nPtr aPtr ldaPtr anormPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpoequ.f>-poequ ::-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, Double, Double, Int)-poequ a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.poequ nPtr aPtr ldaPtr sPtr scondPtr amaxPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpoequb.f>-poequb ::-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, Double, Double, Int)-poequb a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.poequb nPtr aPtr ldaPtr sPtr scondPtr amaxPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zporfs.f>-porfs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ af -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-porfs uplo a af b x = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (afDim0,afDim1) = Call.sizes2 $ bounds af-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "porfs: n == afDim0" (n == afDim0)-   Call.assert "porfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.array af-      ldafPtr <- Call.cint ldaf-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.porfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zposv.f>-posv ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-posv uplo a b = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.posv uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zposvx.f>-posvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->-   Char {- ^ equed -} ->-   IOCArray Int Double {- ^ s -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-posvx fact uplo a af equed s b ldx = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af-   sDim0 <- Call.sizes1 <$> getBounds s-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "posvx: n == afDim0" (n == afDim0)-   Call.assert "posvx: n == sDim0" (n == sDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      afPtr <- Call.ioarray af-      ldafPtr <- Call.cint ldaf-      equedPtr <- Call.char equed-      sPtr <- Call.ioarray s-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.posvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap castCCharToChar (peek equedPtr)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotf2.f>-potf2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-potf2 uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.potf2 uploPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotrf.f>-potrf ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-potrf uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.potrf uploPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotri.f>-potri ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-potri uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.potri uploPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotrs.f>-potrs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-potrs uplo a b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.potrs uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppcon.f>-ppcon ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-ppcon uplo n ap anorm = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "ppcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ppcon uploPtr nPtr apPtr anormPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppequ.f>-ppequ ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IO (CArray Int Double, Double, Double, Int)-ppequ uplo n ap = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "ppequ: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   s <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.ppequ uploPtr nPtr apPtr sPtr scondPtr amaxPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpprfs.f>-pprfs ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ afp -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-pprfs uplo n ap afp b x = do-   let apDim0 = Call.sizes1 $ bounds ap-   let afpDim0 = Call.sizes1 $ bounds afp-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "pprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "pprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   Call.assert "pprfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      afpPtr <- Call.array afp-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.pprfs uploPtr nPtr nrhsPtr apPtr afpPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppsv.f>-ppsv ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-ppsv uplo n ap b = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "ppsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.ioarray ap-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.ppsv uploPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppsvx.f>-ppsvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ afp -} ->-   Char {- ^ equed -} ->-   IOCArray Int Double {- ^ s -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-ppsvx fact uplo ap afp equed s b ldx = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   afpDim0 <- Call.sizes1 <$> getBounds afp-   sDim0 <- Call.sizes1 <$> getBounds s-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = sDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "ppsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "ppsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.ioarray ap-      afpPtr <- Call.ioarray afp-      equedPtr <- Call.char equed-      sPtr <- Call.ioarray s-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ppsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap castCCharToChar (peek equedPtr)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptrf.f>-pptrf ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (Int)-pptrf uplo n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "pptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      infoPtr <- Call.alloca-      liftIO $ FFI.pptrf uploPtr nPtr apPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptri.f>-pptri ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (Int)-pptri uplo n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "pptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      infoPtr <- Call.alloca-      liftIO $ FFI.pptri uploPtr nPtr apPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptrs.f>-pptrs ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-pptrs uplo n ap b = do-   let apDim0 = Call.sizes1 $ bounds ap-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "pptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.pptrs uploPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpstf2.f>-pstf2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ tol -} ->-   IO (CArray Int CInt, Int, Int)-pstf2 uplo a tol = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   piv <- Call.newArray1 n-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      pivPtr <- Call.array piv-      rankPtr <- Call.alloca-      tolPtr <- Call.double tol-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.pstf2 uploPtr nPtr aPtr ldaPtr pivPtr rankPtr tolPtr workPtr infoPtr-      liftIO $ pure (,,)-         <*> pure piv-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpstrf.f>-pstrf ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Double {- ^ tol -} ->-   IO (CArray Int CInt, Int, Int)-pstrf uplo a tol = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   piv <- Call.newArray1 n-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      pivPtr <- Call.array piv-      rankPtr <- Call.alloca-      tolPtr <- Call.double tol-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.pstrf uploPtr nPtr aPtr ldaPtr pivPtr rankPtr tolPtr workPtr infoPtr-      liftIO $ pure (,,)-         <*> pure piv-         <*> fmap fromIntegral (peek rankPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptcon.f>-ptcon ::-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-ptcon d e anorm = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   let n = dDim0-   Call.assert "ptcon: n-1 == eDim0" (n-1 == eDim0)-   rwork <- Call.newArray1 n-   evalContT $ do-      nPtr <- Call.cint n-      dPtr <- Call.array d-      ePtr <- Call.array e-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ptcon nPtr dPtr ePtr anormPtr rcondPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpteqr.f>-pteqr ::-   Char {- ^ compz -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   IO (Int)-pteqr compz d e z = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = dDim0-   let ldz = zDim1-   Call.assert "pteqr: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "pteqr: n == zDim0" (n == zDim0)-   work <- Call.newArray1 (4*n)-   evalContT $ do-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.pteqr compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptrfs.f>-ptrfs ::-   Char {- ^ uplo -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   CArray Int Double {- ^ df -} ->-   CArray Int (Complex Double) {- ^ ef -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-ptrfs uplo d e df ef b x = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   let dfDim0 = Call.sizes1 $ bounds df-   let efDim0 = Call.sizes1 $ bounds ef-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "ptrfs: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "ptrfs: n == dfDim0" (n == dfDim0)-   Call.assert "ptrfs: n-1 == efDim0" (n-1 == efDim0)-   Call.assert "ptrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 n-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.array d-      ePtr <- Call.array e-      dfPtr <- Call.array df-      efPtr <- Call.array ef-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ptrfs uploPtr nPtr nrhsPtr dPtr ePtr dfPtr efPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptsv.f>-ptsv ::-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int (Complex Double) {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-ptsv d e b = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "ptsv: n-1 == eDim0" (n-1 == eDim0)-   evalContT $ do-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.ptsv nPtr nrhsPtr dPtr ePtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptsvx.f>-ptsvx ::-   Char {- ^ fact -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   IOCArray Int Double {- ^ df -} ->-   IOCArray Int (Complex Double) {- ^ ef -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-ptsvx fact d e df ef b ldx = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   dfDim0 <- Call.sizes1 <$> getBounds df-   efDim0 <- Call.sizes1 <$> getBounds ef-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "ptsvx: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "ptsvx: n == dfDim0" (n == dfDim0)-   Call.assert "ptsvx: n-1 == efDim0" (n-1 == efDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 n-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.array d-      ePtr <- Call.array e-      dfPtr <- Call.ioarray df-      efPtr <- Call.ioarray ef-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ptsvx factPtr nPtr nrhsPtr dPtr ePtr dfPtr efPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpttrf.f>-pttrf ::-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int (Complex Double) {- ^ e -} ->-   IO (Int)-pttrf d e = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   let n = dDim0-   Call.assert "pttrf: n-1 == eDim0" (n-1 == eDim0)-   evalContT $ do-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      infoPtr <- Call.alloca-      liftIO $ FFI.pttrf nPtr dPtr ePtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpttrs.f>-pttrs ::-   Char {- ^ uplo -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-pttrs uplo d e b = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "pttrs: n-1 == eDim0" (n-1 == eDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.array d-      ePtr <- Call.array e-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.pttrs uploPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptts2.f>-ptts2 ::-   Int {- ^ iuplo -} ->-   CArray Int Double {- ^ d -} ->-   CArray Int (Complex Double) {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO ()-ptts2 iuplo d e b = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = dDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "ptts2: n-1 == eDim0" (n-1 == eDim0)-   evalContT $ do-      iuploPtr <- Call.cint iuplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      dPtr <- Call.array d-      ePtr <- Call.array e-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.ptts2 iuploPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zrot.f>-rot ::-   IOCArray Int (Complex Double) {- ^ cx -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ cy -} ->-   Int {- ^ incy -} ->-   Double {- ^ c -} ->-   Complex Double {- ^ s -} ->-   IO ()-rot cx incx cy incy c s = do-   cxDim0 <- Call.sizes1 <$> getBounds cx-   cyDim0 <- Call.sizes1 <$> getBounds cy-   let n = cxDim0-   Call.assert "rot: n == cyDim0" (n == cyDim0)-   evalContT $ do-      nPtr <- Call.cint n-      cxPtr <- Call.ioarray cx-      incxPtr <- Call.cint incx-      cyPtr <- Call.ioarray cy-      incyPtr <- Call.cint incy-      cPtr <- Call.double c-      sPtr <- Call.complexDouble s-      liftIO $ FFI.rot nPtr cxPtr incxPtr cyPtr incyPtr cPtr sPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zdrscl.f>-rscl ::-   Int {- ^ n -} ->-   Double {- ^ sa -} ->-   IOCArray Int (Complex Double) {- ^ sx -} ->-   Int {- ^ incx -} ->-   IO ()-rscl n sa sx incx = do-   sxDim0 <- Call.sizes1 <$> getBounds sx-   let _sxSize = sxDim0-   evalContT $ do-      nPtr <- Call.cint n-      saPtr <- Call.double sa-      sxPtr <- Call.ioarray sx-      incxPtr <- Call.cint incx-      liftIO $ FFI.rscl nPtr saPtr sxPtr incxPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspcon.f>-spcon ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-spcon uplo ap ipiv anorm = do-   let apDim0 = Call.sizes1 $ bounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = ipivDim0-   Call.assert "spcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.spcon uploPtr nPtr apPtr ipivPtr anormPtr rcondPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspmv.f>-spmv ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   Complex Double {- ^ alpha -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   Complex Double {- ^ beta -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   Int {- ^ incy -} ->-   IO ()-spmv uplo n alpha ap x incx beta y incy = do-   let apDim0 = Call.sizes1 $ bounds ap-   let xDim0 = Call.sizes1 $ bounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   let _apSize = apDim0-   let _xSize = xDim0-   let _ySize = yDim0-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      apPtr <- Call.array ap-      xPtr <- Call.array x-      incxPtr <- Call.cint incx-      betaPtr <- Call.complexDouble beta-      yPtr <- Call.ioarray y-      incyPtr <- Call.cint incy-      liftIO $ FFI.spmv uploPtr nPtr alphaPtr apPtr xPtr incxPtr betaPtr yPtr incyPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspr.f>-spr ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   Complex Double {- ^ alpha -} ->-   CArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO ()-spr uplo n alpha x incx ap = do-   let xDim0 = Call.sizes1 $ bounds x-   apDim0 <- Call.sizes1 <$> getBounds ap-   let _xSize = xDim0-   let _apSize = apDim0-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      xPtr <- Call.array x-      incxPtr <- Call.cint incx-      apPtr <- Call.ioarray ap-      liftIO $ FFI.spr uploPtr nPtr alphaPtr xPtr incxPtr apPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsprfs.f>-sprfs ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ afp -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-sprfs uplo ap afp ipiv b x = do-   let apDim0 = Call.sizes1 $ bounds ap-   let afpDim0 = Call.sizes1 $ bounds afp-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "sprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "sprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   Call.assert "sprfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      afpPtr <- Call.array afp-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.sprfs uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspsv.f>-spsv ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (CArray Int CInt, Int)-spsv uplo n ap b = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "spsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.spsv uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspsvx.f>-spsvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IOCArray Int (Complex Double) {- ^ afp -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-spsvx fact uplo ap afp ipiv b ldx = do-   let apDim0 = Call.sizes1 $ bounds ap-   afpDim0 <- Call.sizes1 <$> getBounds afp-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "spsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "spsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      afpPtr <- Call.ioarray afp-      ipivPtr <- Call.ioarray ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.spsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptrf.f>-sptrf ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (CArray Int CInt, Int)-sptrf uplo n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "sptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.sptrf uploPtr nPtr apPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptri.f>-sptri ::-   Char {- ^ uplo -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IO (Int)-sptri uplo ap ipiv = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = ipivDim0-   Call.assert "sptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.sptri uploPtr nPtr apPtr ipivPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptrs.f>-sptrs ::-   Char {- ^ uplo -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-sptrs uplo ap ipiv b = do-   let apDim0 = Call.sizes1 $ bounds ap-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = ipivDim0-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "sptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.sptrs uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstedc.f>-stedc ::-   Char {- ^ compz -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ lwork -} ->-   Int {- ^ lrwork -} ->-   Int {- ^ liwork -} ->-   IO (Int)-stedc compz d e z lwork lrwork liwork = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = dDim0-   let ldz = zDim1-   Call.assert "stedc: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "stedc: n == zDim0" (n == zDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 (maximum[1,lrwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.stedc compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstegr.f>-stegr ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Double {- ^ abstol -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   Int {- ^ lwork -} ->-   Int {- ^ liwork -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-stegr jobz range d e vl vu il iu abstol m ldz lwork liwork = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   let n = dDim0-   Call.assert "stegr: n == eDim0" (n == eDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   isuppz <- Call.newArray1 (2*maximum[1,m])-   work <- Call.newArray1 lwork-   iwork <- Call.newArray1 liwork-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      abstolPtr <- Call.double abstol-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      isuppzPtr <- Call.array isuppz-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.stegr jobzPtr rangePtr nPtr dPtr ePtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr isuppzPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure isuppz-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstein.f>-stein ::-   CArray Int Double {- ^ d -} ->-   CArray Int Double {- ^ e -} ->-   Int {- ^ m -} ->-   CArray Int Double {- ^ w -} ->-   CArray Int CInt {- ^ iblock -} ->-   CArray Int CInt {- ^ isplit -} ->-   Int {- ^ ldz -} ->-   IO (CArray (Int,Int) (Complex Double), CArray Int CInt, Int)-stein d e m w iblock isplit ldz = do-   let dDim0 = Call.sizes1 $ bounds d-   let eDim0 = Call.sizes1 $ bounds e-   let wDim0 = Call.sizes1 $ bounds w-   let iblockDim0 = Call.sizes1 $ bounds iblock-   let isplitDim0 = Call.sizes1 $ bounds isplit-   let n = dDim0-   Call.assert "stein: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "stein: n == wDim0" (n == wDim0)-   Call.assert "stein: n == iblockDim0" (n == iblockDim0)-   Call.assert "stein: n == isplitDim0" (n == isplitDim0)-   z <- Call.newArray2 m ldz-   work <- Call.newArray1 (5*n)-   iwork <- Call.newArray1 n-   ifail <- Call.newArray1 m-   evalContT $ do-      nPtr <- Call.cint n-      dPtr <- Call.array d-      ePtr <- Call.array e-      mPtr <- Call.cint m-      wPtr <- Call.array w-      iblockPtr <- Call.array iblock-      isplitPtr <- Call.array isplit-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      iworkPtr <- Call.array iwork-      ifailPtr <- Call.array ifail-      infoPtr <- Call.alloca-      liftIO $ FFI.stein nPtr dPtr ePtr mPtr wPtr iblockPtr isplitPtr zPtr ldzPtr workPtr iworkPtr ifailPtr infoPtr-      liftIO $ pure (,,)-         <*> pure z-         <*> pure ifail-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstemr.f>-stemr ::-   Char {- ^ jobz -} ->-   Char {- ^ range -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   Double {- ^ vl -} ->-   Double {- ^ vu -} ->-   Int {- ^ il -} ->-   Int {- ^ iu -} ->-   Int {- ^ m -} ->-   Int {- ^ ldz -} ->-   Int {- ^ nzc -} ->-   Bool {- ^ tryrac -} ->-   Int {- ^ lwork -} ->-   Int {- ^ liwork -} ->-   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Bool, Int)-stemr jobz range d e vl vu il iu m ldz nzc tryrac lwork liwork = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   let n = dDim0-   Call.assert "stemr: n == eDim0" (n == eDim0)-   w <- Call.newArray1 n-   z <- Call.newArray2 (maximum[1,m]) ldz-   isuppz <- Call.newArray1 (2*maximum[1,m])-   work <- Call.newArray1 lwork-   iwork <- Call.newArray1 liwork-   evalContT $ do-      jobzPtr <- Call.char jobz-      rangePtr <- Call.char range-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      vlPtr <- Call.double vl-      vuPtr <- Call.double vu-      ilPtr <- Call.cint il-      iuPtr <- Call.cint iu-      mPtr <- Call.alloca-      wPtr <- Call.array w-      zPtr <- Call.array z-      ldzPtr <- Call.cint ldz-      nzcPtr <- Call.cint nzc-      isuppzPtr <- Call.array isuppz-      tryracPtr <- Call.bool tryrac-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.stemr jobzPtr rangePtr nPtr dPtr ePtr vlPtr vuPtr ilPtr iuPtr mPtr wPtr zPtr ldzPtr nzcPtr isuppzPtr tryracPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> fmap fromIntegral (peek mPtr)-         <*> pure w-         <*> pure z-         <*> pure isuppz-         <*> peek tryracPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsteqr.f>-steqr ::-   Char {- ^ compz -} ->-   IOCArray Int Double {- ^ d -} ->-   IOCArray Int Double {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   IO (Int)-steqr compz d e z = do-   dDim0 <- Call.sizes1 <$> getBounds d-   eDim0 <- Call.sizes1 <$> getBounds e-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = dDim0-   let ldz = zDim1-   Call.assert "steqr: n-1 == eDim0" (n-1 == eDim0)-   Call.assert "steqr: n == zDim0" (n == zDim0)-   work <- Call.newArray1 (maximum[1,2*n-2])-   evalContT $ do-      compzPtr <- Call.char compz-      nPtr <- Call.cint n-      dPtr <- Call.ioarray d-      ePtr <- Call.ioarray e-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.steqr compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dzsum1.f>-sum1 ::-   CArray Int (Complex Double) {- ^ cx -} ->-   Int {- ^ incx -} ->-   IO Double-sum1 cx incx = do-   let cxDim0 = Call.sizes1 $ bounds cx-   let n = cxDim0-   evalContT $ do-      nPtr <- Call.cint n-      cxPtr <- Call.array cx-      incxPtr <- Call.cint incx-      liftIO $ FFI.sum1 nPtr cxPtr incxPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsycon.f>-sycon ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Double {- ^ anorm -} ->-   IO (Double, Int)-sycon uplo a ipiv anorm = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "sycon: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      anormPtr <- Call.double anorm-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.sycon uploPtr nPtr aPtr ldaPtr ipivPtr anormPtr rcondPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyconv.f>-syconv ::-   Char {- ^ uplo -} ->-   Char {- ^ way -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IO (CArray Int (Complex Double), Int)-syconv uplo way a ipiv = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "syconv: n == ipivDim0" (n == ipivDim0)-   e <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      wayPtr <- Call.char way-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      ePtr <- Call.array e-      infoPtr <- Call.alloca-      liftIO $ FFI.syconv uploPtr wayPtr nPtr aPtr ldaPtr ipivPtr ePtr infoPtr-      liftIO $ pure (,)-         <*> pure e-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyequb.f>-syequb ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int Double, Double, Double, Int)-syequb uplo a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   s <- Call.newArray1 n-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      sPtr <- Call.array s-      scondPtr <- Call.alloca-      amaxPtr <- Call.alloca-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.syequb uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr workPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> peek scondPtr-         <*> peek amaxPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsymv.f>-symv ::-   Char {- ^ uplo -} ->-   Complex Double {- ^ alpha -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   Complex Double {- ^ beta -} ->-   IOCArray Int (Complex Double) {- ^ y -} ->-   Int {- ^ incy -} ->-   IO ()-symv uplo alpha a x incx beta y incy = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let xDim0 = Call.sizes1 $ bounds x-   yDim0 <- Call.sizes1 <$> getBounds y-   let n = aDim0-   let lda = aDim1-   let _xSize = xDim0-   let _ySize = yDim0-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      xPtr <- Call.array x-      incxPtr <- Call.cint incx-      betaPtr <- Call.complexDouble beta-      yPtr <- Call.ioarray y-      incyPtr <- Call.cint incy-      liftIO $ FFI.symv uploPtr nPtr alphaPtr aPtr ldaPtr xPtr incxPtr betaPtr yPtr incyPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyr.f>-syr ::-   Char {- ^ uplo -} ->-   Complex Double {- ^ alpha -} ->-   CArray Int (Complex Double) {- ^ x -} ->-   Int {- ^ incx -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO ()-syr uplo alpha x incx a = do-   let xDim0 = Call.sizes1 $ bounds x-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let _xSize = xDim0-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      xPtr <- Call.array x-      incxPtr <- Call.cint incx-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      liftIO $ FFI.syr uploPtr nPtr alphaPtr xPtr incxPtr aPtr ldaPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyrfs.f>-syrfs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ af -} ->-   CArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-syrfs uplo a af ipiv b x = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (afDim0,afDim1) = Call.sizes2 $ bounds af-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "syrfs: n == afDim0" (n == afDim0)-   Call.assert "syrfs: n == ipivDim0" (n == ipivDim0)-   Call.assert "syrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.array af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.array ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.ioarray x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.syrfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsysv.f>-sysv ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int CInt, Int)-sysv uplo a b lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   ipiv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.sysv uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsysvx.f>-sysvx ::-   Char {- ^ fact -} ->-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->-   IOCArray Int CInt {- ^ ipiv -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   Int {- ^ ldx -} ->-   Int {- ^ lwork -} ->-   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)-sysvx fact uplo a af ipiv b ldx lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af-   ipivDim0 <- Call.sizes1 <$> getBounds ipiv-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let n = aDim0-   let lda = aDim1-   let ldaf = afDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "sysvx: n == afDim0" (n == afDim0)-   Call.assert "sysvx: n == ipivDim0" (n == ipivDim0)-   x <- Call.newArray2 nrhs ldx-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 n-   evalContT $ do-      factPtr <- Call.char fact-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      afPtr <- Call.ioarray af-      ldafPtr <- Call.cint ldaf-      ipivPtr <- Call.ioarray ipiv-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      rcondPtr <- Call.alloca-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.sysvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr lworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure x-         <*> peek rcondPtr-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyswapr.f>-syswapr ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ i1 -} ->-   Int {- ^ i2 -} ->-   IO ()-syswapr uplo a i1 i2 = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      i1Ptr <- Call.cint i1-      i2Ptr <- Call.cint i2-      liftIO $ FFI.syswapr uploPtr nPtr aPtr ldaPtr i1Ptr i2Ptr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytf2.f>-sytf2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int CInt, Int)-sytf2 uplo a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      infoPtr <- Call.alloca-      liftIO $ FFI.sytf2 uploPtr nPtr aPtr ldaPtr ipivPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrf.f>-sytrf ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int CInt, Int)-sytrf uplo a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   ipiv <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.sytrf uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure ipiv-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri.f>-sytri ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IO (Int)-sytri uplo a ipiv = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "sytri: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (2*n)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.sytri uploPtr nPtr aPtr ldaPtr ipivPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri2.f>-sytri2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ nb -} ->-   Int {- ^ lwork -} ->-   IO (Int)-sytri2 uplo a ipiv nb lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "sytri2: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 (n+nb+1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.sytri2 uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri2x.f>-sytri2x ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   Int {- ^ nb -} ->-   IO (Int)-sytri2x uplo a ipiv nb = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   let n = aDim0-   let lda = aDim1-   Call.assert "sytri2x: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray2 (nb+3) (n+nb+1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      workPtr <- Call.array work-      nbPtr <- Call.cint nb-      infoPtr <- Call.alloca-      liftIO $ FFI.sytri2x uploPtr nPtr aPtr ldaPtr ipivPtr workPtr nbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrs.f>-sytrs ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-sytrs uplo a ipiv b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "sytrs: n == ipivDim0" (n == ipivDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.sytrs uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrs2.f>-sytrs2 ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int CInt {- ^ ipiv -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-sytrs2 uplo a ipiv b = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let ipivDim0 = Call.sizes1 $ bounds ipiv-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "sytrs2: n == ipivDim0" (n == ipivDim0)-   work <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      ipivPtr <- Call.array ipiv-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.sytrs2 uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbcon.f>-tbcon ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IO (Double, Int)-tbcon norm uplo diag kd ab = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let n = abDim0-   let ldab = abDim1-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tbcon normPtr uploPtr diagPtr nPtr kdPtr abPtr ldabPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbrfs.f>-tbrfs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   CArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-tbrfs uplo trans diag kd ab b x = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let (xDim0,xDim1) = Call.sizes2 $ bounds x-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "tbrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tbrfs uploPtr transPtr diagPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbtrs.f>-tbtrs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Int {- ^ kd -} ->-   CArray (Int,Int) (Complex Double) {- ^ ab -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-tbtrs uplo trans diag kd ab b = do-   let (abDim0,abDim1) = Call.sizes2 $ bounds ab-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = abDim0-   let ldab = abDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      kdPtr <- Call.cint kd-      nrhsPtr <- Call.cint nrhs-      abPtr <- Call.array ab-      ldabPtr <- Call.cint ldab-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.tbtrs uploPtr transPtr diagPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfsm.f>-tfsm ::-   Char {- ^ transr -} ->-   Char {- ^ side -} ->-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Int {- ^ m -} ->-   Complex Double {- ^ alpha -} ->-   CArray Int (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO ()-tfsm transr side uplo trans diag m alpha a b = do-   let aDim0 = Call.sizes1 $ bounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = bDim0-   let ldb = bDim1-   Call.assert "tfsm: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      sidePtr <- Call.char side-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      alphaPtr <- Call.complexDouble alpha-      aPtr <- Call.array a-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      liftIO $ FFI.tfsm transrPtr sidePtr uploPtr transPtr diagPtr mPtr nPtr alphaPtr aPtr bPtr ldbPtr---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztftri.f>-tftri ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ a -} ->-   IO (Int)-tftri transr uplo diag n a = do-   aDim0 <- Call.sizes1 <$> getBounds a-   Call.assert "tftri: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      infoPtr <- Call.alloca-      liftIO $ FFI.tftri transrPtr uploPtr diagPtr nPtr aPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfttp.f>-tfttp ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ arf -} ->-   IO (CArray Int (Complex Double), Int)-tfttp transr uplo n arf = do-   let arfDim0 = Call.sizes1 $ bounds arf-   Call.assert "tfttp: n*(n+1)`div`2 == arfDim0" (n*(n+1)`div`2 == arfDim0)-   ap <- Call.newArray1 (n*(n+1)`div`2)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      arfPtr <- Call.array arf-      apPtr <- Call.array ap-      infoPtr <- Call.alloca-      liftIO $ FFI.tfttp transrPtr uploPtr nPtr arfPtr apPtr infoPtr-      liftIO $ pure (,)-         <*> pure ap-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfttr.f>-tfttr ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ arf -} ->-   Int {- ^ lda -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-tfttr transr uplo n arf lda = do-   let arfDim0 = Call.sizes1 $ bounds arf-   Call.assert "tfttr: n*(n+1)`div`2 == arfDim0" (n*(n+1)`div`2 == arfDim0)-   a <- Call.newArray2 n lda-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      arfPtr <- Call.array arf-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.tfttr transrPtr uploPtr nPtr arfPtr aPtr ldaPtr infoPtr-      liftIO $ pure (,)-         <*> pure a-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgevc.f>-tgevc ::-   Char {- ^ side -} ->-   Char {- ^ howmny -} ->-   CArray Int Bool {- ^ select -} ->-   CArray (Int,Int) (Complex Double) {- ^ s -} ->-   CArray (Int,Int) (Complex Double) {- ^ p -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->-   IO (Int, Int)-tgevc side howmny select s p vl vr = do-   let selectDim0 = Call.sizes1 $ bounds select-   let (sDim0,sDim1) = Call.sizes2 $ bounds s-   let (pDim0,pDim1) = Call.sizes2 $ bounds p-   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl-   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr-   let n = selectDim0-   let lds = sDim1-   let ldp = pDim1-   let mm = vlDim0-   let ldvl = vlDim1-   let ldvr = vrDim1-   Call.assert "tgevc: n == sDim0" (n == sDim0)-   Call.assert "tgevc: n == pDim0" (n == pDim0)-   Call.assert "tgevc: mm == vrDim0" (mm == vrDim0)-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 (2*n)-   evalContT $ do-      sidePtr <- Call.char side-      howmnyPtr <- Call.char howmny-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      sPtr <- Call.array s-      ldsPtr <- Call.cint lds-      pPtr <- Call.array p-      ldpPtr <- Call.cint ldp-      vlPtr <- Call.ioarray vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.ioarray vr-      ldvrPtr <- Call.cint ldvr-      mmPtr <- Call.cint mm-      mPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tgevc sidePtr howmnyPtr selectPtr nPtr sPtr ldsPtr pPtr ldpPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek mPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgex2.f>-tgex2 ::-   Bool {- ^ wantq -} ->-   Bool {- ^ wantz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ j1 -} ->-   IO (Int)-tgex2 wantq wantz a b q z j1 = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let _aSize = aDim0-   let lda = aDim1-   let _bSize = bDim0-   let ldb = bDim1-   let n = qDim0-   let ldq = qDim1-   let ldz = zDim1-   Call.assert "tgex2: n == zDim0" (n == zDim0)-   evalContT $ do-      wantqPtr <- Call.bool wantq-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      j1Ptr <- Call.cint j1-      infoPtr <- Call.alloca-      liftIO $ FFI.tgex2 wantqPtr wantzPtr nPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr j1Ptr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgexc.f>-tgexc ::-   Bool {- ^ wantq -} ->-   Bool {- ^ wantz -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ ifst -} ->-   Int {- ^ ilst -} ->-   IO (Int, Int)-tgexc wantq wantz a b q z ifst ilst = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   let ldq = qDim1-   let ldz = zDim1-   Call.assert "tgexc: n == bDim0" (n == bDim0)-   Call.assert "tgexc: n == qDim0" (n == qDim0)-   Call.assert "tgexc: n == zDim0" (n == zDim0)-   evalContT $ do-      wantqPtr <- Call.bool wantq-      wantzPtr <- Call.bool wantz-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      ifstPtr <- Call.cint ifst-      ilstPtr <- Call.cint ilst-      infoPtr <- Call.alloca-      liftIO $ FFI.tgexc wantqPtr wantzPtr nPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr ifstPtr ilstPtr infoPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek ilstPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsen.f>-tgsen ::-   Int {- ^ ijob -} ->-   Bool {- ^ wantq -} ->-   Bool {- ^ wantz -} ->-   CArray Int Bool {- ^ select -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->-   Int {- ^ lwork -} ->-   Int {- ^ liwork -} ->-   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int, Double, Double, CArray Int Double, Int)-tgsen ijob wantq wantz select a b q z lwork liwork = do-   let selectDim0 = Call.sizes1 $ bounds select-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z-   let n = selectDim0-   let lda = aDim1-   let ldb = bDim1-   let ldq = qDim1-   let ldz = zDim1-   Call.assert "tgsen: n == aDim0" (n == aDim0)-   Call.assert "tgsen: n == bDim0" (n == bDim0)-   Call.assert "tgsen: n == qDim0" (n == qDim0)-   Call.assert "tgsen: n == zDim0" (n == zDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   dif <- Call.newArray1 2-   work <- Call.newArray1 (maximum[1,lwork])-   iwork <- Call.newArray1 (maximum[1,liwork])-   evalContT $ do-      ijobPtr <- Call.cint ijob-      wantqPtr <- Call.bool wantq-      wantzPtr <- Call.bool wantz-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      zPtr <- Call.ioarray z-      ldzPtr <- Call.cint ldz-      mPtr <- Call.alloca-      plPtr <- Call.alloca-      prPtr <- Call.alloca-      difPtr <- Call.array dif-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      iworkPtr <- Call.array iwork-      liworkPtr <- Call.cint liwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tgsen ijobPtr wantqPtr wantzPtr selectPtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr qPtr ldqPtr zPtr ldzPtr mPtr plPtr prPtr difPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr-      liftIO $ pure (,,,,,,)-         <*> pure alpha-         <*> pure beta-         <*> fmap fromIntegral (peek mPtr)-         <*> peek plPtr-         <*> peek prPtr-         <*> pure dif-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsja.f>-tgsja ::-   Char {- ^ jobu -} ->-   Char {- ^ jobv -} ->-   Char {- ^ jobq -} ->-   Int {- ^ k -} ->-   Int {- ^ l -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   Double {- ^ tola -} ->-   Double {- ^ tolb -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ u -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   IO (CArray Int Double, CArray Int Double, Int, Int)-tgsja jobu jobv jobq k l a b tola tolb u v q = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   (uDim0,uDim1) <- Call.sizes2 <$> getBounds u-   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   let n = aDim0-   let lda = aDim1-   let ldb = bDim1-   let m = uDim0-   let ldu = uDim1-   let p = vDim0-   let ldv = vDim1-   let ldq = qDim1-   Call.assert "tgsja: n == bDim0" (n == bDim0)-   Call.assert "tgsja: n == qDim0" (n == qDim0)-   alpha <- Call.newArray1 n-   beta <- Call.newArray1 n-   work <- Call.newArray1 (2*n)-   evalContT $ do-      jobuPtr <- Call.char jobu-      jobvPtr <- Call.char jobv-      jobqPtr <- Call.char jobq-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      lPtr <- Call.cint l-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      tolaPtr <- Call.double tola-      tolbPtr <- Call.double tolb-      alphaPtr <- Call.array alpha-      betaPtr <- Call.array beta-      uPtr <- Call.ioarray u-      lduPtr <- Call.cint ldu-      vPtr <- Call.ioarray v-      ldvPtr <- Call.cint ldv-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      workPtr <- Call.array work-      ncyclePtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.tgsja jobuPtr jobvPtr jobqPtr mPtr pPtr nPtr kPtr lPtr aPtr ldaPtr bPtr ldbPtr tolaPtr tolbPtr alphaPtr betaPtr uPtr lduPtr vPtr ldvPtr qPtr ldqPtr workPtr ncyclePtr infoPtr-      liftIO $ pure (,,,)-         <*> pure alpha-         <*> pure beta-         <*> fmap fromIntegral (peek ncyclePtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsna.f>-tgsna ::-   Char {- ^ job -} ->-   Char {- ^ howmny -} ->-   CArray Int Bool {- ^ select -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   CArray (Int,Int) (Complex Double) {- ^ vl -} ->-   CArray (Int,Int) (Complex Double) {- ^ vr -} ->-   Int {- ^ mm -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, CArray Int Double, Int, Int)-tgsna job howmny select a b vl vr mm lwork = do-   let selectDim0 = Call.sizes1 $ bounds select-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let (vlDim0,vlDim1) = Call.sizes2 $ bounds vl-   let (vrDim0,vrDim1) = Call.sizes2 $ bounds vr-   let n = selectDim0-   let lda = aDim1-   let ldb = bDim1-   let m = vlDim0-   let ldvl = vlDim1-   let ldvr = vrDim1-   Call.assert "tgsna: n == aDim0" (n == aDim0)-   Call.assert "tgsna: n == bDim0" (n == bDim0)-   Call.assert "tgsna: m == vrDim0" (m == vrDim0)-   s <- Call.newArray1 mm-   dif <- Call.newArray1 mm-   work <- Call.newArray1 (maximum[1,lwork])-   iwork <- Call.newArray1 (n+2)-   evalContT $ do-      jobPtr <- Call.char job-      howmnyPtr <- Call.char howmny-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      sPtr <- Call.array s-      difPtr <- Call.array dif-      mmPtr <- Call.cint mm-      mPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tgsna jobPtr howmnyPtr selectPtr nPtr aPtr ldaPtr bPtr ldbPtr vlPtr ldvlPtr vrPtr ldvrPtr sPtr difPtr mmPtr mPtr workPtr lworkPtr iworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> pure dif-         <*> fmap fromIntegral (peek mPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsy2.f>-tgsy2 ::-   Char {- ^ trans -} ->-   Int {- ^ ijob -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   CArray (Int,Int) (Complex Double) {- ^ d -} ->-   CArray (Int,Int) (Complex Double) {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->-   Double {- ^ rdsum -} ->-   Double {- ^ rdscal -} ->-   IO (Double, Double, Double, Int)-tgsy2 trans ijob a b c d e f rdsum rdscal = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let (dDim0,dDim1) = Call.sizes2 $ bounds d-   let (eDim0,eDim1) = Call.sizes2 $ bounds e-   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f-   let m = aDim0-   let lda = aDim1-   let n = bDim0-   let ldb = bDim1-   let ldc = cDim1-   let ldd = dDim1-   let lde = eDim1-   let ldf = fDim1-   Call.assert "tgsy2: n == cDim0" (n == cDim0)-   Call.assert "tgsy2: m == dDim0" (m == dDim0)-   Call.assert "tgsy2: n == eDim0" (n == eDim0)-   Call.assert "tgsy2: n == fDim0" (n == fDim0)-   evalContT $ do-      transPtr <- Call.char trans-      ijobPtr <- Call.cint ijob-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      dPtr <- Call.array d-      lddPtr <- Call.cint ldd-      ePtr <- Call.array e-      ldePtr <- Call.cint lde-      fPtr <- Call.ioarray f-      ldfPtr <- Call.cint ldf-      scalePtr <- Call.alloca-      rdsumPtr <- Call.double rdsum-      rdscalPtr <- Call.double rdscal-      infoPtr <- Call.alloca-      liftIO $ FFI.tgsy2 transPtr ijobPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr dPtr lddPtr ePtr ldePtr fPtr ldfPtr scalePtr rdsumPtr rdscalPtr infoPtr-      liftIO $ pure (,,,)-         <*> peek scalePtr-         <*> peek rdsumPtr-         <*> peek rdscalPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsyl.f>-tgsyl ::-   Char {- ^ trans -} ->-   Int {- ^ ijob -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   CArray (Int,Int) (Complex Double) {- ^ d -} ->-   CArray (Int,Int) (Complex Double) {- ^ e -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->-   Int {- ^ lwork -} ->-   IO (Double, Double, Int)-tgsyl trans ijob a b c d e f lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let (dDim0,dDim1) = Call.sizes2 $ bounds d-   let (eDim0,eDim1) = Call.sizes2 $ bounds e-   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f-   let m = aDim0-   let lda = aDim1-   let n = bDim0-   let ldb = bDim1-   let ldc = cDim1-   let ldd = dDim1-   let lde = eDim1-   let ldf = fDim1-   Call.assert "tgsyl: n == cDim0" (n == cDim0)-   Call.assert "tgsyl: m == dDim0" (m == dDim0)-   Call.assert "tgsyl: n == eDim0" (n == eDim0)-   Call.assert "tgsyl: n == fDim0" (n == fDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   iwork <- Call.newArray1 (m+n+2)-   evalContT $ do-      transPtr <- Call.char trans-      ijobPtr <- Call.cint ijob-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      dPtr <- Call.array d-      lddPtr <- Call.cint ldd-      ePtr <- Call.array e-      ldePtr <- Call.cint lde-      fPtr <- Call.ioarray f-      ldfPtr <- Call.cint ldf-      scalePtr <- Call.alloca-      difPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tgsyl transPtr ijobPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr dPtr lddPtr ePtr ldePtr fPtr ldfPtr scalePtr difPtr workPtr lworkPtr iworkPtr infoPtr-      liftIO $ pure (,,)-         <*> peek scalePtr-         <*> peek difPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpcon.f>-tpcon ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IO (Double, Int)-tpcon norm uplo diag n ap = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "tpcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tpcon normPtr uploPtr diagPtr nPtr apPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztprfs.f>-tprfs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   CArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-tprfs uplo trans diag n ap b x = do-   let apDim0 = Call.sizes1 $ bounds ap-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let (xDim0,xDim1) = Call.sizes2 $ bounds x-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "tprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "tprfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tprfs uploPtr transPtr diagPtr nPtr nrhsPtr apPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztptri.f>-tptri ::-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   IOCArray Int (Complex Double) {- ^ ap -} ->-   IO (Int)-tptri uplo diag n ap = do-   apDim0 <- Call.sizes1 <$> getBounds ap-   Call.assert "tptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      apPtr <- Call.ioarray ap-      infoPtr <- Call.alloca-      liftIO $ FFI.tptri uploPtr diagPtr nPtr apPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztptrs.f>-tptrs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-tptrs uplo trans diag n ap b = do-   let apDim0 = Call.sizes1 $ bounds ap-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let nrhs = bDim0-   let ldb = bDim1-   Call.assert "tptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      apPtr <- Call.array ap-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.tptrs uploPtr transPtr diagPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpttf.f>-tpttf ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   IO (CArray Int (Complex Double), Int)-tpttf transr uplo n ap = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "tpttf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   arf <- Call.newArray1 (n*(n+1)`div`2)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      arfPtr <- Call.array arf-      infoPtr <- Call.alloca-      liftIO $ FFI.tpttf transrPtr uploPtr nPtr apPtr arfPtr infoPtr-      liftIO $ pure (,)-         <*> pure arf-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpttr.f>-tpttr ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   Int {- ^ lda -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-tpttr uplo n ap lda = do-   let apDim0 = Call.sizes1 $ bounds ap-   Call.assert "tpttr: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   a <- Call.newArray2 n lda-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.tpttr uploPtr nPtr apPtr aPtr ldaPtr infoPtr-      liftIO $ pure (,)-         <*> pure a-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrcon.f>-trcon ::-   Char {- ^ norm -} ->-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Double, Int)-trcon norm uplo diag a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      normPtr <- Call.char norm-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      rcondPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.trcon normPtr uploPtr diagPtr nPtr aPtr ldaPtr rcondPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> peek rcondPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrevc.f>-trevc ::-   Char {- ^ side -} ->-   Char {- ^ howmny -} ->-   CArray Int Bool {- ^ select -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->-   IO (Int, Int)-trevc side howmny select t vl vr = do-   let selectDim0 = Call.sizes1 $ bounds select-   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t-   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl-   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr-   let n = selectDim0-   let ldt = tDim1-   let mm = vlDim0-   let ldvl = vlDim1-   let ldvr = vrDim1-   Call.assert "trevc: n == tDim0" (n == tDim0)-   Call.assert "trevc: mm == vrDim0" (mm == vrDim0)-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      sidePtr <- Call.char side-      howmnyPtr <- Call.char howmny-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      tPtr <- Call.ioarray t-      ldtPtr <- Call.cint ldt-      vlPtr <- Call.ioarray vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.ioarray vr-      ldvrPtr <- Call.cint ldvr-      mmPtr <- Call.cint mm-      mPtr <- Call.alloca-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.trevc sidePtr howmnyPtr selectPtr nPtr tPtr ldtPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,)-         <*> fmap fromIntegral (peek mPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrexc.f>-trexc ::-   Char {- ^ compq -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   Int {- ^ ifst -} ->-   Int {- ^ ilst -} ->-   IO (Int)-trexc compq t q ifst ilst = do-   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   let n = tDim0-   let ldt = tDim1-   let ldq = qDim1-   Call.assert "trexc: n == qDim0" (n == qDim0)-   evalContT $ do-      compqPtr <- Call.char compq-      nPtr <- Call.cint n-      tPtr <- Call.ioarray t-      ldtPtr <- Call.cint ldt-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      ifstPtr <- Call.cint ifst-      ilstPtr <- Call.cint ilst-      infoPtr <- Call.alloca-      liftIO $ FFI.trexc compqPtr nPtr tPtr ldtPtr qPtr ldqPtr ifstPtr ilstPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrrfs.f>-trrfs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   CArray (Int,Int) (Complex Double) {- ^ x -} ->-   IO (CArray Int Double, CArray Int Double, Int)-trrfs uplo trans diag a b x = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   let (xDim0,xDim1) = Call.sizes2 $ bounds x-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   let ldx = xDim1-   Call.assert "trrfs: nrhs == xDim0" (nrhs == xDim0)-   ferr <- Call.newArray1 nrhs-   berr <- Call.newArray1 nrhs-   work <- Call.newArray1 (2*n)-   rwork <- Call.newArray1 n-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      xPtr <- Call.array x-      ldxPtr <- Call.cint ldx-      ferrPtr <- Call.array ferr-      berrPtr <- Call.array berr-      workPtr <- Call.array work-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.trrfs uploPtr transPtr diagPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr-      liftIO $ pure (,,)-         <*> pure ferr-         <*> pure berr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsen.f>-trsen ::-   Char {- ^ job -} ->-   Char {- ^ compq -} ->-   CArray Int Bool {- ^ select -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int, Double, Double, Int)-trsen job compq select t q lwork = do-   let selectDim0 = Call.sizes1 $ bounds select-   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t-   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q-   let n = selectDim0-   let ldt = tDim1-   let ldq = qDim1-   Call.assert "trsen: n == tDim0" (n == tDim0)-   Call.assert "trsen: n == qDim0" (n == qDim0)-   w <- Call.newArray1 n-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      jobPtr <- Call.char job-      compqPtr <- Call.char compq-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      tPtr <- Call.ioarray t-      ldtPtr <- Call.cint ldt-      qPtr <- Call.ioarray q-      ldqPtr <- Call.cint ldq-      wPtr <- Call.array w-      mPtr <- Call.alloca-      sPtr <- Call.alloca-      sepPtr <- Call.alloca-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.trsen jobPtr compqPtr selectPtr nPtr tPtr ldtPtr qPtr ldqPtr wPtr mPtr sPtr sepPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,,,,)-         <*> pure w-         <*> fmap fromIntegral (peek mPtr)-         <*> peek sPtr-         <*> peek sepPtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsna.f>-trsna ::-   Char {- ^ job -} ->-   Char {- ^ howmny -} ->-   CArray Int Bool {- ^ select -} ->-   CArray (Int,Int) (Complex Double) {- ^ t -} ->-   CArray (Int,Int) (Complex Double) {- ^ vl -} ->-   CArray (Int,Int) (Complex Double) {- ^ vr -} ->-   Int {- ^ mm -} ->-   Int {- ^ ldwork -} ->-   IO (CArray Int Double, CArray Int Double, Int, Int)-trsna job howmny select t vl vr mm ldwork = do-   let selectDim0 = Call.sizes1 $ bounds select-   let (tDim0,tDim1) = Call.sizes2 $ bounds t-   let (vlDim0,vlDim1) = Call.sizes2 $ bounds vl-   let (vrDim0,vrDim1) = Call.sizes2 $ bounds vr-   let n = selectDim0-   let ldt = tDim1-   let m = vlDim0-   let ldvl = vlDim1-   let ldvr = vrDim1-   Call.assert "trsna: n == tDim0" (n == tDim0)-   Call.assert "trsna: m == vrDim0" (m == vrDim0)-   s <- Call.newArray1 mm-   sep <- Call.newArray1 mm-   work <- Call.newArray2 (n+6) ldwork-   rwork <- Call.newArray1 n-   evalContT $ do-      jobPtr <- Call.char job-      howmnyPtr <- Call.char howmny-      selectPtr <- Call.array select-      nPtr <- Call.cint n-      tPtr <- Call.array t-      ldtPtr <- Call.cint ldt-      vlPtr <- Call.array vl-      ldvlPtr <- Call.cint ldvl-      vrPtr <- Call.array vr-      ldvrPtr <- Call.cint ldvr-      sPtr <- Call.array s-      sepPtr <- Call.array sep-      mmPtr <- Call.cint mm-      mPtr <- Call.alloca-      workPtr <- Call.array work-      ldworkPtr <- Call.cint ldwork-      rworkPtr <- Call.array rwork-      infoPtr <- Call.alloca-      liftIO $ FFI.trsna jobPtr howmnyPtr selectPtr nPtr tPtr ldtPtr vlPtr ldvlPtr vrPtr ldvrPtr sPtr sepPtr mmPtr mPtr workPtr ldworkPtr rworkPtr infoPtr-      liftIO $ pure (,,,)-         <*> pure s-         <*> pure sep-         <*> fmap fromIntegral (peek mPtr)-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsyl.f>-trsyl ::-   Char {- ^ trana -} ->-   Char {- ^ tranb -} ->-   Int {- ^ isgn -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray (Int,Int) (Complex Double) {- ^ b -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   IO (Double, Int)-trsyl trana tranb isgn a b c = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let (bDim0,bDim1) = Call.sizes2 $ bounds b-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let m = aDim0-   let lda = aDim1-   let n = bDim0-   let ldb = bDim1-   let ldc = cDim1-   Call.assert "trsyl: n == cDim0" (n == cDim0)-   evalContT $ do-      tranaPtr <- Call.char trana-      tranbPtr <- Call.char tranb-      isgnPtr <- Call.cint isgn-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.array b-      ldbPtr <- Call.cint ldb-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      scalePtr <- Call.alloca-      infoPtr <- Call.alloca-      liftIO $ FFI.trsyl tranaPtr tranbPtr isgnPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr scalePtr infoPtr-      liftIO $ pure (,)-         <*> peek scalePtr-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrti2.f>-trti2 ::-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-trti2 uplo diag a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.trti2 uploPtr diagPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrtri.f>-trtri ::-   Char {- ^ uplo -} ->-   Char {- ^ diag -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (Int)-trtri uplo diag a = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      infoPtr <- Call.alloca-      liftIO $ FFI.trtri uploPtr diagPtr nPtr aPtr ldaPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrtrs.f>-trtrs ::-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Char {- ^ diag -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->-   IO (Int)-trtrs uplo trans diag a b = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b-   let n = aDim0-   let lda = aDim1-   let nrhs = bDim0-   let ldb = bDim1-   evalContT $ do-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      diagPtr <- Call.char diag-      nPtr <- Call.cint n-      nrhsPtr <- Call.cint nrhs-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      bPtr <- Call.ioarray b-      ldbPtr <- Call.cint ldb-      infoPtr <- Call.alloca-      liftIO $ FFI.trtrs uploPtr transPtr diagPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrttf.f>-trttf ::-   Char {- ^ transr -} ->-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-trttf transr uplo a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   arf <- Call.newArray1 (n*(n+1)`div`2)-   evalContT $ do-      transrPtr <- Call.char transr-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      arfPtr <- Call.array arf-      infoPtr <- Call.alloca-      liftIO $ FFI.trttf transrPtr uploPtr nPtr aPtr ldaPtr arfPtr infoPtr-      liftIO $ pure (,)-         <*> pure arf-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrttp.f>-trttp ::-   Char {- ^ uplo -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   IO (CArray Int (Complex Double), Int)-trttp uplo a = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let n = aDim0-   let lda = aDim1-   ap <- Call.newArray1 (n*(n+1)`div`2)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      apPtr <- Call.array ap-      infoPtr <- Call.alloca-      liftIO $ FFI.trttp uploPtr nPtr aPtr ldaPtr apPtr infoPtr-      liftIO $ pure (,)-         <*> pure ap-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztzrzf.f>-tzrzf ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int (Complex Double), Int)-tzrzf m a lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let n = aDim0-   let lda = aDim1-   tau <- Call.newArray1 m-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.tzrzf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ pure (,)-         <*> pure tau-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunbdb.f>-unbdb ::-   Char {- ^ trans -} ->-   Char {- ^ signs -} ->-   Int {- ^ m -} ->-   Int {- ^ p -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x11 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x12 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x21 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x22 -} ->-   Int {- ^ lwork -} ->-   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), CArray Int (Complex Double), CArray Int (Complex Double), Int)-unbdb trans signs m p x11 x12 x21 x22 lwork = do-   (x11Dim0,x11Dim1) <- Call.sizes2 <$> getBounds x11-   (x12Dim0,x12Dim1) <- Call.sizes2 <$> getBounds x12-   (x21Dim0,x21Dim1) <- Call.sizes2 <$> getBounds x21-   (x22Dim0,x22Dim1) <- Call.sizes2 <$> getBounds x22-   let q = x11Dim0-   let ldx11 = x11Dim1-   let ldx12 = x12Dim1-   let ldx21 = x21Dim1-   let ldx22 = x22Dim1-   Call.assert "unbdb: m-q == x12Dim0" (m-q == x12Dim0)-   Call.assert "unbdb: q == x21Dim0" (q == x21Dim0)-   Call.assert "unbdb: m-q == x22Dim0" (m-q == x22Dim0)-   theta <- Call.newArray1 q-   phi <- Call.newArray1 (q-1)-   taup1 <- Call.newArray1 p-   taup2 <- Call.newArray1 (m-p)-   tauq1 <- Call.newArray1 q-   tauq2 <- Call.newArray1 (m-q)-   work <- Call.newArray1 lwork-   evalContT $ do-      transPtr <- Call.char trans-      signsPtr <- Call.char signs-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      qPtr <- Call.cint q-      x11Ptr <- Call.ioarray x11-      ldx11Ptr <- Call.cint ldx11-      x12Ptr <- Call.ioarray x12-      ldx12Ptr <- Call.cint ldx12-      x21Ptr <- Call.ioarray x21-      ldx21Ptr <- Call.cint ldx21-      x22Ptr <- Call.ioarray x22-      ldx22Ptr <- Call.cint ldx22-      thetaPtr <- Call.array theta-      phiPtr <- Call.array phi-      taup1Ptr <- Call.array taup1-      taup2Ptr <- Call.array taup2-      tauq1Ptr <- Call.array tauq1-      tauq2Ptr <- Call.array tauq2-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unbdb transPtr signsPtr mPtr pPtr qPtr x11Ptr ldx11Ptr x12Ptr ldx12Ptr x21Ptr ldx21Ptr x22Ptr ldx22Ptr thetaPtr phiPtr taup1Ptr taup2Ptr tauq1Ptr tauq2Ptr workPtr lworkPtr infoPtr-      liftIO $ pure (,,,,,,)-         <*> pure theta-         <*> pure phi-         <*> pure taup1-         <*> pure taup2-         <*> pure tauq1-         <*> pure tauq2-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zuncsd.f>-uncsd ::-   Char {- ^ jobu1 -} ->-   Char {- ^ jobu2 -} ->-   Char {- ^ jobv1t -} ->-   Char {- ^ jobv2t -} ->-   Char {- ^ trans -} ->-   Char {- ^ signs -} ->-   Int {- ^ m -} ->-   Int {- ^ p -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x11 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x12 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x21 -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ x22 -} ->-   Int {- ^ r -} ->-   Int {- ^ ldu1 -} ->-   Int {- ^ ldu2 -} ->-   Int {- ^ ldv1t -} ->-   Int {- ^ ldv2t -} ->-   Int {- ^ lwork -} ->-   Int {- ^ rworkSize -} ->-   Int {- ^ lrwork -} ->-   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)-uncsd jobu1 jobu2 jobv1t jobv2t trans signs m p x11 x12 x21 x22 r ldu1 ldu2 ldv1t ldv2t lwork rworkSize lrwork = do-   (x11Dim0,x11Dim1) <- Call.sizes2 <$> getBounds x11-   (x12Dim0,x12Dim1) <- Call.sizes2 <$> getBounds x12-   (x21Dim0,x21Dim1) <- Call.sizes2 <$> getBounds x21-   (x22Dim0,x22Dim1) <- Call.sizes2 <$> getBounds x22-   let q = x11Dim0-   let ldx11 = x11Dim1-   let ldx12 = x12Dim1-   let ldx21 = x21Dim1-   let ldx22 = x22Dim1-   Call.assert "uncsd: m-q == x12Dim0" (m-q == x12Dim0)-   Call.assert "uncsd: q == x21Dim0" (q == x21Dim0)-   Call.assert "uncsd: m-q == x22Dim0" (m-q == x22Dim0)-   theta <- Call.newArray1 r-   u1 <- Call.newArray2 p ldu1-   u2 <- Call.newArray2 (m-p) ldu2-   v1t <- Call.newArray2 q ldv1t-   v2t <- Call.newArray2 (m-q) ldv2t-   work <- Call.newArray1 (maximum[1,lwork])-   rwork <- Call.newArray1 rworkSize-   iwork <- Call.newArray1 (m-minimum[p,m-p,q,m-q])-   evalContT $ do-      jobu1Ptr <- Call.char jobu1-      jobu2Ptr <- Call.char jobu2-      jobv1tPtr <- Call.char jobv1t-      jobv2tPtr <- Call.char jobv2t-      transPtr <- Call.char trans-      signsPtr <- Call.char signs-      mPtr <- Call.cint m-      pPtr <- Call.cint p-      qPtr <- Call.cint q-      x11Ptr <- Call.ioarray x11-      ldx11Ptr <- Call.cint ldx11-      x12Ptr <- Call.ioarray x12-      ldx12Ptr <- Call.cint ldx12-      x21Ptr <- Call.ioarray x21-      ldx21Ptr <- Call.cint ldx21-      x22Ptr <- Call.ioarray x22-      ldx22Ptr <- Call.cint ldx22-      thetaPtr <- Call.array theta-      u1Ptr <- Call.array u1-      ldu1Ptr <- Call.cint ldu1-      u2Ptr <- Call.array u2-      ldu2Ptr <- Call.cint ldu2-      v1tPtr <- Call.array v1t-      ldv1tPtr <- Call.cint ldv1t-      v2tPtr <- Call.array v2t-      ldv2tPtr <- Call.cint ldv2t-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      rworkPtr <- Call.array rwork-      lrworkPtr <- Call.cint lrwork-      iworkPtr <- Call.array iwork-      infoPtr <- Call.alloca-      liftIO $ FFI.uncsd jobu1Ptr jobu2Ptr jobv1tPtr jobv2tPtr transPtr signsPtr mPtr pPtr qPtr x11Ptr ldx11Ptr x12Ptr ldx12Ptr x21Ptr ldx21Ptr x22Ptr ldx22Ptr thetaPtr u1Ptr ldu1Ptr u2Ptr ldu2Ptr v1tPtr ldv1tPtr v2tPtr ldv2tPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr infoPtr-      liftIO $ pure (,,,,,)-         <*> pure theta-         <*> pure u1-         <*> pure u2-         <*> pure v1t-         <*> pure v2t-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zung2l.f>-ung2l ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IO (Int)-ung2l m a tau = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.ung2l mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zung2r.f>-ung2r ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IO (Int)-ung2r m a tau = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 n-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.ung2r mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungbr.f>-ungbr ::-   Char {- ^ vect -} ->-   Int {- ^ m -} ->-   Int {- ^ k -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-ungbr vect m k a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let _tauSize = tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      vectPtr <- Call.char vect-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ungbr vectPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunghr.f>-unghr ::-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unghr ilo ihi a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   Call.assert "unghr: n-1 == tauDim0" (n-1 == tauDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unghr nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungl2.f>-ungl2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IO (Int)-ungl2 m a tau = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 m-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.ungl2 mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunglq.f>-unglq ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unglq m a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unglq mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungql.f>-ungql ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-ungql m a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ungql mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungqr.f>-ungqr ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-ungqr m a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ungqr mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungr2.f>-ungr2 ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IO (Int)-ungr2 m a tau = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 m-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.ungr2 mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungrq.f>-ungrq ::-   Int {- ^ m -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-ungrq m a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   let k = tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ungrq mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungtr.f>-ungtr ::-   Char {- ^ uplo -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ lwork -} ->-   IO (Int)-ungtr uplo a tau lwork = do-   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   let n = aDim0-   let lda = aDim1-   Call.assert "ungtr: n-1 == tauDim0" (n-1 == tauDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      aPtr <- Call.ioarray a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.ungtr uploPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunm2l.f>-unm2l ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-unm2l side trans m a tau c workSize = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let k = aDim0-   let lda = aDim1-   let n = cDim0-   let ldc = cDim1-   Call.assert "unm2l: k == tauDim0" (k == tauDim0)-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.unm2l sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunm2r.f>-unm2r ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-unm2r side trans m a tau c workSize = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let k = aDim0-   let lda = aDim1-   let n = cDim0-   let ldc = cDim1-   Call.assert "unm2r: k == tauDim0" (k == tauDim0)-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.unm2r sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmbr.f>-unmbr ::-   Char {- ^ vect -} ->-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   Int {- ^ k -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmbr vect side trans m k a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let n = cDim0-   let ldc = cDim1-   Call.ignore "unmbr: minimum[nq,k] == tauDim0" tauDim0-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      vectPtr <- Call.char vect-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmbr vectPtr sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmhr.f>-unmhr ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   Int {- ^ ilo -} ->-   Int {- ^ ihi -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmhr side trans m ilo ihi a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let _tauSize = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      iloPtr <- Call.cint ilo-      ihiPtr <- Call.cint ihi-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmhr sidePtr transPtr mPtr nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunml2.f>-unml2 ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-unml2 side trans m a tau c workSize = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.unml2 sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmlq.f>-unmlq ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmlq side trans m a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmlq sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmql.f>-unmql ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmql side trans m a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let k = aDim0-   let lda = aDim1-   let n = cDim0-   let ldc = cDim1-   Call.assert "unmql: k == tauDim0" (k == tauDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmql sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmqr.f>-unmqr ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmqr side trans m a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let k = aDim0-   let lda = aDim1-   let n = cDim0-   let ldc = cDim1-   Call.assert "unmqr: k == tauDim0" (k == tauDim0)-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmqr sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmr2.f>-unmr2 ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-unmr2 side trans m a tau c workSize = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.unmr2 sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmr3.f>-unmr3 ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   Int {- ^ l -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-unmr3 side trans m l a tau c workSize = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      lPtr <- Call.cint l-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.unmr3 sidePtr transPtr mPtr nPtr kPtr lPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmrq.f>-unmrq ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmrq side trans m a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmrq sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmrz.f>-unmrz ::-   Char {- ^ side -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   Int {- ^ l -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmrz side trans m l a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let k = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      kPtr <- Call.cint k-      lPtr <- Call.cint l-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmrz sidePtr transPtr mPtr nPtr kPtr lPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmtr.f>-unmtr ::-   Char {- ^ side -} ->-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray (Int,Int) (Complex Double) {- ^ a -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ lwork -} ->-   IO (Int)-unmtr side uplo trans m a tau c lwork = do-   let (aDim0,aDim1) = Call.sizes2 $ bounds a-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _aSize = aDim0-   let lda = aDim1-   let _tauSize = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 (maximum[1,lwork])-   evalContT $ do-      sidePtr <- Call.char side-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      aPtr <- Call.array a-      ldaPtr <- Call.cint lda-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work-      lworkPtr <- Call.cint lwork-      infoPtr <- Call.alloca-      liftIO $ FFI.unmtr sidePtr uploPtr transPtr mPtr nPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr-      liftIO $ fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zupgtr.f>-upgtr ::-   Char {- ^ uplo -} ->-   Int {- ^ n -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   Int {- ^ ldq -} ->-   IO (CArray (Int,Int) (Complex Double), Int)-upgtr uplo n ap tau ldq = do-   let apDim0 = Call.sizes1 $ bounds ap-   let tauDim0 = Call.sizes1 $ bounds tau-   Call.assert "upgtr: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)-   Call.assert "upgtr: n-1 == tauDim0" (n-1 == tauDim0)-   q <- Call.newArray2 n ldq-   work <- Call.newArray1 (n-1)-   evalContT $ do-      uploPtr <- Call.char uplo-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      tauPtr <- Call.array tau-      qPtr <- Call.array q-      ldqPtr <- Call.cint ldq-      workPtr <- Call.array work-      infoPtr <- Call.alloca-      liftIO $ FFI.upgtr uploPtr nPtr apPtr tauPtr qPtr ldqPtr workPtr infoPtr-      liftIO $ pure (,)-         <*> pure q-         <*> fmap fromIntegral (peek infoPtr)---- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zupmtr.f>-upmtr ::-   Char {- ^ side -} ->-   Char {- ^ uplo -} ->-   Char {- ^ trans -} ->-   Int {- ^ m -} ->-   CArray Int (Complex Double) {- ^ ap -} ->-   CArray Int (Complex Double) {- ^ tau -} ->-   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->-   Int {- ^ workSize -} ->-   IO (Int)-upmtr side uplo trans m ap tau c workSize = do-   let apDim0 = Call.sizes1 $ bounds ap-   let tauDim0 = Call.sizes1 $ bounds tau-   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c-   let _apSize = apDim0-   let _tauSize = tauDim0-   let n = cDim0-   let ldc = cDim1-   work <- Call.newArray1 workSize-   evalContT $ do-      sidePtr <- Call.char side-      uploPtr <- Call.char uplo-      transPtr <- Call.char trans-      mPtr <- Call.cint m-      nPtr <- Call.cint n-      apPtr <- Call.array ap-      tauPtr <- Call.array tau-      cPtr <- Call.ioarray c-      ldcPtr <- Call.cint ldc-      workPtr <- Call.array work+      b11dPtr <- Call.ioarray b11d+      b11ePtr <- Call.ioarray b11e+      b12dPtr <- Call.ioarray b12d+      b12ePtr <- Call.ioarray b12e+      b21dPtr <- Call.ioarray b21d+      b21ePtr <- Call.ioarray b21e+      b22dPtr <- Call.ioarray b22d+      b22ePtr <- Call.ioarray b22e+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      infoPtr <- Call.alloca+      liftIO $ FFI.bbcsd jobu1Ptr jobu2Ptr jobv1tPtr jobv2tPtr transPtr mPtr pPtr qPtr thetaPtr phiPtr u1Ptr ldu1Ptr u2Ptr ldu2Ptr v1tPtr ldv1tPtr v2tPtr ldv2tPtr b11dPtr b11ePtr b12dPtr b12ePtr b21dPtr b21ePtr b22dPtr b22ePtr rworkPtr lrworkPtr infoPtr+      liftIO $ pure (,,,,,,,,)+         <*> Call.freezeArray b11d+         <*> Call.freezeArray b11e+         <*> Call.freezeArray b12d+         <*> Call.freezeArray b12e+         <*> Call.freezeArray b21d+         <*> Call.freezeArray b21e+         <*> Call.freezeArray b22d+         <*> Call.freezeArray b22e+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zbdsqr.f>+bdsqr ::+   Char {- ^ uplo -} ->+   Int {- ^ nru -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vt -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ u -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   IO (Int)+bdsqr uplo nru d e vt u c = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (vtDim0,vtDim1) <- Call.sizes2 <$> getBounds vt+   (uDim0,uDim1) <- Call.sizes2 <$> getBounds u+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let n = dDim0+   let ncvt = vtDim0+   let ldvt = vtDim1+   let ldu = uDim1+   let ncc = cDim0+   let ldc = cDim1+   Call.assert "bdsqr: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "bdsqr: n == uDim0" (n == uDim0)+   rwork <- Call.newArray1 (4*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      ncvtPtr <- Call.cint ncvt+      nruPtr <- Call.cint nru+      nccPtr <- Call.cint ncc+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      vtPtr <- Call.ioarray vt+      ldvtPtr <- Call.cint ldvt+      uPtr <- Call.ioarray u+      lduPtr <- Call.cint ldu+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.bdsqr uploPtr nPtr ncvtPtr nruPtr nccPtr dPtr ePtr vtPtr ldvtPtr uPtr lduPtr cPtr ldcPtr rworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zcgesv.f>+cgesv ::+   Int {- ^ n -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray Int CInt, CArray (Int,Int) (Complex Double), Int, Int)+cgesv n a b ldx = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let _aSize = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   ipiv <- Call.newArray1 n+   x <- Call.newArray2 nrhs ldx+   work <- Call.newArray2 nrhs n+   swork <- Call.newArray1 (n*(n+nrhs))+   rwork <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      workPtr <- Call.ioarray work+      sworkPtr <- Call.ioarray swork+      rworkPtr <- Call.ioarray rwork+      iterPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.cgesv nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr xPtr ldxPtr workPtr sworkPtr rworkPtr iterPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray ipiv+         <*> Call.freezeArray x+         <*> fmap fromIntegral (peek iterPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zcposv.f>+cposv ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Int, Int)+cposv uplo n a b ldx = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let _aSize = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   x <- Call.newArray2 nrhs ldx+   work <- Call.newArray2 nrhs n+   swork <- Call.newArray1 (n*(n+nrhs))+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      workPtr <- Call.ioarray work+      sworkPtr <- Call.ioarray swork+      rworkPtr <- Call.ioarray rwork+      iterPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.cposv uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr xPtr ldxPtr workPtr sworkPtr rworkPtr iterPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray x+         <*> fmap fromIntegral (peek iterPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbbrd.f>+gbbrd ::+   Char {- ^ vect -} ->+   Int {- ^ m -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ ldq -} ->+   Int {- ^ ldpt -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   IO (CArray Int Double, CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+gbbrd vect m kl ku ab ldq ldpt c = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let n = abDim0+   let ldab = abDim1+   let ncc = cDim0+   let ldc = cDim1+   d <- Call.newArray1 (minimum[m,n])+   e <- Call.newArray1 (minimum[m,n]-1)+   q <- Call.newArray2 m ldq+   pt <- Call.newArray2 n ldpt+   work <- Call.newArray1 (maximum[m,n])+   rwork <- Call.newArray1 (maximum[m,n])+   evalContT $ do+      vectPtr <- Call.char vect+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nccPtr <- Call.cint ncc+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      ptPtr <- Call.ioarray pt+      ldptPtr <- Call.cint ldpt+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gbbrd vectPtr mPtr nPtr nccPtr klPtr kuPtr abPtr ldabPtr dPtr ePtr qPtr ldqPtr ptPtr ldptPtr cPtr ldcPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray q+         <*> Call.freezeArray pt+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbcon.f>+gbcon ::+   Char {- ^ norm -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+gbcon norm kl ku ab ipiv anorm = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = abDim0+   let ldab = abDim1+   Call.assert "gbcon: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gbcon normPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr anormPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbequ.f>+gbequ ::+   Int {- ^ m -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)+gbequ m kl ku ab = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   r <- Call.newArray1 m+   c <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      rowcndPtr <- Call.alloca+      colcndPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.gbequ mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray r+         <*> Call.freezeArray c+         <*> peek rowcndPtr+         <*> peek colcndPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbequb.f>+gbequb ::+   Int {- ^ m -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)+gbequb m kl ku ab = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   r <- Call.newArray1 m+   c <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      rowcndPtr <- Call.alloca+      colcndPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.gbequb mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray r+         <*> Call.freezeArray c+         <*> peek rowcndPtr+         <*> peek colcndPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbrfs.f>+gbrfs ::+   Char {- ^ trans -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray (Int,Int) (Complex Double) {- ^ afb -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+gbrfs trans kl ku ab afb ipiv b x = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let (afbDim0,afbDim1) = Call.sizes2 $ bounds afb+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = abDim0+   let ldab = abDim1+   let ldafb = afbDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "gbrfs: n == afbDim0" (n == afbDim0)+   Call.assert "gbrfs: n == ipivDim0" (n == ipivDim0)+   Call.assert "gbrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      afbPtr <- Call.array afb+      ldafbPtr <- Call.cint ldafb+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gbrfs transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbsv.f>+gbsv ::+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (CArray Int CInt, Int)+gbsv kl ku ab b = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   ipiv <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.gbsv nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbsvx.f>+gbsvx ::+   Char {- ^ fact -} ->+   Char {- ^ trans -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ afb -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   Char {- ^ equed -} ->+   IOCArray Int Double {- ^ r -} ->+   IOCArray Int Double {- ^ c -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+gbsvx fact trans kl ku ab afb ipiv equed r c b ldx = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (afbDim0,afbDim1) <- Call.sizes2 <$> getBounds afb+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   rDim0 <- Call.sizes1 <$> getBounds r+   cDim0 <- Call.sizes1 <$> getBounds c+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let ldafb = afbDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gbsvx: n == afbDim0" (n == afbDim0)+   Call.assert "gbsvx: n == ipivDim0" (n == ipivDim0)+   Call.assert "gbsvx: n == rDim0" (n == rDim0)+   Call.assert "gbsvx: n == cDim0" (n == cDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      afbPtr <- Call.ioarray afb+      ldafbPtr <- Call.cint ldafb+      ipivPtr <- Call.ioarray ipiv+      equedPtr <- Call.char equed+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gbsvx factPtr transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr ipivPtr equedPtr rPtr cPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap castCCharToChar (peek equedPtr)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtf2.f>+gbtf2 ::+   Int {- ^ m -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (CArray Int CInt, Int)+gbtf2 m kl ku ab = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   ipiv <- Call.newArray1 (minimum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.gbtf2 mPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtrf.f>+gbtrf ::+   Int {- ^ m -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (CArray Int CInt, Int)+gbtrf m kl ku ab = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   ipiv <- Call.newArray1 (minimum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.gbtrf mPtr nPtr klPtr kuPtr abPtr ldabPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgbtrs.f>+gbtrs ::+   Char {- ^ trans -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+gbtrs trans kl ku ab ipiv b = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gbtrs: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.gbtrs transPtr nPtr klPtr kuPtr nrhsPtr abPtr ldabPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebak.f>+gebak ::+   Char {- ^ job -} ->+   Char {- ^ side -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   CArray Int Double {- ^ scale -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->+   IO (Int)+gebak job side ilo ihi scale v = do+   let scaleDim0 = Call.sizes1 $ bounds scale+   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v+   let n = scaleDim0+   let m = vDim0+   let ldv = vDim1+   evalContT $ do+      jobPtr <- Call.char job+      sidePtr <- Call.char side+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      scalePtr <- Call.array scale+      mPtr <- Call.cint m+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      infoPtr <- Call.alloca+      liftIO $ FFI.gebak jobPtr sidePtr nPtr iloPtr ihiPtr scalePtr mPtr vPtr ldvPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebal.f>+gebal ::+   Char {- ^ job -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int, Int, CArray Int Double, Int)+gebal job a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   scale <- Call.newArray1 n+   evalContT $ do+      jobPtr <- Call.char job+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      iloPtr <- Call.alloca+      ihiPtr <- Call.alloca+      scalePtr <- Call.ioarray scale+      infoPtr <- Call.alloca+      liftIO $ FFI.gebal jobPtr nPtr aPtr ldaPtr iloPtr ihiPtr scalePtr infoPtr+      liftIO $ pure (,,,)+         <*> fmap fromIntegral (peek iloPtr)+         <*> fmap fromIntegral (peek ihiPtr)+         <*> Call.freezeArray scale+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebd2.f>+gebd2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), Int)+gebd2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   d <- Call.newArray1 (minimum[m,n])+   e <- Call.newArray1 (minimum[m,n]-1)+   tauq <- Call.newArray1 (minimum[m,n])+   taup <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauqPtr <- Call.ioarray tauq+      taupPtr <- Call.ioarray taup+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.gebd2 mPtr nPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr workPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tauq+         <*> Call.freezeArray taup+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgebrd.f>+gebrd ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), Int)+gebrd m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   d <- Call.newArray1 (minimum[m,n])+   e <- Call.newArray1 (minimum[m,n]-1)+   tauq <- Call.newArray1 (minimum[m,n])+   taup <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauqPtr <- Call.ioarray tauq+      taupPtr <- Call.ioarray taup+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gebrd mPtr nPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tauq+         <*> Call.freezeArray taup+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgecon.f>+gecon ::+   Char {- ^ norm -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+gecon norm a anorm = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gecon normPtr nPtr aPtr ldaPtr anormPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeequ.f>+geequ ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)+geequ m a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   r <- Call.newArray1 m+   c <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      rowcndPtr <- Call.alloca+      colcndPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.geequ mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray r+         <*> Call.freezeArray c+         <*> peek rowcndPtr+         <*> peek colcndPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeequb.f>+geequb ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, CArray Int Double, Double, Double, Double, Int)+geequb m a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   r <- Call.newArray1 m+   c <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      rowcndPtr <- Call.alloca+      colcndPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.geequb mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray r+         <*> Call.freezeArray c+         <*> peek rowcndPtr+         <*> peek colcndPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgees.f>+gees ::+   Char {- ^ jobvs -} ->+   Char {- ^ sort -} ->+   FunPtr (Ptr (Complex Double) -> IO Bool) {- ^ select -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldvs -} ->+   Int {- ^ lwork -} ->+   IO (Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), Int)+gees jobvs sort select a ldvs lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   vs <- Call.newArray2 n ldvs+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 n+   bwork <- Call.newArray1 n+   evalContT $ do+      jobvsPtr <- Call.char jobvs+      sortPtr <- Call.char sort+      selectPtr <- pure select+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sdimPtr <- Call.alloca+      wPtr <- Call.ioarray w+      vsPtr <- Call.ioarray vs+      ldvsPtr <- Call.cint ldvs+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      bworkPtr <- Call.ioarray bwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gees jobvsPtr sortPtr selectPtr nPtr aPtr ldaPtr sdimPtr wPtr vsPtr ldvsPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> fmap fromIntegral (peek sdimPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray vs+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeesx.f>+geesx ::+   Char {- ^ jobvs -} ->+   Char {- ^ sort -} ->+   FunPtr (Ptr (Complex Double) -> IO Bool) {- ^ select -} ->+   Char {- ^ sense -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldvs -} ->+   Int {- ^ lwork -} ->+   IO (Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), Double, Double, Int)+geesx jobvs sort select sense a ldvs lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   vs <- Call.newArray2 n ldvs+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 n+   bwork <- Call.newArray1 n+   evalContT $ do+      jobvsPtr <- Call.char jobvs+      sortPtr <- Call.char sort+      selectPtr <- pure select+      sensePtr <- Call.char sense+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sdimPtr <- Call.alloca+      wPtr <- Call.ioarray w+      vsPtr <- Call.ioarray vs+      ldvsPtr <- Call.cint ldvs+      rcondePtr <- Call.alloca+      rcondvPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      bworkPtr <- Call.ioarray bwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geesx jobvsPtr sortPtr selectPtr sensePtr nPtr aPtr ldaPtr sdimPtr wPtr vsPtr ldvsPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap fromIntegral (peek sdimPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray vs+         <*> peek rcondePtr+         <*> peek rcondvPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeev.f>+geev ::+   Char {- ^ jobvl -} ->+   Char {- ^ jobvr -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldvl -} ->+   Int {- ^ ldvr -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+geev jobvl jobvr a ldvl ldvr lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   vl <- Call.newArray2 n ldvl+   vr <- Call.newArray2 n ldvr+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      jobvlPtr <- Call.char jobvl+      jobvrPtr <- Call.char jobvr+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      wPtr <- Call.ioarray w+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geev jobvlPtr jobvrPtr nPtr aPtr ldaPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray vl+         <*> Call.freezeArray vr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeevx.f>+geevx ::+   Char {- ^ balanc -} ->+   Char {- ^ jobvl -} ->+   Char {- ^ jobvr -} ->+   Char {- ^ sense -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldvl -} ->+   Int {- ^ ldvr -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int, Int, CArray Int Double, Double, CArray Int Double, CArray Int Double, Int)+geevx balanc jobvl jobvr sense a ldvl ldvr lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   vl <- Call.newArray2 n ldvl+   vr <- Call.newArray2 n ldvr+   scale <- Call.newArray1 n+   rconde <- Call.newArray1 n+   rcondv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      balancPtr <- Call.char balanc+      jobvlPtr <- Call.char jobvl+      jobvrPtr <- Call.char jobvr+      sensePtr <- Call.char sense+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      wPtr <- Call.ioarray w+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      iloPtr <- Call.alloca+      ihiPtr <- Call.alloca+      scalePtr <- Call.ioarray scale+      abnrmPtr <- Call.alloca+      rcondePtr <- Call.ioarray rconde+      rcondvPtr <- Call.ioarray rcondv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geevx balancPtr jobvlPtr jobvrPtr sensePtr nPtr aPtr ldaPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr iloPtr ihiPtr scalePtr abnrmPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,,,,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray vl+         <*> Call.freezeArray vr+         <*> fmap fromIntegral (peek iloPtr)+         <*> fmap fromIntegral (peek ihiPtr)+         <*> Call.freezeArray scale+         <*> peek abnrmPtr+         <*> Call.freezeArray rconde+         <*> Call.freezeArray rcondv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgehd2.f>+gehd2 ::+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+gehd2 ilo ihi a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (n-1)+   work <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.gehd2 nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgehrd.f>+gehrd ::+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+gehrd ilo ihi a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (n-1)+   work <- Call.newArray1 lwork+   evalContT $ do+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gehrd nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelq2.f>+gelq2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+gelq2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 m+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.gelq2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelqf.f>+gelqf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+gelqf m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gelqf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgels.f>+gels ::+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (Int)+gels trans m a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gels transPtr mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelsd.f>+gelsd ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Double {- ^ rcond -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, Int, Int)+gelsd m a b rcond lwork lrwork liwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   s <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      sPtr <- Call.ioarray s+      rcondPtr <- Call.double rcond+      rankPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gelsd mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr sPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray s+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelss.f>+gelss ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Double {- ^ rcond -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, Int, Int)+gelss m a b rcond lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   s <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (5*minimum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      sPtr <- Call.ioarray s+      rcondPtr <- Call.double rcond+      rankPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gelss mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr sPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray s+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgelsy.f>+gelsy ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray Int CInt {- ^ jpvt -} ->+   Double {- ^ rcond -} ->+   Int {- ^ lwork -} ->+   IO (Int, Int)+gelsy m a b jpvt rcond lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gelsy: n == jpvtDim0" (n == jpvtDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      jpvtPtr <- Call.ioarray jpvt+      rcondPtr <- Call.double rcond+      rankPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gelsy mPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr jpvtPtr rcondPtr rankPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeql2.f>+geql2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+geql2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.geql2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqlf.f>+geqlf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+geqlf m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geqlf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqp3.f>+geqp3 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray Int CInt {- ^ jpvt -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+geqp3 m a jpvt lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt+   let n = aDim0+   let lda = aDim1+   Call.assert "geqp3: n == jpvtDim0" (n == jpvtDim0)+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      jpvtPtr <- Call.ioarray jpvt+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geqp3 mPtr nPtr aPtr ldaPtr jpvtPtr tauPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqr2.f>+geqr2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+geqr2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.geqr2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqr2p.f>+geqr2p ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+geqr2p m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.geqr2p mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqrf.f>+geqrf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+geqrf m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geqrf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgeqrfp.f>+geqrfp ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+geqrfp m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.geqrfp mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerfs.f>+gerfs ::+   Char {- ^ trans -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ af -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+gerfs trans a af ipiv b x = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (afDim0,afDim1) = Call.sizes2 $ bounds af+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "gerfs: n == afDim0" (n == afDim0)+   Call.assert "gerfs: n == ipivDim0" (n == ipivDim0)+   Call.assert "gerfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.array af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gerfs transPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerq2.f>+gerq2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+gerq2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 m+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.gerq2 mPtr nPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgerqf.f>+gerqf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+gerqf m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gerqf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesc2.f>+gesc2 ::+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray Int (Complex Double) {- ^ rhs -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray Int CInt {- ^ jpiv -} ->+   IO (Double)+gesc2 a rhs ipiv jpiv = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   rhsDim0 <- Call.sizes1 <$> getBounds rhs+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let jpivDim0 = Call.sizes1 $ bounds jpiv+   let n = aDim0+   let lda = aDim1+   let _rhsSize = rhsDim0+   Call.assert "gesc2: n == ipivDim0" (n == ipivDim0)+   Call.assert "gesc2: n == jpivDim0" (n == jpivDim0)+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      rhsPtr <- Call.ioarray rhs+      ipivPtr <- Call.array ipiv+      jpivPtr <- Call.array jpiv+      scalePtr <- Call.alloca+      liftIO $ FFI.gesc2 nPtr aPtr ldaPtr rhsPtr ipivPtr jpivPtr scalePtr+      liftIO $ peek scalePtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesdd.f>+gesdd ::+   Char {- ^ jobz -} ->+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ucol -} ->+   Int {- ^ ldu -} ->+   Int {- ^ ldvt -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+gesdd jobz m a ucol ldu ldvt lwork lrwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 (minimum[m,n])+   u <- Call.newArray2 ucol ldu+   vt <- Call.newArray2 n ldvt+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (8*minimum[m,n])+   evalContT $ do+      jobzPtr <- Call.char jobz+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      uPtr <- Call.ioarray u+      lduPtr <- Call.cint ldu+      vtPtr <- Call.ioarray vt+      ldvtPtr <- Call.cint ldvt+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gesdd jobzPtr mPtr nPtr aPtr ldaPtr sPtr uPtr lduPtr vtPtr ldvtPtr workPtr lworkPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> Call.freezeArray u+         <*> Call.freezeArray vt+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesv.f>+gesv ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (CArray Int CInt, Int)+gesv a b = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   ipiv <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.gesv nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesvd.f>+gesvd ::+   Char {- ^ jobu -} ->+   Char {- ^ jobvt -} ->+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ucol -} ->+   Int {- ^ ldu -} ->+   Int {- ^ ldvt -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+gesvd jobu jobvt m a ucol ldu ldvt lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 (minimum[m,n])+   u <- Call.newArray2 ucol ldu+   vt <- Call.newArray2 n ldvt+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (5*minimum[m,n])+   evalContT $ do+      jobuPtr <- Call.char jobu+      jobvtPtr <- Call.char jobvt+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      uPtr <- Call.ioarray u+      lduPtr <- Call.cint ldu+      vtPtr <- Call.ioarray vt+      ldvtPtr <- Call.cint ldvt+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gesvd jobuPtr jobvtPtr mPtr nPtr aPtr ldaPtr sPtr uPtr lduPtr vtPtr ldvtPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> Call.freezeArray u+         <*> Call.freezeArray vt+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgesvx.f>+gesvx ::+   Char {- ^ fact -} ->+   Char {- ^ trans -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   Char {- ^ equed -} ->+   IOCArray Int Double {- ^ r -} ->+   IOCArray Int Double {- ^ c -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+gesvx fact trans a af ipiv equed r c b ldx = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   rDim0 <- Call.sizes1 <$> getBounds r+   cDim0 <- Call.sizes1 <$> getBounds c+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gesvx: n == afDim0" (n == afDim0)+   Call.assert "gesvx: n == ipivDim0" (n == ipivDim0)+   Call.assert "gesvx: n == rDim0" (n == rDim0)+   Call.assert "gesvx: n == cDim0" (n == cDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      factPtr <- Call.char fact+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      afPtr <- Call.ioarray af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.ioarray ipiv+      equedPtr <- Call.char equed+      rPtr <- Call.ioarray r+      cPtr <- Call.ioarray c+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gesvx factPtr transPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr equedPtr rPtr cPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap castCCharToChar (peek equedPtr)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetc2.f>+getc2 ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int CInt, CArray Int CInt, Int)+getc2 a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   jpiv <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      jpivPtr <- Call.ioarray jpiv+      infoPtr <- Call.alloca+      liftIO $ FFI.getc2 nPtr aPtr ldaPtr ipivPtr jpivPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ipiv+         <*> Call.freezeArray jpiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetf2.f>+getf2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int CInt, Int)+getf2 m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 (minimum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.getf2 mPtr nPtr aPtr ldaPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetrf.f>+getrf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int CInt, Int)+getrf m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 (minimum[m,n])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.getrf mPtr nPtr aPtr ldaPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetri.f>+getri ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ lwork -} ->+   IO (Int)+getri a ipiv lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "getri: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.getri nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgetrs.f>+getrs ::+   Char {- ^ trans -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+getrs trans a ipiv b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "getrs: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.getrs transPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggbak.f>+ggbak ::+   Char {- ^ job -} ->+   Char {- ^ side -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   CArray Int Double {- ^ lscale -} ->+   CArray Int Double {- ^ rscale -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->+   IO (Int)+ggbak job side ilo ihi lscale rscale v = do+   let lscaleDim0 = Call.sizes1 $ bounds lscale+   let rscaleDim0 = Call.sizes1 $ bounds rscale+   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v+   let n = lscaleDim0+   let m = vDim0+   let ldv = vDim1+   Call.assert "ggbak: n == rscaleDim0" (n == rscaleDim0)+   evalContT $ do+      jobPtr <- Call.char job+      sidePtr <- Call.char side+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      lscalePtr <- Call.array lscale+      rscalePtr <- Call.array rscale+      mPtr <- Call.cint m+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      infoPtr <- Call.alloca+      liftIO $ FFI.ggbak jobPtr sidePtr nPtr iloPtr ihiPtr lscalePtr rscalePtr mPtr vPtr ldvPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggbal.f>+ggbal ::+   Char {- ^ job -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (Int, Int, CArray Int Double, CArray Int Double, Int)+ggbal job a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "ggbal: n == bDim0" (n == bDim0)+   lscale <- Call.newArray1 n+   rscale <- Call.newArray1 n+   work <- Call.newArray1 lwork+   evalContT $ do+      jobPtr <- Call.char job+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      iloPtr <- Call.alloca+      ihiPtr <- Call.alloca+      lscalePtr <- Call.ioarray lscale+      rscalePtr <- Call.ioarray rscale+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.ggbal jobPtr nPtr aPtr ldaPtr bPtr ldbPtr iloPtr ihiPtr lscalePtr rscalePtr workPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek iloPtr)+         <*> fmap fromIntegral (peek ihiPtr)+         <*> Call.freezeArray lscale+         <*> Call.freezeArray rscale+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgges.f>+gges ::+   Char {- ^ jobvsl -} ->+   Char {- ^ jobvsr -} ->+   Char {- ^ sort -} ->+   FunPtr (Ptr (Complex Double) -> Ptr (Complex Double) -> IO Bool) {- ^ selctg -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldvsl -} ->+   Int {- ^ ldvsr -} ->+   Int {- ^ lwork -} ->+   IO (Int, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+gges jobvsl jobvsr sort selctg a b ldvsl ldvsr lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "gges: n == bDim0" (n == bDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   vsl <- Call.newArray2 n ldvsl+   vsr <- Call.newArray2 n ldvsr+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (8*n)+   bwork <- Call.newArray1 n+   evalContT $ do+      jobvslPtr <- Call.char jobvsl+      jobvsrPtr <- Call.char jobvsr+      sortPtr <- Call.char sort+      selctgPtr <- pure selctg+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      sdimPtr <- Call.alloca+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      vslPtr <- Call.ioarray vsl+      ldvslPtr <- Call.cint ldvsl+      vsrPtr <- Call.ioarray vsr+      ldvsrPtr <- Call.cint ldvsr+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      bworkPtr <- Call.ioarray bwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gges jobvslPtr jobvsrPtr sortPtr selctgPtr nPtr aPtr ldaPtr bPtr ldbPtr sdimPtr alphaPtr betaPtr vslPtr ldvslPtr vsrPtr ldvsrPtr workPtr lworkPtr rworkPtr bworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap fromIntegral (peek sdimPtr)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> Call.freezeArray vsl+         <*> Call.freezeArray vsr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggesx.f>+ggesx ::+   Char {- ^ jobvsl -} ->+   Char {- ^ jobvsr -} ->+   Char {- ^ sort -} ->+   FunPtr (Ptr (Complex Double) -> Ptr (Complex Double) -> IO Bool) {- ^ selctg -} ->+   Char {- ^ sense -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldvsl -} ->+   Int {- ^ ldvsr -} ->+   Int {- ^ lwork -} ->+   Int {- ^ liwork -} ->+   IO (Int, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray Int Double, CArray Int Double, Int)+ggesx jobvsl jobvsr sort selctg sense a b ldvsl ldvsr lwork liwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "ggesx: n == bDim0" (n == bDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   vsl <- Call.newArray2 n ldvsl+   vsr <- Call.newArray2 n ldvsr+   rconde <- Call.newArray1 2+   rcondv <- Call.newArray1 2+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (8*n)+   iwork <- Call.newArray1 (maximum[1,liwork])+   bwork <- Call.newArray1 n+   evalContT $ do+      jobvslPtr <- Call.char jobvsl+      jobvsrPtr <- Call.char jobvsr+      sortPtr <- Call.char sort+      selctgPtr <- pure selctg+      sensePtr <- Call.char sense+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      sdimPtr <- Call.alloca+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      vslPtr <- Call.ioarray vsl+      ldvslPtr <- Call.cint ldvsl+      vsrPtr <- Call.ioarray vsr+      ldvsrPtr <- Call.cint ldvsr+      rcondePtr <- Call.ioarray rconde+      rcondvPtr <- Call.ioarray rcondv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      bworkPtr <- Call.ioarray bwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggesx jobvslPtr jobvsrPtr sortPtr selctgPtr sensePtr nPtr aPtr ldaPtr bPtr ldbPtr sdimPtr alphaPtr betaPtr vslPtr ldvslPtr vsrPtr ldvsrPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr iworkPtr liworkPtr bworkPtr infoPtr+      liftIO $ pure (,,,,,,,)+         <*> fmap fromIntegral (peek sdimPtr)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> Call.freezeArray vsl+         <*> Call.freezeArray vsr+         <*> Call.freezeArray rconde+         <*> Call.freezeArray rcondv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggev.f>+ggev ::+   Char {- ^ jobvl -} ->+   Char {- ^ jobvr -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldvl -} ->+   Int {- ^ ldvr -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+ggev jobvl jobvr a b ldvl ldvr lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "ggev: n == bDim0" (n == bDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   vl <- Call.newArray2 n ldvl+   vr <- Call.newArray2 n ldvr+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (8*n)+   evalContT $ do+      jobvlPtr <- Call.char jobvl+      jobvrPtr <- Call.char jobvr+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggev jobvlPtr jobvrPtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr vlPtr ldvlPtr vrPtr ldvrPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> Call.freezeArray vl+         <*> Call.freezeArray vr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggevx.f>+ggevx ::+   Char {- ^ balanc -} ->+   Char {- ^ jobvl -} ->+   Char {- ^ jobvr -} ->+   Char {- ^ sense -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldvl -} ->+   Int {- ^ ldvr -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int, Int, CArray Int Double, CArray Int Double, Double, Double, CArray Int Double, CArray Int Double, Int)+ggevx balanc jobvl jobvr sense a b ldvl ldvr lwork lrwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "ggevx: n == bDim0" (n == bDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   vl <- Call.newArray2 n ldvl+   vr <- Call.newArray2 n ldvr+   lscale <- Call.newArray1 n+   rscale <- Call.newArray1 n+   rconde <- Call.newArray1 n+   rcondv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 lrwork+   iwork <- Call.newArray1 (n+2)+   bwork <- Call.newArray1 n+   evalContT $ do+      balancPtr <- Call.char balanc+      jobvlPtr <- Call.char jobvl+      jobvrPtr <- Call.char jobvr+      sensePtr <- Call.char sense+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      iloPtr <- Call.alloca+      ihiPtr <- Call.alloca+      lscalePtr <- Call.ioarray lscale+      rscalePtr <- Call.ioarray rscale+      abnrmPtr <- Call.alloca+      bbnrmPtr <- Call.alloca+      rcondePtr <- Call.ioarray rconde+      rcondvPtr <- Call.ioarray rcondv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      bworkPtr <- Call.ioarray bwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggevx balancPtr jobvlPtr jobvrPtr sensePtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr vlPtr ldvlPtr vrPtr ldvrPtr iloPtr ihiPtr lscalePtr rscalePtr abnrmPtr bbnrmPtr rcondePtr rcondvPtr workPtr lworkPtr rworkPtr iworkPtr bworkPtr infoPtr+      liftIO $ pure (,,,,,,,,,,,,)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> Call.freezeArray vl+         <*> Call.freezeArray vr+         <*> fmap fromIntegral (peek iloPtr)+         <*> fmap fromIntegral (peek ihiPtr)+         <*> Call.freezeArray lscale+         <*> Call.freezeArray rscale+         <*> peek abnrmPtr+         <*> peek bbnrmPtr+         <*> Call.freezeArray rconde+         <*> Call.freezeArray rcondv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggglm.f>+ggglm ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray Int (Complex Double) {- ^ d -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)+ggglm a b d lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   dDim0 <- Call.sizes1 <$> getBounds d+   let m = aDim0+   let lda = aDim1+   let p = bDim0+   let ldb = bDim1+   let n = dDim0+   x <- Call.newArray1 m+   y <- Call.newArray1 p+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      nPtr <- Call.cint n+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      dPtr <- Call.ioarray d+      xPtr <- Call.ioarray x+      yPtr <- Call.ioarray y+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggglm nPtr mPtr pPtr aPtr ldaPtr bPtr ldbPtr dPtr xPtr yPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray x+         <*> Call.freezeArray y+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgghrd.f>+gghrd ::+   Char {- ^ compq -} ->+   Char {- ^ compz -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   IO (Int)+gghrd compq compz ilo ihi a b q z = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   let ldq = qDim1+   let ldz = zDim1+   Call.assert "gghrd: n == bDim0" (n == bDim0)+   Call.assert "gghrd: n == qDim0" (n == qDim0)+   Call.assert "gghrd: n == zDim0" (n == zDim0)+   evalContT $ do+      compqPtr <- Call.char compq+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      infoPtr <- Call.alloca+      liftIO $ FFI.gghrd compqPtr compzPtr nPtr iloPtr ihiPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgglse.f>+gglse ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray Int (Complex Double) {- ^ c -} ->+   IOCArray Int (Complex Double) {- ^ d -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+gglse a b c d lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   cDim0 <- Call.sizes1 <$> getBounds c+   dDim0 <- Call.sizes1 <$> getBounds d+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   let m = cDim0+   let p = dDim0+   Call.assert "gglse: n == bDim0" (n == bDim0)+   x <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      pPtr <- Call.cint p+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      dPtr <- Call.ioarray d+      xPtr <- Call.ioarray x+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gglse mPtr nPtr pPtr aPtr ldaPtr bPtr ldbPtr cPtr dPtr xPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray x+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggqrf.f>+ggqrf ::+   Int {- ^ n -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)+ggqrf n a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let m = aDim0+   let lda = aDim1+   let p = bDim0+   let ldb = bDim1+   taua <- Call.newArray1 (minimum[n,m])+   taub <- Call.newArray1 (minimum[n,p])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      nPtr <- Call.cint n+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauaPtr <- Call.ioarray taua+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      taubPtr <- Call.ioarray taub+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggqrf nPtr mPtr pPtr aPtr ldaPtr tauaPtr bPtr ldbPtr taubPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray taua+         <*> Call.freezeArray taub+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zggrqf.f>+ggrqf ::+   Int {- ^ m -} ->+   Int {- ^ p -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)+ggrqf m p a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "ggrqf: n == bDim0" (n == bDim0)+   taua <- Call.newArray1 (minimum[m,n])+   taub <- Call.newArray1 (minimum[p,n])+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauaPtr <- Call.ioarray taua+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      taubPtr <- Call.ioarray taub+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ggrqf mPtr pPtr nPtr aPtr ldaPtr tauaPtr bPtr ldbPtr taubPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray taua+         <*> Call.freezeArray taub+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtcon.f>+gtcon ::+   Char {- ^ norm -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   CArray Int (Complex Double) {- ^ du2 -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+gtcon norm dl d du du2 ipiv anorm = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let du2Dim0 = Call.sizes1 $ bounds du2+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = dDim0+   Call.assert "gtcon: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gtcon: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "gtcon: n-2 == du2Dim0" (n-2 == du2Dim0)+   Call.assert "gtcon: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      du2Ptr <- Call.array du2+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.gtcon normPtr nPtr dlPtr dPtr duPtr du2Ptr ipivPtr anormPtr rcondPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtrfs.f>+gtrfs ::+   Char {- ^ trans -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   CArray Int (Complex Double) {- ^ dlf -} ->+   CArray Int (Complex Double) {- ^ df -} ->+   CArray Int (Complex Double) {- ^ duf -} ->+   CArray Int (Complex Double) {- ^ du2 -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+gtrfs trans dl d du dlf df duf du2 ipiv b x = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let dlfDim0 = Call.sizes1 $ bounds dlf+   let dfDim0 = Call.sizes1 $ bounds df+   let dufDim0 = Call.sizes1 $ bounds duf+   let du2Dim0 = Call.sizes1 $ bounds du2+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "gtrfs: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gtrfs: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "gtrfs: n-1 == dlfDim0" (n-1 == dlfDim0)+   Call.assert "gtrfs: n == dfDim0" (n == dfDim0)+   Call.assert "gtrfs: n-1 == dufDim0" (n-1 == dufDim0)+   Call.assert "gtrfs: n-2 == du2Dim0" (n-2 == du2Dim0)+   Call.assert "gtrfs: n == ipivDim0" (n == ipivDim0)+   Call.assert "gtrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      dlfPtr <- Call.array dlf+      dfPtr <- Call.array df+      dufPtr <- Call.array duf+      du2Ptr <- Call.array du2+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gtrfs transPtr nPtr nrhsPtr dlPtr dPtr duPtr dlfPtr dfPtr dufPtr du2Ptr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtsv.f>+gtsv ::+   IOCArray Int (Complex Double) {- ^ dl -} ->+   IOCArray Int (Complex Double) {- ^ d -} ->+   IOCArray Int (Complex Double) {- ^ du -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+gtsv dl d du b = do+   dlDim0 <- Call.sizes1 <$> getBounds dl+   dDim0 <- Call.sizes1 <$> getBounds d+   duDim0 <- Call.sizes1 <$> getBounds du+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gtsv: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gtsv: n-1 == duDim0" (n-1 == duDim0)+   evalContT $ do+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dlPtr <- Call.ioarray dl+      dPtr <- Call.ioarray d+      duPtr <- Call.ioarray du+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.gtsv nPtr nrhsPtr dlPtr dPtr duPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtsvx.f>+gtsvx ::+   Char {- ^ fact -} ->+   Char {- ^ trans -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   IOCArray Int (Complex Double) {- ^ dlf -} ->+   IOCArray Int (Complex Double) {- ^ df -} ->+   IOCArray Int (Complex Double) {- ^ duf -} ->+   IOCArray Int (Complex Double) {- ^ du2 -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+gtsvx fact trans dl d du dlf df duf du2 ipiv b ldx = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   dlfDim0 <- Call.sizes1 <$> getBounds dlf+   dfDim0 <- Call.sizes1 <$> getBounds df+   dufDim0 <- Call.sizes1 <$> getBounds duf+   du2Dim0 <- Call.sizes1 <$> getBounds du2+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gtsvx: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gtsvx: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "gtsvx: n-1 == dlfDim0" (n-1 == dlfDim0)+   Call.assert "gtsvx: n == dfDim0" (n == dfDim0)+   Call.assert "gtsvx: n-1 == dufDim0" (n-1 == dufDim0)+   Call.assert "gtsvx: n-2 == du2Dim0" (n-2 == du2Dim0)+   Call.assert "gtsvx: n == ipivDim0" (n == ipivDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      dlfPtr <- Call.ioarray dlf+      dfPtr <- Call.ioarray df+      dufPtr <- Call.ioarray duf+      du2Ptr <- Call.ioarray du2+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.gtsvx factPtr transPtr nPtr nrhsPtr dlPtr dPtr duPtr dlfPtr dfPtr dufPtr du2Ptr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgttrf.f>+gttrf ::+   IOCArray Int (Complex Double) {- ^ dl -} ->+   IOCArray Int (Complex Double) {- ^ d -} ->+   IOCArray Int (Complex Double) {- ^ du -} ->+   IO (CArray Int (Complex Double), CArray Int CInt, Int)+gttrf dl d du = do+   dlDim0 <- Call.sizes1 <$> getBounds dl+   dDim0 <- Call.sizes1 <$> getBounds d+   duDim0 <- Call.sizes1 <$> getBounds du+   let n = dDim0+   Call.assert "gttrf: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gttrf: n-1 == duDim0" (n-1 == duDim0)+   du2 <- Call.newArray1 (n-2)+   ipiv <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      dlPtr <- Call.ioarray dl+      dPtr <- Call.ioarray d+      duPtr <- Call.ioarray du+      du2Ptr <- Call.ioarray du2+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.gttrf nPtr dlPtr dPtr duPtr du2Ptr ipivPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray du2+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgttrs.f>+gttrs ::+   Char {- ^ trans -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   CArray Int (Complex Double) {- ^ du2 -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+gttrs trans dl d du du2 ipiv b = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let du2Dim0 = Call.sizes1 $ bounds du2+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gttrs: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gttrs: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "gttrs: n-2 == du2Dim0" (n-2 == du2Dim0)+   Call.assert "gttrs: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      du2Ptr <- Call.array du2+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.gttrs transPtr nPtr nrhsPtr dlPtr dPtr duPtr du2Ptr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zgtts2.f>+gtts2 ::+   Int {- ^ itrans -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   CArray Int (Complex Double) {- ^ du2 -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO ()+gtts2 itrans dl d du du2 ipiv b = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let du2Dim0 = Call.sizes1 $ bounds du2+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "gtts2: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "gtts2: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "gtts2: n-2 == du2Dim0" (n-2 == du2Dim0)+   Call.assert "gtts2: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      itransPtr <- Call.cint itrans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      du2Ptr <- Call.array du2+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.gtts2 itransPtr nPtr nrhsPtr dlPtr dPtr duPtr du2Ptr ipivPtr bPtr ldbPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbev.f>+hbev ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ ldz -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hbev jobz uplo kd ab ldz = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 n+   rwork <- Call.newArray1 (maximum[1,3*n-2])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hbev jobzPtr uploPtr nPtr kdPtr abPtr ldabPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbevd.f>+hbevd ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ rworkSize -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hbevd jobz uplo kd ab ldz lwork rworkSize lrwork liwork = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hbevd jobzPtr uploPtr nPtr kdPtr abPtr ldabPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbevx.f>+hbevx ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ ldq -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   IO (CArray (Int,Int) (Complex Double), Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+hbevx jobz range uplo kd ab ldq vl vu il iu abstol m ldz = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   q <- Call.newArray2 n ldq+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   work <- Call.newArray1 n+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.hbevx jobzPtr rangePtr uploPtr nPtr kdPtr abPtr ldabPtr qPtr ldqPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray q+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgst.f>+hbgst ::+   Char {- ^ vect -} ->+   Char {- ^ uplo -} ->+   Int {- ^ ka -} ->+   Int {- ^ kb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray (Int,Int) (Complex Double) {- ^ bb -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+hbgst vect uplo ka kb ab bb ldx = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let (bbDim0,bbDim1) = Call.sizes2 $ bounds bb+   let n = abDim0+   let ldab = abDim1+   let ldbb = bbDim1+   Call.assert "hbgst: n == bbDim0" (n == bbDim0)+   x <- Call.newArray2 n ldx+   work <- Call.newArray1 n+   rwork <- Call.newArray1 n+   evalContT $ do+      vectPtr <- Call.char vect+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kaPtr <- Call.cint ka+      kbPtr <- Call.cint kb+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      bbPtr <- Call.array bb+      ldbbPtr <- Call.cint ldbb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hbgst vectPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr xPtr ldxPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray x+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgv.f>+hbgv ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ ka -} ->+   Int {- ^ kb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->+   Int {- ^ ldz -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hbgv jobz uplo ka kb ab bb ldz = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb+   let n = abDim0+   let ldab = abDim1+   let ldbb = bbDim1+   Call.assert "hbgv: n == bbDim0" (n == bbDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 n+   rwork <- Call.newArray1 (3*n)+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kaPtr <- Call.cint ka+      kbPtr <- Call.cint kb+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      bbPtr <- Call.ioarray bb+      ldbbPtr <- Call.cint ldbb+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hbgv jobzPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgvd.f>+hbgvd ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ ka -} ->+   Int {- ^ kb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hbgvd jobz uplo ka kb ab bb ldz lwork lrwork liwork = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb+   let n = abDim0+   let ldab = abDim1+   let ldbb = bbDim1+   Call.assert "hbgvd: n == bbDim0" (n == bbDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kaPtr <- Call.cint ka+      kbPtr <- Call.cint kb+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      bbPtr <- Call.ioarray bb+      ldbbPtr <- Call.cint ldbb+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hbgvd jobzPtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbgvx.f>+hbgvx ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   Int {- ^ ka -} ->+   Int {- ^ kb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ bb -} ->+   Int {- ^ ldq -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ ldz -} ->+   IO (CArray (Int,Int) (Complex Double), Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+hbgvx jobz range uplo ka kb ab bb ldq vl vu il iu abstol ldz = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (bbDim0,bbDim1) <- Call.sizes2 <$> getBounds bb+   let n = abDim0+   let ldab = abDim1+   let ldbb = bbDim1+   Call.assert "hbgvx: n == bbDim0" (n == bbDim0)+   q <- Call.newArray2 n ldq+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 n+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kaPtr <- Call.cint ka+      kbPtr <- Call.cint kb+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      bbPtr <- Call.ioarray bb+      ldbbPtr <- Call.cint ldbb+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.hbgvx jobzPtr rangePtr uploPtr nPtr kaPtr kbPtr abPtr ldabPtr bbPtr ldbbPtr qPtr ldqPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray q+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhbtrd.f>+hbtrd ::+   Char {- ^ vect -} ->+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IO (CArray Int Double, CArray Int Double, Int)+hbtrd vect uplo kd ab q = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   let n = abDim0+   let ldab = abDim1+   let ldq = qDim1+   Call.assert "hbtrd: n == qDim0" (n == qDim0)+   d <- Call.newArray1 n+   e <- Call.newArray1 (n-1)+   work <- Call.newArray1 n+   evalContT $ do+      vectPtr <- Call.char vect+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hbtrd vectPtr uploPtr nPtr kdPtr abPtr ldabPtr dPtr ePtr qPtr ldqPtr workPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhecon.f>+hecon ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+hecon uplo a ipiv anorm = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "hecon: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hecon uploPtr nPtr aPtr ldaPtr ipivPtr anormPtr rcondPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheequb.f>+heequb ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, Double, Double, Int)+heequb uplo a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 n+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.heequb uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr workPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheev.f>+heev ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, Int)+heev jobz uplo a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,3*n-2])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      wPtr <- Call.ioarray w+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.heev jobzPtr uploPtr nPtr aPtr ldaPtr wPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevd.f>+heevd ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   Int {- ^ rworkSize -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, Int)+heevd jobz uplo a lwork rworkSize lrwork liwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      wPtr <- Call.ioarray w+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.heevd jobzPtr uploPtr nPtr aPtr ldaPtr wPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevr.f>+heevr ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+heevr jobz range uplo a vl vu il iu abstol m ldz lwork lrwork liwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   isuppz <- Call.newArray1 (2*maximum[1,m])+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      isuppzPtr <- Call.ioarray isuppz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.heevr jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr isuppzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray isuppz+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheevx.f>+heevx ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+heevx jobz range uplo a vl vu il iu abstol m ldz lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.heevx jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegs2.f>+hegs2 ::+   Int {- ^ itype -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+hegs2 itype uplo a b = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "hegs2: n == bDim0" (n == bDim0)+   evalContT $ do+      itypePtr <- Call.cint itype+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.hegs2 itypePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegst.f>+hegst ::+   Int {- ^ itype -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+hegst itype uplo a b = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "hegst: n == bDim0" (n == bDim0)+   evalContT $ do+      itypePtr <- Call.cint itype+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.hegst itypePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegv.f>+hegv ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, Int)+hegv itype jobz uplo a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "hegv: n == bDim0" (n == bDim0)+   w <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,3*n-2])+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      wPtr <- Call.ioarray w+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hegv itypePtr jobzPtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr wPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegvd.f>+hegvd ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, Int)+hegvd itype jobz uplo a b lwork lrwork liwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "hegvd: n == bDim0" (n == bDim0)+   w <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      wPtr <- Call.ioarray w+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hegvd itypePtr jobzPtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr wPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhegvx.f>+hegvx ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+hegvx itype jobz range uplo a b vl vu il iu abstol m ldz lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "hegvx: n == bDim0" (n == bDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.hegvx itypePtr jobzPtr rangePtr uploPtr nPtr aPtr ldaPtr bPtr ldbPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zherfs.f>+herfs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ af -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+herfs uplo a af ipiv b x = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (afDim0,afDim1) = Call.sizes2 $ bounds af+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "herfs: n == afDim0" (n == afDim0)+   Call.assert "herfs: n == ipivDim0" (n == ipivDim0)+   Call.assert "herfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.array af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.herfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhesv.f>+hesv ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int CInt, Int)+hesv uplo a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   ipiv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hesv uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhesvx.f>+hesvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   Int {- ^ lwork -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+hesvx fact uplo a af ipiv b ldx lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hesvx: n == afDim0" (n == afDim0)+   Call.assert "hesvx: n == ipivDim0" (n == ipivDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.ioarray af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hesvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zheswapr.f>+heswapr ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ i1 -} ->+   Int {- ^ i2 -} ->+   IO ()+heswapr uplo a i1 i2 = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      i1Ptr <- Call.cint i1+      i2Ptr <- Call.cint i2+      liftIO $ FFI.heswapr uploPtr nPtr aPtr ldaPtr i1Ptr i2Ptr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetd2.f>+hetd2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)+hetd2 uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   d <- Call.newArray1 n+   e <- Call.newArray1 (n-1)+   tau <- Call.newArray1 (n-1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauPtr <- Call.ioarray tau+      infoPtr <- Call.alloca+      liftIO $ FFI.hetd2 uploPtr nPtr aPtr ldaPtr dPtr ePtr tauPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetf2.f>+hetf2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int CInt, Int)+hetf2 uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.hetf2 uploPtr nPtr aPtr ldaPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrd.f>+hetrd ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)+hetrd uplo a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   d <- Call.newArray1 n+   e <- Call.newArray1 (n-1)+   tau <- Call.newArray1 (n-1)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hetrd uploPtr nPtr aPtr ldaPtr dPtr ePtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrf.f>+hetrf ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int CInt, Int)+hetrf uplo a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hetrf uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri.f>+hetri ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IO (Int)+hetri uplo a ipiv = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "hetri: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hetri uploPtr nPtr aPtr ldaPtr ipivPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri2.f>+hetri2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ nb -} ->+   Int {- ^ lwork -} ->+   IO (Int)+hetri2 uplo a ipiv nb lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "hetri2: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (n+nb+1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hetri2 uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetri2x.f>+hetri2x ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ nb -} ->+   IO (Int)+hetri2x uplo a ipiv nb = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "hetri2x: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray2 (nb+3) (n+nb+1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      nbPtr <- Call.cint nb+      infoPtr <- Call.alloca+      liftIO $ FFI.hetri2x uploPtr nPtr aPtr ldaPtr ipivPtr workPtr nbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrs.f>+hetrs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+hetrs uplo a ipiv b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hetrs: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.hetrs uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhetrs2.f>+hetrs2 ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+hetrs2 uplo a ipiv b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hetrs2: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hetrs2 uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhfrk.f>+hfrk ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Int {- ^ n -} ->+   Int {- ^ k -} ->+   Double {- ^ alpha -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ beta -} ->+   IOCArray Int (Complex Double) {- ^ c -} ->+   IO ()+hfrk transr uplo trans n k alpha a beta c = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   cDim0 <- Call.sizes1 <$> getBounds c+   let _ka = aDim0+   let lda = aDim1+   Call.assert "hfrk: n*(n+1)`div`2 == cDim0" (n*(n+1)`div`2 == cDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      alphaPtr <- Call.double alpha+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      betaPtr <- Call.double beta+      cPtr <- Call.ioarray c+      liftIO $ FFI.hfrk transrPtr uploPtr transPtr nPtr kPtr alphaPtr aPtr ldaPtr betaPtr cPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhgeqz.f>+hgeqz ::+   Char {- ^ job -} ->+   Char {- ^ compq -} ->+   Char {- ^ compz -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int)+hgeqz job compq compz ilo ihi h t q z lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ldt = tDim1+   let ldq = qDim1+   let ldz = zDim1+   Call.assert "hgeqz: n == tDim0" (n == tDim0)+   Call.assert "hgeqz: n == qDim0" (n == qDim0)+   Call.assert "hgeqz: n == zDim0" (n == zDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 n+   evalContT $ do+      jobPtr <- Call.char job+      compqPtr <- Call.char compq+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hgeqz jobPtr compqPtr compzPtr nPtr iloPtr ihiPtr hPtr ldhPtr tPtr ldtPtr alphaPtr betaPtr qPtr ldqPtr zPtr ldzPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpcon.f>+hpcon ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+hpcon uplo ap ipiv anorm = do+   let apDim0 = Call.sizes1 $ bounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = ipivDim0+   Call.assert "hpcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hpcon uploPtr nPtr apPtr ipivPtr anormPtr rcondPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpev.f>+hpev ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ ldz -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hpev jobz uplo n ap ldz = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "hpev: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,2*n-1])+   rwork <- Call.newArray1 (maximum[1,3*n-2])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hpev jobzPtr uploPtr nPtr apPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpevd.f>+hpevd ::+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hpevd jobz uplo n ap ldz lwork lrwork liwork = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "hpevd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hpevd jobzPtr uploPtr nPtr apPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpevx.f>+hpevx ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+hpevx jobz range uplo n ap vl vu il iu abstol m ldz = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "hpevx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.hpevx jobzPtr rangePtr uploPtr nPtr apPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgst.f>+hpgst ::+   Int {- ^ itype -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ bp -} ->+   IO (Int)+hpgst itype uplo n ap bp = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   let bpDim0 = Call.sizes1 $ bounds bp+   Call.assert "hpgst: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hpgst: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)+   evalContT $ do+      itypePtr <- Call.cint itype+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      bpPtr <- Call.array bp+      infoPtr <- Call.alloca+      liftIO $ FFI.hpgst itypePtr uploPtr nPtr apPtr bpPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgv.f>+hpgv ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ bp -} ->+   Int {- ^ ldz -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hpgv itype jobz uplo n ap bp ldz = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   bpDim0 <- Call.sizes1 <$> getBounds bp+   Call.assert "hpgv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hpgv: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,2*n-1])+   rwork <- Call.newArray1 (maximum[1,3*n-2])+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      bpPtr <- Call.ioarray bp+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hpgv itypePtr jobzPtr uploPtr nPtr apPtr bpPtr wPtr zPtr ldzPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgvd.f>+hpgvd ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ bp -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), Int)+hpgvd itype jobz uplo n ap bp ldz lwork lrwork liwork = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   bpDim0 <- Call.sizes1 <$> getBounds bp+   Call.assert "hpgvd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hpgvd: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      bpPtr <- Call.ioarray bp+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hpgvd itypePtr jobzPtr uploPtr nPtr apPtr bpPtr wPtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpgvx.f>+hpgvx ::+   Int {- ^ itype -} ->+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ bp -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ ldz -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+hpgvx itype jobz range uplo n ap bp vl vu il iu abstol ldz = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   bpDim0 <- Call.sizes1 <$> getBounds bp+   Call.assert "hpgvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hpgvx: n*(n+1)`div`2 == bpDim0" (n*(n+1)`div`2 == bpDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 n ldz+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 (7*n)+   iwork <- Call.newArray1 (5*n)+   ifail <- Call.newArray1 n+   evalContT $ do+      itypePtr <- Call.cint itype+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      bpPtr <- Call.ioarray bp+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.hpgvx itypePtr jobzPtr rangePtr uploPtr nPtr apPtr bpPtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr workPtr rworkPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhprfs.f>+hprfs ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ afp -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+hprfs uplo ap afp ipiv b x = do+   let apDim0 = Call.sizes1 $ bounds ap+   let afpDim0 = Call.sizes1 $ bounds afp+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "hprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   Call.assert "hprfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      afpPtr <- Call.array afp+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hprfs uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpsv.f>+hpsv ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (CArray Int CInt, Int)+hpsv uplo n ap b = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hpsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.hpsv uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhpsvx.f>+hpsvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ afp -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+hpsvx fact uplo ap afp ipiv b ldx = do+   let apDim0 = Call.sizes1 $ bounds ap+   afpDim0 <- Call.sizes1 <$> getBounds afp+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hpsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "hpsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      afpPtr <- Call.ioarray afp+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hpsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrd.f>+hptrd ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), Int)+hptrd uplo n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "hptrd: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   d <- Call.newArray1 n+   e <- Call.newArray1 (n-1)+   tau <- Call.newArray1 (n-1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauPtr <- Call.ioarray tau+      infoPtr <- Call.alloca+      liftIO $ FFI.hptrd uploPtr nPtr apPtr dPtr ePtr tauPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrf.f>+hptrf ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (CArray Int CInt, Int)+hptrf uplo n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "hptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.hptrf uploPtr nPtr apPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptri.f>+hptri ::+   Char {- ^ uplo -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IO (Int)+hptri uplo ap ipiv = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = ipivDim0+   Call.assert "hptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.hptri uploPtr nPtr apPtr ipivPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhptrs.f>+hptrs ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+hptrs uplo ap ipiv b = do+   let apDim0 = Call.sizes1 $ bounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "hptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.hptrs uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhsein.f>+hsein ::+   Char {- ^ side -} ->+   Char {- ^ eigsrc -} ->+   Char {- ^ initv -} ->+   CArray Int Bool {- ^ select -} ->+   CArray (Int,Int) (Complex Double) {- ^ h -} ->+   IOCArray Int (Complex Double) {- ^ w -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->+   IO (Int, CArray Int CInt, CArray Int CInt, Int)+hsein side eigsrc initv select h w vl vr = do+   let selectDim0 = Call.sizes1 $ bounds select+   let (hDim0,hDim1) = Call.sizes2 $ bounds h+   wDim0 <- Call.sizes1 <$> getBounds w+   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl+   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr+   let n = selectDim0+   let ldh = hDim1+   let mm = vlDim0+   let ldvl = vlDim1+   let ldvr = vrDim1+   Call.assert "hsein: n == hDim0" (n == hDim0)+   Call.assert "hsein: n == wDim0" (n == wDim0)+   Call.assert "hsein: mm == vrDim0" (mm == vrDim0)+   work <- Call.newArray1 (n*n)+   rwork <- Call.newArray1 n+   ifaill <- Call.newArray1 mm+   ifailr <- Call.newArray1 mm+   evalContT $ do+      sidePtr <- Call.char side+      eigsrcPtr <- Call.char eigsrc+      initvPtr <- Call.char initv+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      hPtr <- Call.array h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.ioarray w+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      mmPtr <- Call.cint mm+      mPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      ifaillPtr <- Call.ioarray ifaill+      ifailrPtr <- Call.ioarray ifailr+      infoPtr <- Call.alloca+      liftIO $ FFI.hsein sidePtr eigsrcPtr initvPtr selectPtr nPtr hPtr ldhPtr wPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr ifaillPtr ifailrPtr infoPtr+      liftIO $ pure (,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray ifaill+         <*> Call.freezeArray ifailr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zhseqr.f>+hseqr ::+   Char {- ^ job -} ->+   Char {- ^ compz -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+hseqr job compz ilo ihi h z lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ldz = zDim1+   Call.assert "hseqr: n == zDim0" (n == zDim0)+   w <- Call.newArray1 n+   work <- Call.newArray1 lwork+   evalContT $ do+      jobPtr <- Call.char job+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.hseqr jobPtr compzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr zPtr ldzPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ilazlc.f>+ilalc ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO CInt+ilalc m a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      liftIO $ FFI.ilalc mPtr nPtr aPtr ldaPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ilazlr.f>+ilalr ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO CInt+ilalr m a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      liftIO $ FFI.ilalr mPtr nPtr aPtr ldaPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/izmax1.f>+imax1 ::+   CArray Int (Complex Double) {- ^ zx -} ->+   Int {- ^ incx -} ->+   IO CInt+imax1 zx incx = do+   let zxDim0 = Call.sizes1 $ bounds zx+   let n = zxDim0+   evalContT $ do+      nPtr <- Call.cint n+      zxPtr <- Call.array zx+      incxPtr <- Call.cint incx+      liftIO $ FFI.imax1 nPtr zxPtr incxPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlabrd.f>+labrd ::+   Int {- ^ m -} ->+   Int {- ^ nb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldx -} ->+   Int {- ^ ldy -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))+labrd m nb a ldx ldy = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   d <- Call.newArray1 nb+   e <- Call.newArray1 nb+   tauq <- Call.newArray1 nb+   taup <- Call.newArray1 nb+   x <- Call.newArray2 nb ldx+   y <- Call.newArray2 nb ldy+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      nbPtr <- Call.cint nb+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      tauqPtr <- Call.ioarray tauq+      taupPtr <- Call.ioarray taup+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      yPtr <- Call.ioarray y+      ldyPtr <- Call.cint ldy+      liftIO $ FFI.labrd mPtr nPtr nbPtr aPtr ldaPtr dPtr ePtr tauqPtr taupPtr xPtr ldxPtr yPtr ldyPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray d+         <*> Call.freezeArray e+         <*> Call.freezeArray tauq+         <*> Call.freezeArray taup+         <*> Call.freezeArray x+         <*> Call.freezeArray y++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacgv.f>+lacgv ::+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IO ()+lacgv n x incx = do+   xDim0 <- Call.sizes1 <$> getBounds x+   let _xSize = xDim0+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      liftIO $ FFI.lacgv nPtr xPtr incxPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacn2.f>+lacn2 ::+   IOCArray Int (Complex Double) {- ^ x -} ->+   Double {- ^ est -} ->+   Int {- ^ kase -} ->+   IOCArray Int CInt {- ^ isave -} ->+   IO (CArray Int (Complex Double), Double, Int)+lacn2 x est kase isave = do+   xDim0 <- Call.sizes1 <$> getBounds x+   isaveDim0 <- Call.sizes1 <$> getBounds isave+   let n = xDim0+   Call.assert "lacn2: 3 == isaveDim0" (3 == isaveDim0)+   v <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      vPtr <- Call.ioarray v+      xPtr <- Call.ioarray x+      estPtr <- Call.double est+      kasePtr <- Call.cint kase+      isavePtr <- Call.ioarray isave+      liftIO $ FFI.lacn2 nPtr vPtr xPtr estPtr kasePtr isavePtr+      liftIO $ pure (,,)+         <*> Call.freezeArray v+         <*> peek estPtr+         <*> fmap fromIntegral (peek kasePtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacon.f>+lacon ::+   IOCArray Int (Complex Double) {- ^ x -} ->+   Double {- ^ est -} ->+   Int {- ^ kase -} ->+   IO (CArray Int (Complex Double), Double, Int)+lacon x est kase = do+   xDim0 <- Call.sizes1 <$> getBounds x+   let n = xDim0+   v <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      vPtr <- Call.ioarray v+      xPtr <- Call.ioarray x+      estPtr <- Call.double est+      kasePtr <- Call.cint kase+      liftIO $ FFI.lacon nPtr vPtr xPtr estPtr kasePtr+      liftIO $ pure (,,)+         <*> Call.freezeArray v+         <*> peek estPtr+         <*> fmap fromIntegral (peek kasePtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacp2.f>+lacp2 ::+   Char {- ^ uplo -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) Double {- ^ a -} ->+   Int {- ^ ldb -} ->+   IO (CArray (Int,Int) (Complex Double))+lacp2 uplo m a ldb = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   b <- Call.newArray2 n ldb+   evalContT $ do+      uploPtr <- Call.char uplo+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.lacp2 uploPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr+      liftIO $ Call.freezeArray b++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacpy.f>+lacpy ::+   Char {- ^ uplo -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldb -} ->+   IO (CArray (Int,Int) (Complex Double))+lacpy uplo m a ldb = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   b <- Call.newArray2 n ldb+   evalContT $ do+      uploPtr <- Call.char uplo+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.lacpy uploPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr+      liftIO $ Call.freezeArray b++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacrm.f>+lacrm ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) Double {- ^ b -} ->+   Int {- ^ ldc -} ->+   IO (CArray (Int,Int) (Complex Double))+lacrm m a b ldc = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   Call.assert "lacrm: n == bDim0" (n == bDim0)+   c <- Call.newArray2 n ldc+   rwork <- Call.newArray1 (2*m*n)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      rworkPtr <- Call.ioarray rwork+      liftIO $ FFI.lacrm mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr rworkPtr+      liftIO $ Call.freezeArray c++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlacrt.f>+lacrt ::+   IOCArray Int (Complex Double) {- ^ cx -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ cy -} ->+   Int {- ^ incy -} ->+   Complex Double {- ^ c -} ->+   Complex Double {- ^ s -} ->+   IO ()+lacrt cx incx cy incy c s = do+   cxDim0 <- Call.sizes1 <$> getBounds cx+   cyDim0 <- Call.sizes1 <$> getBounds cy+   let n = cxDim0+   Call.assert "lacrt: n == cyDim0" (n == cyDim0)+   evalContT $ do+      nPtr <- Call.cint n+      cxPtr <- Call.ioarray cx+      incxPtr <- Call.cint incx+      cyPtr <- Call.ioarray cy+      incyPtr <- Call.cint incy+      cPtr <- Call.complexDouble c+      sPtr <- Call.complexDouble s+      liftIO $ FFI.lacrt nPtr cxPtr incxPtr cyPtr incyPtr cPtr sPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed0.f>+laed0 ::+   Int {- ^ qsiz -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   Int {- ^ ldqs -} ->+   Int {- ^ rworkSize -} ->+   Int {- ^ iworkSize -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+laed0 qsiz d e q ldqs rworkSize iworkSize = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   let n = dDim0+   let ldq = qDim1+   Call.assert "laed0: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "laed0: n == qDim0" (n == qDim0)+   qstore <- Call.newArray2 n ldqs+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 iworkSize+   evalContT $ do+      qsizPtr <- Call.cint qsiz+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      qstorePtr <- Call.ioarray qstore+      ldqsPtr <- Call.cint ldqs+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.laed0 qsizPtr nPtr dPtr ePtr qPtr ldqPtr qstorePtr ldqsPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray qstore+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed7.f>+laed7 ::+   Int {- ^ cutpnt -} ->+   Int {- ^ qsiz -} ->+   Int {- ^ tlvls -} ->+   Int {- ^ curlvl -} ->+   Int {- ^ curpbm -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   Double {- ^ rho -} ->+   IOCArray Int Double {- ^ qstore -} ->+   IOCArray Int CInt {- ^ qptr -} ->+   CArray Int CInt {- ^ prmptr -} ->+   CArray Int CInt {- ^ perm -} ->+   CArray Int CInt {- ^ givptr -} ->+   CArray (Int,Int) CInt {- ^ givcol -} ->+   CArray (Int,Int) Double {- ^ givnum -} ->+   Int {- ^ rworkSize -} ->+   IO (CArray Int CInt, Int)+laed7 cutpnt qsiz tlvls curlvl curpbm d q rho qstore qptr prmptr perm givptr givcol givnum rworkSize = do+   dDim0 <- Call.sizes1 <$> getBounds d+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   qstoreDim0 <- Call.sizes1 <$> getBounds qstore+   qptrDim0 <- Call.sizes1 <$> getBounds qptr+   let prmptrDim0 = Call.sizes1 $ bounds prmptr+   let permDim0 = Call.sizes1 $ bounds perm+   let givptrDim0 = Call.sizes1 $ bounds givptr+   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol+   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum+   let n = dDim0+   let ldq = qDim1+   let nlgn = prmptrDim0+   Call.assert "laed7: n == qDim0" (n == qDim0)+   Call.assert "laed7: n^!2+1 == qstoreDim0" (n^!2+1 == qstoreDim0)+   Call.assert "laed7: n+2 == qptrDim0" (n+2 == qptrDim0)+   Call.assert "laed7: nlgn == permDim0" (nlgn == permDim0)+   Call.assert "laed7: nlgn == givptrDim0" (nlgn == givptrDim0)+   Call.assert "laed7: nlgn == givcolDim0" (nlgn == givcolDim0)+   Call.assert "laed7: 2 == givcolDim1" (2 == givcolDim1)+   Call.assert "laed7: nlgn == givnumDim0" (nlgn == givnumDim0)+   Call.assert "laed7: 2 == givnumDim1" (2 == givnumDim1)+   indxq <- Call.newArray1 n+   work <- Call.newArray1 (qsiz*n)+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 (4*n)+   evalContT $ do+      nPtr <- Call.cint n+      cutpntPtr <- Call.cint cutpnt+      qsizPtr <- Call.cint qsiz+      tlvlsPtr <- Call.cint tlvls+      curlvlPtr <- Call.cint curlvl+      curpbmPtr <- Call.cint curpbm+      dPtr <- Call.ioarray d+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      rhoPtr <- Call.double rho+      indxqPtr <- Call.ioarray indxq+      qstorePtr <- Call.ioarray qstore+      qptrPtr <- Call.ioarray qptr+      prmptrPtr <- Call.array prmptr+      permPtr <- Call.array perm+      givptrPtr <- Call.array givptr+      givcolPtr <- Call.array givcol+      givnumPtr <- Call.array givnum+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.laed7 nPtr cutpntPtr qsizPtr tlvlsPtr curlvlPtr curpbmPtr dPtr qPtr ldqPtr rhoPtr indxqPtr qstorePtr qptrPtr prmptrPtr permPtr givptrPtr givcolPtr givnumPtr workPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray indxq+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaed8.f>+laed8 ::+   Int {- ^ qsiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray Int Double {- ^ d -} ->+   Double {- ^ rho -} ->+   Int {- ^ cutpnt -} ->+   CArray Int Double {- ^ z -} ->+   Int {- ^ ldq2 -} ->+   CArray Int CInt {- ^ indxq -} ->+   IO (Int, Double, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int Double, CArray Int CInt, CArray Int CInt, CArray Int CInt, Int, CArray (Int,Int) CInt, CArray (Int,Int) Double, Int)+laed8 qsiz q d rho cutpnt z ldq2 indxq = do+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   dDim0 <- Call.sizes1 <$> getBounds d+   let zDim0 = Call.sizes1 $ bounds z+   let indxqDim0 = Call.sizes1 $ bounds indxq+   let n = qDim0+   let ldq = qDim1+   Call.assert "laed8: n == dDim0" (n == dDim0)+   Call.assert "laed8: n == zDim0" (n == zDim0)+   Call.assert "laed8: n == indxqDim0" (n == indxqDim0)+   dlamda <- Call.newArray1 n+   q2 <- Call.newArray2 n ldq2+   w <- Call.newArray1 n+   indxp <- Call.newArray1 n+   indx <- Call.newArray1 n+   perm <- Call.newArray1 n+   givcol <- Call.newArray2 n 2+   givnum <- Call.newArray2 n 2+   evalContT $ do+      kPtr <- Call.alloca+      nPtr <- Call.cint n+      qsizPtr <- Call.cint qsiz+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      dPtr <- Call.ioarray d+      rhoPtr <- Call.double rho+      cutpntPtr <- Call.cint cutpnt+      zPtr <- Call.array z+      dlamdaPtr <- Call.ioarray dlamda+      q2Ptr <- Call.ioarray q2+      ldq2Ptr <- Call.cint ldq2+      wPtr <- Call.ioarray w+      indxpPtr <- Call.ioarray indxp+      indxPtr <- Call.ioarray indx+      indxqPtr <- Call.array indxq+      permPtr <- Call.ioarray perm+      givptrPtr <- Call.alloca+      givcolPtr <- Call.ioarray givcol+      givnumPtr <- Call.ioarray givnum+      infoPtr <- Call.alloca+      liftIO $ FFI.laed8 kPtr nPtr qsizPtr qPtr ldqPtr dPtr rhoPtr cutpntPtr zPtr dlamdaPtr q2Ptr ldq2Ptr wPtr indxpPtr indxPtr indxqPtr permPtr givptrPtr givcolPtr givnumPtr infoPtr+      liftIO $ pure (,,,,,,,,,,,)+         <*> fmap fromIntegral (peek kPtr)+         <*> peek rhoPtr+         <*> Call.freezeArray dlamda+         <*> Call.freezeArray q2+         <*> Call.freezeArray w+         <*> Call.freezeArray indxp+         <*> Call.freezeArray indx+         <*> Call.freezeArray perm+         <*> fmap fromIntegral (peek givptrPtr)+         <*> Call.freezeArray givcol+         <*> Call.freezeArray givnum+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaein.f>+laein ::+   Bool {- ^ rightv -} ->+   Bool {- ^ noinit -} ->+   CArray (Int,Int) (Complex Double) {- ^ h -} ->+   Complex Double {- ^ w -} ->+   IOCArray Int (Complex Double) {- ^ v -} ->+   Int {- ^ ldb -} ->+   Double {- ^ eps3 -} ->+   Double {- ^ smlnum -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+laein rightv noinit h w v ldb eps3 smlnum = do+   let (hDim0,hDim1) = Call.sizes2 $ bounds h+   vDim0 <- Call.sizes1 <$> getBounds v+   let n = hDim0+   let ldh = hDim1+   Call.assert "laein: n == vDim0" (n == vDim0)+   b <- Call.newArray2 n ldb+   rwork <- Call.newArray1 n+   evalContT $ do+      rightvPtr <- Call.bool rightv+      noinitPtr <- Call.bool noinit+      nPtr <- Call.cint n+      hPtr <- Call.array h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.complexDouble w+      vPtr <- Call.ioarray v+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      rworkPtr <- Call.ioarray rwork+      eps3Ptr <- Call.double eps3+      smlnumPtr <- Call.double smlnum+      infoPtr <- Call.alloca+      liftIO $ FFI.laein rightvPtr noinitPtr nPtr hPtr ldhPtr wPtr vPtr bPtr ldbPtr rworkPtr eps3Ptr smlnumPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray b+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaesy.f>+laesy ::+   Complex Double {- ^ a -} ->+   Complex Double {- ^ b -} ->+   Complex Double {- ^ c -} ->+   IO (Complex Double, Complex Double, Complex Double, Complex Double, Complex Double)+laesy a b c = do+   evalContT $ do+      aPtr <- Call.complexDouble a+      bPtr <- Call.complexDouble b+      cPtr <- Call.complexDouble c+      rt1Ptr <- Call.alloca+      rt2Ptr <- Call.alloca+      evscalPtr <- Call.alloca+      cs1Ptr <- Call.alloca+      sn1Ptr <- Call.alloca+      liftIO $ FFI.laesy aPtr bPtr cPtr rt1Ptr rt2Ptr evscalPtr cs1Ptr sn1Ptr+      liftIO $ pure (,,,,)+         <*> peek rt1Ptr+         <*> peek rt2Ptr+         <*> peek evscalPtr+         <*> peek cs1Ptr+         <*> peek sn1Ptr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaev2.f>+laev2 ::+   Complex Double {- ^ a -} ->+   Complex Double {- ^ b -} ->+   Complex Double {- ^ c -} ->+   IO (Double, Double, Double, Complex Double)+laev2 a b c = do+   evalContT $ do+      aPtr <- Call.complexDouble a+      bPtr <- Call.complexDouble b+      cPtr <- Call.complexDouble c+      rt1Ptr <- Call.alloca+      rt2Ptr <- Call.alloca+      cs1Ptr <- Call.alloca+      sn1Ptr <- Call.alloca+      liftIO $ FFI.laev2 aPtr bPtr cPtr rt1Ptr rt2Ptr cs1Ptr sn1Ptr+      liftIO $ pure (,,,)+         <*> peek rt1Ptr+         <*> peek rt2Ptr+         <*> peek cs1Ptr+         <*> peek sn1Ptr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlag2c.f>+lag2c ::+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldsa -} ->+   IO (CArray (Int,Int) (Complex Float), Int)+lag2c m a ldsa = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   sa <- Call.newArray2 n ldsa+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      saPtr <- Call.ioarray sa+      ldsaPtr <- Call.cint ldsa+      infoPtr <- Call.alloca+      liftIO $ FFI.lag2c mPtr nPtr aPtr ldaPtr saPtr ldsaPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray sa+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlags2.f>+lags2 ::+   Bool {- ^ upper -} ->+   Double {- ^ a1 -} ->+   Complex Double {- ^ a2 -} ->+   Double {- ^ a3 -} ->+   Double {- ^ b1 -} ->+   Complex Double {- ^ b2 -} ->+   Double {- ^ b3 -} ->+   IO (Double, Complex Double, Double, Complex Double, Double, Complex Double)+lags2 upper a1 a2 a3 b1 b2 b3 = do+   evalContT $ do+      upperPtr <- Call.bool upper+      a1Ptr <- Call.double a1+      a2Ptr <- Call.complexDouble a2+      a3Ptr <- Call.double a3+      b1Ptr <- Call.double b1+      b2Ptr <- Call.complexDouble b2+      b3Ptr <- Call.double b3+      csuPtr <- Call.alloca+      snuPtr <- Call.alloca+      csvPtr <- Call.alloca+      snvPtr <- Call.alloca+      csqPtr <- Call.alloca+      snqPtr <- Call.alloca+      liftIO $ FFI.lags2 upperPtr a1Ptr a2Ptr a3Ptr b1Ptr b2Ptr b3Ptr csuPtr snuPtr csvPtr snvPtr csqPtr snqPtr+      liftIO $ pure (,,,,,)+         <*> peek csuPtr+         <*> peek snuPtr+         <*> peek csvPtr+         <*> peek snvPtr+         <*> peek csqPtr+         <*> peek snqPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlagtm.f>+lagtm ::+   Char {- ^ trans -} ->+   Double {- ^ alpha -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   CArray (Int,Int) (Complex Double) {- ^ x -} ->+   Double {- ^ beta -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO ()+lagtm trans alpha dl d du x beta b = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let (xDim0,xDim1) = Call.sizes2 $ bounds x+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = xDim0+   let ldx = xDim1+   let ldb = bDim1+   Call.assert "lagtm: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "lagtm: n-1 == duDim0" (n-1 == duDim0)+   Call.assert "lagtm: nrhs == bDim0" (nrhs == bDim0)+   evalContT $ do+      transPtr <- Call.char trans+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      alphaPtr <- Call.double alpha+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      xPtr <- Call.array x+      ldxPtr <- Call.cint ldx+      betaPtr <- Call.double beta+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.lagtm transPtr nPtr nrhsPtr alphaPtr dlPtr dPtr duPtr xPtr ldxPtr betaPtr bPtr ldbPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahef.f>+lahef ::+   Char {- ^ uplo -} ->+   Int {- ^ nb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldw -} ->+   IO (Int, CArray Int CInt, CArray (Int,Int) (Complex Double), Int)+lahef uplo nb a ldw = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   w <- Call.newArray2 nb ldw+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nbPtr <- Call.cint nb+      kbPtr <- Call.alloca+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      wPtr <- Call.ioarray w+      ldwPtr <- Call.cint ldw+      infoPtr <- Call.alloca+      liftIO $ FFI.lahef uploPtr nPtr nbPtr kbPtr aPtr ldaPtr ipivPtr wPtr ldwPtr infoPtr+      liftIO $ pure (,,,)+         <*> fmap fromIntegral (peek kbPtr)+         <*> Call.freezeArray ipiv+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahqr.f>+lahqr ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   Int {- ^ ihiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   IO (CArray Int (Complex Double), Int)+lahqr wantt wantz ilo ihi h iloz ihiz z = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ldz = zDim1+   Call.assert "lahqr: n == zDim0" (n == zDim0)+   w <- Call.newArray1 n+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.ioarray w+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      infoPtr <- Call.alloca+      liftIO $ FFI.lahqr wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlahr2.f>+lahr2 ::+   Int {- ^ n -} ->+   Int {- ^ k -} ->+   Int {- ^ nb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldt -} ->+   Int {- ^ ldy -} ->+   IO (CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))+lahr2 n k nb a ldt ldy = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let lda = aDim1+   Call.assert "lahr2: n-k+1 == aDim0" (n-k+1 == aDim0)+   tau <- Call.newArray1 nb+   t <- Call.newArray2 nb ldt+   y <- Call.newArray2 nb ldy+   evalContT $ do+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      nbPtr <- Call.cint nb+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      yPtr <- Call.ioarray y+      ldyPtr <- Call.cint ldy+      liftIO $ FFI.lahr2 nPtr kPtr nbPtr aPtr ldaPtr tauPtr tPtr ldtPtr yPtr ldyPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray tau+         <*> Call.freezeArray t+         <*> Call.freezeArray y++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaic1.f>+laic1 ::+   Int {- ^ job -} ->+   CArray Int (Complex Double) {- ^ x -} ->+   Double {- ^ sest -} ->+   CArray Int (Complex Double) {- ^ w -} ->+   Complex Double {- ^ gamma -} ->+   IO (Double, Complex Double, Complex Double)+laic1 job x sest w gamma = do+   let xDim0 = Call.sizes1 $ bounds x+   let wDim0 = Call.sizes1 $ bounds w+   let j = xDim0+   Call.assert "laic1: j == wDim0" (j == wDim0)+   evalContT $ do+      jobPtr <- Call.cint job+      jPtr <- Call.cint j+      xPtr <- Call.array x+      sestPtr <- Call.double sest+      wPtr <- Call.array w+      gammaPtr <- Call.complexDouble gamma+      sestprPtr <- Call.alloca+      sPtr <- Call.alloca+      cPtr <- Call.alloca+      liftIO $ FFI.laic1 jobPtr jPtr xPtr sestPtr wPtr gammaPtr sestprPtr sPtr cPtr+      liftIO $ pure (,,)+         <*> peek sestprPtr+         <*> peek sPtr+         <*> peek cPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlals0.f>+lals0 ::+   Int {- ^ icompq -} ->+   Int {- ^ nl -} ->+   Int {- ^ nr -} ->+   Int {- ^ sqre -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldbx -} ->+   CArray Int CInt {- ^ perm -} ->+   Int {- ^ givptr -} ->+   CArray (Int,Int) CInt {- ^ givcol -} ->+   CArray (Int,Int) Double {- ^ givnum -} ->+   CArray (Int,Int) Double {- ^ poles -} ->+   CArray Int Double {- ^ difl -} ->+   CArray (Int,Int) Double {- ^ difr -} ->+   CArray Int Double {- ^ z -} ->+   Double {- ^ c -} ->+   Double {- ^ s -} ->+   Int {- ^ rworkSize -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+lals0 icompq nl nr sqre b ldbx perm givptr givcol givnum poles difl difr z c s rworkSize = do+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let permDim0 = Call.sizes1 $ bounds perm+   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol+   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum+   let (polesDim0,polesDim1) = Call.sizes2 $ bounds poles+   let diflDim0 = Call.sizes1 $ bounds difl+   let (difrDim0,difrDim1) = Call.sizes2 $ bounds difr+   let zDim0 = Call.sizes1 $ bounds z+   let nrhs = bDim0+   let ldb = bDim1+   let _n = permDim0+   let ldgcol = givcolDim1+   let ldgnum = givnumDim1+   let k = diflDim0+   Call.assert "lals0: 2 == givcolDim0" (2 == givcolDim0)+   Call.assert "lals0: 2 == givnumDim0" (2 == givnumDim0)+   Call.assert "lals0: 2 == polesDim0" (2 == polesDim0)+   Call.assert "lals0: ldgnum == polesDim1" (ldgnum == polesDim1)+   Call.assert "lals0: 2 == difrDim0" (2 == difrDim0)+   Call.assert "lals0: ldgnum == difrDim1" (ldgnum == difrDim1)+   Call.assert "lals0: k == zDim0" (k == zDim0)+   bx <- Call.newArray2 nrhs ldbx+   rwork <- Call.newArray1 rworkSize+   evalContT $ do+      icompqPtr <- Call.cint icompq+      nlPtr <- Call.cint nl+      nrPtr <- Call.cint nr+      sqrePtr <- Call.cint sqre+      nrhsPtr <- Call.cint nrhs+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      bxPtr <- Call.ioarray bx+      ldbxPtr <- Call.cint ldbx+      permPtr <- Call.array perm+      givptrPtr <- Call.cint givptr+      givcolPtr <- Call.array givcol+      ldgcolPtr <- Call.cint ldgcol+      givnumPtr <- Call.array givnum+      ldgnumPtr <- Call.cint ldgnum+      polesPtr <- Call.array poles+      diflPtr <- Call.array difl+      difrPtr <- Call.array difr+      zPtr <- Call.array z+      kPtr <- Call.cint k+      cPtr <- Call.double c+      sPtr <- Call.double s+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.lals0 icompqPtr nlPtr nrPtr sqrePtr nrhsPtr bPtr ldbPtr bxPtr ldbxPtr permPtr givptrPtr givcolPtr ldgcolPtr givnumPtr ldgnumPtr polesPtr diflPtr difrPtr zPtr kPtr cPtr sPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray bx+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlalsa.f>+lalsa ::+   Int {- ^ icompq -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldbx -} ->+   CArray (Int,Int) Double {- ^ u -} ->+   CArray (Int,Int) Double {- ^ vt -} ->+   CArray Int CInt {- ^ k -} ->+   CArray (Int,Int) Double {- ^ difl -} ->+   CArray (Int,Int) Double {- ^ difr -} ->+   CArray (Int,Int) Double {- ^ z -} ->+   CArray (Int,Int) Double {- ^ poles -} ->+   CArray Int CInt {- ^ givptr -} ->+   CArray (Int,Int) CInt {- ^ givcol -} ->+   CArray (Int,Int) CInt {- ^ perm -} ->+   CArray (Int,Int) Double {- ^ givnum -} ->+   CArray Int Double {- ^ c -} ->+   CArray Int Double {- ^ s -} ->+   Int {- ^ rworkSize -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+lalsa icompq b ldbx u vt k difl difr z poles givptr givcol perm givnum c s rworkSize = do+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let (uDim0,uDim1) = Call.sizes2 $ bounds u+   let (vtDim0,vtDim1) = Call.sizes2 $ bounds vt+   let kDim0 = Call.sizes1 $ bounds k+   let (diflDim0,diflDim1) = Call.sizes2 $ bounds difl+   let (difrDim0,difrDim1) = Call.sizes2 $ bounds difr+   let (zDim0,zDim1) = Call.sizes2 $ bounds z+   let (polesDim0,polesDim1) = Call.sizes2 $ bounds poles+   let givptrDim0 = Call.sizes1 $ bounds givptr+   let (givcolDim0,givcolDim1) = Call.sizes2 $ bounds givcol+   let (permDim0,permDim1) = Call.sizes2 $ bounds perm+   let (givnumDim0,givnumDim1) = Call.sizes2 $ bounds givnum+   let cDim0 = Call.sizes1 $ bounds c+   let sDim0 = Call.sizes1 $ bounds s+   let nrhs = bDim0+   let ldb = bDim1+   let smlsiz = uDim0+   let ldu = uDim1+   let n = kDim0+   let nlvl = diflDim0+   let ldgcol = givcolDim1+   Call.assert "lalsa: smlsiz+1 == vtDim0" (smlsiz+1 == vtDim0)+   Call.assert "lalsa: ldu == vtDim1" (ldu == vtDim1)+   Call.assert "lalsa: ldu == diflDim1" (ldu == diflDim1)+   Call.assert "lalsa: 2*nlvl == difrDim0" (2*nlvl == difrDim0)+   Call.assert "lalsa: ldu == difrDim1" (ldu == difrDim1)+   Call.assert "lalsa: nlvl == zDim0" (nlvl == zDim0)+   Call.assert "lalsa: ldu == zDim1" (ldu == zDim1)+   Call.assert "lalsa: 2*nlvl == polesDim0" (2*nlvl == polesDim0)+   Call.assert "lalsa: ldu == polesDim1" (ldu == polesDim1)+   Call.assert "lalsa: n == givptrDim0" (n == givptrDim0)+   Call.assert "lalsa: 2*nlvl == givcolDim0" (2*nlvl == givcolDim0)+   Call.assert "lalsa: nlvl == permDim0" (nlvl == permDim0)+   Call.assert "lalsa: ldgcol == permDim1" (ldgcol == permDim1)+   Call.assert "lalsa: 2*nlvl == givnumDim0" (2*nlvl == givnumDim0)+   Call.assert "lalsa: ldu == givnumDim1" (ldu == givnumDim1)+   Call.assert "lalsa: n == cDim0" (n == cDim0)+   Call.assert "lalsa: n == sDim0" (n == sDim0)+   bx <- Call.newArray2 nrhs ldbx+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 (3*n)+   evalContT $ do+      icompqPtr <- Call.cint icompq+      smlsizPtr <- Call.cint smlsiz+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      bxPtr <- Call.ioarray bx+      ldbxPtr <- Call.cint ldbx+      uPtr <- Call.array u+      lduPtr <- Call.cint ldu+      vtPtr <- Call.array vt+      kPtr <- Call.array k+      diflPtr <- Call.array difl+      difrPtr <- Call.array difr+      zPtr <- Call.array z+      polesPtr <- Call.array poles+      givptrPtr <- Call.array givptr+      givcolPtr <- Call.array givcol+      ldgcolPtr <- Call.cint ldgcol+      permPtr <- Call.array perm+      givnumPtr <- Call.array givnum+      cPtr <- Call.array c+      sPtr <- Call.array s+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.lalsa icompqPtr smlsizPtr nPtr nrhsPtr bPtr ldbPtr bxPtr ldbxPtr uPtr lduPtr vtPtr kPtr diflPtr difrPtr zPtr polesPtr givptrPtr givcolPtr ldgcolPtr permPtr givnumPtr cPtr sPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray bx+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlalsd.f>+lalsd ::+   Char {- ^ uplo -} ->+   Int {- ^ smlsiz -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Double {- ^ rcond -} ->+   Int {- ^ rworkSize -} ->+   Int {- ^ iworkSize -} ->+   IO (Int, Int)+lalsd uplo smlsiz d e b rcond rworkSize iworkSize = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "lalsd: n-1 == eDim0" (n-1 == eDim0)+   work <- Call.newArray1 (n*nrhs)+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 iworkSize+   evalContT $ do+      uploPtr <- Call.char uplo+      smlsizPtr <- Call.cint smlsiz+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      rcondPtr <- Call.double rcond+      rankPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.lalsd uploPtr smlsizPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr rcondPtr rankPtr workPtr rworkPtr iworkPtr infoPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlangb.f>+langb ::+   Char {- ^ norm -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ lwork -} ->+   IO Double+langb norm kl ku ab lwork = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      workPtr <- Call.ioarray work+      liftIO $ FFI.langb normPtr nPtr klPtr kuPtr abPtr ldabPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlange.f>+lange ::+   Char {- ^ norm -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lange norm m a lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      workPtr <- Call.ioarray work+      liftIO $ FFI.lange normPtr mPtr nPtr aPtr ldaPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlangt.f>+langt ::+   Char {- ^ norm -} ->+   CArray Int (Complex Double) {- ^ dl -} ->+   CArray Int (Complex Double) {- ^ d -} ->+   CArray Int (Complex Double) {- ^ du -} ->+   IO Double+langt norm dl d du = do+   let dlDim0 = Call.sizes1 $ bounds dl+   let dDim0 = Call.sizes1 $ bounds d+   let duDim0 = Call.sizes1 $ bounds du+   let n = dDim0+   Call.assert "langt: n-1 == dlDim0" (n-1 == dlDim0)+   Call.assert "langt: n-1 == duDim0" (n-1 == duDim0)+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      dlPtr <- Call.array dl+      dPtr <- Call.array d+      duPtr <- Call.array du+      liftIO $ FFI.langt normPtr nPtr dlPtr dPtr duPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhb.f>+lanhb ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Int {- ^ k -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ lwork -} ->+   IO Double+lanhb norm uplo k ab lwork = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      workPtr <- Call.ioarray work+      liftIO $ FFI.lanhb normPtr uploPtr nPtr kPtr abPtr ldabPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhe.f>+lanhe ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lanhe norm uplo a lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      workPtr <- Call.ioarray work+      liftIO $ FFI.lanhe normPtr uploPtr nPtr aPtr ldaPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhf.f>+lanhf ::+   Char {- ^ norm -} ->+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lanhf norm transr uplo n a lwork = do+   let aDim0 = Call.sizes1 $ bounds a+   Call.assert "lanhf: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   work <- Call.newArray1 lwork+   evalContT $ do+      normPtr <- Call.char norm+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      workPtr <- Call.ioarray work+      liftIO $ FFI.lanhf normPtr transrPtr uploPtr nPtr aPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhp.f>+lanhp ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ lwork -} ->+   IO Double+lanhp norm uplo n ap lwork = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "lanhp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      workPtr <- Call.ioarray work+      liftIO $ FFI.lanhp normPtr uploPtr nPtr apPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanhs.f>+lanhs ::+   Char {- ^ norm -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lanhs norm a lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      workPtr <- Call.ioarray work+      liftIO $ FFI.lanhs normPtr nPtr aPtr ldaPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlanht.f>+lanht ::+   Char {- ^ norm -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   IO Double+lanht norm d e = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   let n = dDim0+   Call.assert "lanht: n-1 == eDim0" (n-1 == eDim0)+   evalContT $ do+      normPtr <- Call.char norm+      nPtr <- Call.cint n+      dPtr <- Call.array d+      ePtr <- Call.array e+      liftIO $ FFI.lanht normPtr nPtr dPtr ePtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansb.f>+lansb ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Int {- ^ k -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ lwork -} ->+   IO Double+lansb norm uplo k ab lwork = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      workPtr <- Call.ioarray work+      liftIO $ FFI.lansb normPtr uploPtr nPtr kPtr abPtr ldabPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansp.f>+lansp ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ lwork -} ->+   IO Double+lansp norm uplo n ap lwork = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "lansp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      workPtr <- Call.ioarray work+      liftIO $ FFI.lansp normPtr uploPtr nPtr apPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlansy.f>+lansy ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lansy norm uplo a lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      workPtr <- Call.ioarray work+      liftIO $ FFI.lansy normPtr uploPtr nPtr aPtr ldaPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantb.f>+lantb ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ k -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Int {- ^ lwork -} ->+   IO Double+lantb norm uplo diag k ab lwork = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      workPtr <- Call.ioarray work+      liftIO $ FFI.lantb normPtr uploPtr diagPtr nPtr kPtr abPtr ldabPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantp.f>+lantp ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ lwork -} ->+   IO Double+lantp norm uplo diag n ap lwork = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "lantp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      workPtr <- Call.ioarray work+      liftIO $ FFI.lantp normPtr uploPtr diagPtr nPtr apPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlantr.f>+lantr ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO Double+lantr norm uplo diag m a lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      workPtr <- Call.ioarray work+      liftIO $ FFI.lantr normPtr uploPtr diagPtr mPtr nPtr aPtr ldaPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapll.f>+lapll ::+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   Int {- ^ incy -} ->+   IO (Double)+lapll n x incx y incy = do+   xDim0 <- Call.sizes1 <$> getBounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   Call.assert "lapll: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)+   Call.assert "lapll: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      yPtr <- Call.ioarray y+      incyPtr <- Call.cint incy+      ssminPtr <- Call.alloca+      liftIO $ FFI.lapll nPtr xPtr incxPtr yPtr incyPtr ssminPtr+      liftIO $ peek ssminPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapmr.f>+lapmr ::+   Bool {- ^ forwrd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IOCArray Int CInt {- ^ k -} ->+   IO ()+lapmr forwrd x k = do+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   kDim0 <- Call.sizes1 <$> getBounds k+   let n = xDim0+   let ldx = xDim1+   let m = kDim0+   evalContT $ do+      forwrdPtr <- Call.bool forwrd+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      kPtr <- Call.ioarray k+      liftIO $ FFI.lapmr forwrdPtr mPtr nPtr xPtr ldxPtr kPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlapmt.f>+lapmt ::+   Bool {- ^ forwrd -} ->+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IOCArray Int CInt {- ^ k -} ->+   IO ()+lapmt forwrd m x k = do+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   kDim0 <- Call.sizes1 <$> getBounds k+   let n = xDim0+   let ldx = xDim1+   Call.assert "lapmt: n == kDim0" (n == kDim0)+   evalContT $ do+      forwrdPtr <- Call.bool forwrd+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      kPtr <- Call.ioarray k+      liftIO $ FFI.lapmt forwrdPtr mPtr nPtr xPtr ldxPtr kPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqgb.f>+laqgb ::+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray Int Double {- ^ r -} ->+   CArray Int Double {- ^ c -} ->+   Double {- ^ rowcnd -} ->+   Double {- ^ colcnd -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqgb kl ku ab r c rowcnd colcnd amax = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let rDim0 = Call.sizes1 $ bounds r+   let cDim0 = Call.sizes1 $ bounds c+   let n = abDim0+   let ldab = abDim1+   let m = rDim0+   Call.assert "laqgb: n == cDim0" (n == cDim0)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      rPtr <- Call.array r+      cPtr <- Call.array c+      rowcndPtr <- Call.double rowcnd+      colcndPtr <- Call.double colcnd+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqgb mPtr nPtr klPtr kuPtr abPtr ldabPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqge.f>+laqge ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int Double {- ^ r -} ->+   CArray Int Double {- ^ c -} ->+   Double {- ^ rowcnd -} ->+   Double {- ^ colcnd -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqge a r c rowcnd colcnd amax = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let rDim0 = Call.sizes1 $ bounds r+   let cDim0 = Call.sizes1 $ bounds c+   let n = aDim0+   let lda = aDim1+   let m = rDim0+   Call.assert "laqge: n == cDim0" (n == cDim0)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      rPtr <- Call.array r+      cPtr <- Call.array c+      rowcndPtr <- Call.double rowcnd+      colcndPtr <- Call.double colcnd+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqge mPtr nPtr aPtr ldaPtr rPtr cPtr rowcndPtr colcndPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhb.f>+laqhb ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (CArray Int Double, Char)+laqhb uplo kd ab scond amax = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   s <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      sPtr <- Call.ioarray s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqhb uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ pure (,)+         <*> Call.freezeArray s+         <*> fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhe.f>+laqhe ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int Double {- ^ s -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqhe uplo a s scond amax = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let sDim0 = Call.sizes1 $ bounds s+   let n = aDim0+   let lda = aDim1+   Call.assert "laqhe: n == sDim0" (n == sDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sPtr <- Call.array s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqhe uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqhp.f>+laqhp ::+   Char {- ^ uplo -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   CArray Int Double {- ^ s -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqhp uplo ap s scond amax = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   let sDim0 = Call.sizes1 $ bounds s+   let n = sDim0+   Call.assert "laqhp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      sPtr <- Call.array s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqhp uploPtr nPtr apPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqp2.f>+laqp2 ::+   Int {- ^ m -} ->+   Int {- ^ offset -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray Int CInt {- ^ jpvt -} ->+   IOCArray Int Double {- ^ vn1 -} ->+   IOCArray Int Double {- ^ vn2 -} ->+   IO (CArray Int (Complex Double))+laqp2 m offset a jpvt vn1 vn2 = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt+   vn1Dim0 <- Call.sizes1 <$> getBounds vn1+   vn2Dim0 <- Call.sizes1 <$> getBounds vn2+   let n = aDim0+   let lda = aDim1+   Call.assert "laqp2: n == jpvtDim0" (n == jpvtDim0)+   Call.assert "laqp2: n == vn1Dim0" (n == vn1Dim0)+   Call.assert "laqp2: n == vn2Dim0" (n == vn2Dim0)+   tau <- Call.newArray1 (minimum[m,n])+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      offsetPtr <- Call.cint offset+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      jpvtPtr <- Call.ioarray jpvt+      tauPtr <- Call.ioarray tau+      vn1Ptr <- Call.ioarray vn1+      vn2Ptr <- Call.ioarray vn2+      workPtr <- Call.ioarray work+      liftIO $ FFI.laqp2 mPtr nPtr offsetPtr aPtr ldaPtr jpvtPtr tauPtr vn1Ptr vn2Ptr workPtr+      liftIO $ Call.freezeArray tau++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqps.f>+laqps ::+   Int {- ^ m -} ->+   Int {- ^ offset -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray Int CInt {- ^ jpvt -} ->+   Int {- ^ kb -} ->+   IOCArray Int Double {- ^ vn1 -} ->+   IOCArray Int Double {- ^ vn2 -} ->+   IOCArray Int (Complex Double) {- ^ auxv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->+   IO (Int, CArray Int (Complex Double))+laqps m offset a jpvt kb vn1 vn2 auxv f = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   jpvtDim0 <- Call.sizes1 <$> getBounds jpvt+   vn1Dim0 <- Call.sizes1 <$> getBounds vn1+   vn2Dim0 <- Call.sizes1 <$> getBounds vn2+   auxvDim0 <- Call.sizes1 <$> getBounds auxv+   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f+   let n = aDim0+   let lda = aDim1+   let nb = auxvDim0+   let ldf = fDim1+   Call.assert "laqps: n == jpvtDim0" (n == jpvtDim0)+   Call.assert "laqps: n == vn1Dim0" (n == vn1Dim0)+   Call.assert "laqps: n == vn2Dim0" (n == vn2Dim0)+   Call.assert "laqps: nb == fDim0" (nb == fDim0)+   tau <- Call.newArray1 kb+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      offsetPtr <- Call.cint offset+      nbPtr <- Call.cint nb+      kbPtr <- Call.alloca+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      jpvtPtr <- Call.ioarray jpvt+      tauPtr <- Call.ioarray tau+      vn1Ptr <- Call.ioarray vn1+      vn2Ptr <- Call.ioarray vn2+      auxvPtr <- Call.ioarray auxv+      fPtr <- Call.ioarray f+      ldfPtr <- Call.cint ldf+      liftIO $ FFI.laqps mPtr nPtr offsetPtr nbPtr kbPtr aPtr ldaPtr jpvtPtr tauPtr vn1Ptr vn2Ptr auxvPtr fPtr ldfPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek kbPtr)+         <*> Call.freezeArray tau++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr0.f>+laqr0 ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ ilo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   Int {- ^ ihiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ workSize -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+laqr0 wantt wantz ilo h iloz ihiz z workSize lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ihi = zDim0+   let ldz = zDim1+   w <- Call.newArray1 n+   work <- Call.newArray1 workSize+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.ioarray w+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.laqr0 wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr1.f>+laqr1 ::+   CArray (Int,Int) (Complex Double) {- ^ h -} ->+   Complex Double {- ^ s1 -} ->+   Complex Double {- ^ s2 -} ->+   IO (CArray Int (Complex Double))+laqr1 h s1 s2 = do+   let (hDim0,hDim1) = Call.sizes2 $ bounds h+   let n = hDim0+   let ldh = hDim1+   v <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      hPtr <- Call.array h+      ldhPtr <- Call.cint ldh+      s1Ptr <- Call.complexDouble s1+      s2Ptr <- Call.complexDouble s2+      vPtr <- Call.ioarray v+      liftIO $ FFI.laqr1 nPtr hPtr ldhPtr s1Ptr s2Ptr vPtr+      liftIO $ Call.freezeArray v++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr2.f>+laqr2 ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ ktop -} ->+   Int {- ^ kbot -} ->+   Int {- ^ nw -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   Int {- ^ ihiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ ldv -} ->+   Int {- ^ nh -} ->+   Int {- ^ ldt -} ->+   Int {- ^ nv -} ->+   Int {- ^ ldwv -} ->+   Int {- ^ lwork -} ->+   IO (Int, Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))+laqr2 wantt wantz ktop kbot nw h iloz ihiz z ldv nh ldt nv ldwv lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ldz = zDim1+   Call.assert "laqr2: n == zDim0" (n == zDim0)+   sh <- Call.newArray1 kbot+   v <- Call.newArray2 nw ldv+   t <- Call.newArray2 nw ldt+   wv <- Call.newArray2 nw ldwv+   work <- Call.newArray1 lwork+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      ktopPtr <- Call.cint ktop+      kbotPtr <- Call.cint kbot+      nwPtr <- Call.cint nw+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      nsPtr <- Call.alloca+      ndPtr <- Call.alloca+      shPtr <- Call.ioarray sh+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      nhPtr <- Call.cint nh+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      nvPtr <- Call.cint nv+      wvPtr <- Call.ioarray wv+      ldwvPtr <- Call.cint ldwv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      liftIO $ FFI.laqr2 wanttPtr wantzPtr nPtr ktopPtr kbotPtr nwPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr nsPtr ndPtr shPtr vPtr ldvPtr nhPtr tPtr ldtPtr nvPtr wvPtr ldwvPtr workPtr lworkPtr+      liftIO $ pure (,,,,,)+         <*> fmap fromIntegral (peek nsPtr)+         <*> fmap fromIntegral (peek ndPtr)+         <*> Call.freezeArray sh+         <*> Call.freezeArray v+         <*> Call.freezeArray t+         <*> Call.freezeArray wv++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr3.f>+laqr3 ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ ktop -} ->+   Int {- ^ kbot -} ->+   Int {- ^ nw -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   Int {- ^ ihiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ ldv -} ->+   Int {- ^ nh -} ->+   Int {- ^ ldt -} ->+   Int {- ^ nv -} ->+   Int {- ^ ldwv -} ->+   Int {- ^ lwork -} ->+   IO (Int, Int, CArray Int (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))+laqr3 wantt wantz ktop kbot nw h iloz ihiz z ldv nh ldt nv ldwv lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ldz = zDim1+   Call.assert "laqr3: n == zDim0" (n == zDim0)+   sh <- Call.newArray1 kbot+   v <- Call.newArray2 nw ldv+   t <- Call.newArray2 nw ldt+   wv <- Call.newArray2 nw ldwv+   work <- Call.newArray1 lwork+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      ktopPtr <- Call.cint ktop+      kbotPtr <- Call.cint kbot+      nwPtr <- Call.cint nw+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      nsPtr <- Call.alloca+      ndPtr <- Call.alloca+      shPtr <- Call.ioarray sh+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      nhPtr <- Call.cint nh+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      nvPtr <- Call.cint nv+      wvPtr <- Call.ioarray wv+      ldwvPtr <- Call.cint ldwv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      liftIO $ FFI.laqr3 wanttPtr wantzPtr nPtr ktopPtr kbotPtr nwPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr nsPtr ndPtr shPtr vPtr ldvPtr nhPtr tPtr ldtPtr nvPtr wvPtr ldwvPtr workPtr lworkPtr+      liftIO $ pure (,,,,,)+         <*> fmap fromIntegral (peek nsPtr)+         <*> fmap fromIntegral (peek ndPtr)+         <*> Call.freezeArray sh+         <*> Call.freezeArray v+         <*> Call.freezeArray t+         <*> Call.freezeArray wv++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr4.f>+laqr4 ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ ilo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   Int {- ^ ihiz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ workSize -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+laqr4 wantt wantz ilo h iloz ihiz z workSize lwork = do+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = hDim0+   let ldh = hDim1+   let ihi = zDim0+   let ldz = zDim1+   w <- Call.newArray1 n+   work <- Call.newArray1 workSize+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      wPtr <- Call.ioarray w+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.laqr4 wanttPtr wantzPtr nPtr iloPtr ihiPtr hPtr ldhPtr wPtr ilozPtr ihizPtr zPtr ldzPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqr5.f>+laqr5 ::+   Bool {- ^ wantt -} ->+   Bool {- ^ wantz -} ->+   Int {- ^ kacc22 -} ->+   Int {- ^ ktop -} ->+   Int {- ^ kbot -} ->+   IOCArray Int (Complex Double) {- ^ s -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ h -} ->+   Int {- ^ iloz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ ldv -} ->+   Int {- ^ ldu -} ->+   Int {- ^ nv -} ->+   Int {- ^ ldwv -} ->+   Int {- ^ nh -} ->+   Int {- ^ ldwh -} ->+   IO (CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double))+laqr5 wantt wantz kacc22 ktop kbot s h iloz z ldv ldu nv ldwv nh ldwh = do+   sDim0 <- Call.sizes1 <$> getBounds s+   (hDim0,hDim1) <- Call.sizes2 <$> getBounds h+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let nshfts = sDim0+   let n = hDim0+   let ldh = hDim1+   let ihiz = zDim0+   let ldz = zDim1+   v <- Call.newArray2 (nshfts`div`2) ldv+   u <- Call.newArray2 (3*nshfts-3) ldu+   wv <- Call.newArray2 (3*nshfts-3) ldwv+   wh <- Call.newArray2 nh ldwh+   evalContT $ do+      wanttPtr <- Call.bool wantt+      wantzPtr <- Call.bool wantz+      kacc22Ptr <- Call.cint kacc22+      nPtr <- Call.cint n+      ktopPtr <- Call.cint ktop+      kbotPtr <- Call.cint kbot+      nshftsPtr <- Call.cint nshfts+      sPtr <- Call.ioarray s+      hPtr <- Call.ioarray h+      ldhPtr <- Call.cint ldh+      ilozPtr <- Call.cint iloz+      ihizPtr <- Call.cint ihiz+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      uPtr <- Call.ioarray u+      lduPtr <- Call.cint ldu+      nvPtr <- Call.cint nv+      wvPtr <- Call.ioarray wv+      ldwvPtr <- Call.cint ldwv+      nhPtr <- Call.cint nh+      whPtr <- Call.ioarray wh+      ldwhPtr <- Call.cint ldwh+      liftIO $ FFI.laqr5 wanttPtr wantzPtr kacc22Ptr nPtr ktopPtr kbotPtr nshftsPtr sPtr hPtr ldhPtr ilozPtr ihizPtr zPtr ldzPtr vPtr ldvPtr uPtr lduPtr nvPtr wvPtr ldwvPtr nhPtr whPtr ldwhPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray v+         <*> Call.freezeArray u+         <*> Call.freezeArray wv+         <*> Call.freezeArray wh++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsb.f>+laqsb ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray Int Double {- ^ s -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqsb uplo kd ab s scond amax = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let sDim0 = Call.sizes1 $ bounds s+   let n = abDim0+   let ldab = abDim1+   Call.assert "laqsb: n == sDim0" (n == sDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      sPtr <- Call.array s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqsb uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsp.f>+laqsp ::+   Char {- ^ uplo -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   CArray Int Double {- ^ s -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqsp uplo ap s scond amax = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   let sDim0 = Call.sizes1 $ bounds s+   let n = sDim0+   Call.assert "laqsp: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      sPtr <- Call.array s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqsp uploPtr nPtr apPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaqsy.f>+laqsy ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int Double {- ^ s -} ->+   Double {- ^ scond -} ->+   Double {- ^ amax -} ->+   IO (Char)+laqsy uplo a s scond amax = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let sDim0 = Call.sizes1 $ bounds s+   let n = aDim0+   let lda = aDim1+   Call.assert "laqsy: n == sDim0" (n == sDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      sPtr <- Call.array s+      scondPtr <- Call.double scond+      amaxPtr <- Call.double amax+      equedPtr <- Call.alloca+      liftIO $ FFI.laqsy uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr equedPtr+      liftIO $ fmap castCCharToChar (peek equedPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlar1v.f>+lar1v ::+   Int {- ^ b1 -} ->+   Int {- ^ bn -} ->+   Double {- ^ lambda -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int Double {- ^ l -} ->+   CArray Int Double {- ^ ld -} ->+   CArray Int Double {- ^ lld -} ->+   Double {- ^ pivmin -} ->+   Double {- ^ gaptol -} ->+   IOCArray Int (Complex Double) {- ^ z -} ->+   Bool {- ^ wantnc -} ->+   Int {- ^ r -} ->+   IO (Int, Double, Double, Int, CArray Int CInt, Double, Double, Double)+lar1v b1 bn lambda d l ld lld pivmin gaptol z wantnc r = do+   let dDim0 = Call.sizes1 $ bounds d+   let lDim0 = Call.sizes1 $ bounds l+   let ldDim0 = Call.sizes1 $ bounds ld+   let lldDim0 = Call.sizes1 $ bounds lld+   zDim0 <- Call.sizes1 <$> getBounds z+   let n = dDim0+   Call.assert "lar1v: n-1 == lDim0" (n-1 == lDim0)+   Call.assert "lar1v: n-1 == ldDim0" (n-1 == ldDim0)+   Call.assert "lar1v: n-1 == lldDim0" (n-1 == lldDim0)+   Call.assert "lar1v: n == zDim0" (n == zDim0)+   isuppz <- Call.newArray1 2+   work <- Call.newArray1 (4*n)+   evalContT $ do+      nPtr <- Call.cint n+      b1Ptr <- Call.cint b1+      bnPtr <- Call.cint bn+      lambdaPtr <- Call.double lambda+      dPtr <- Call.array d+      lPtr <- Call.array l+      ldPtr <- Call.array ld+      lldPtr <- Call.array lld+      pivminPtr <- Call.double pivmin+      gaptolPtr <- Call.double gaptol+      zPtr <- Call.ioarray z+      wantncPtr <- Call.bool wantnc+      negcntPtr <- Call.alloca+      ztzPtr <- Call.alloca+      mingmaPtr <- Call.alloca+      rPtr <- Call.cint r+      isuppzPtr <- Call.ioarray isuppz+      nrminvPtr <- Call.alloca+      residPtr <- Call.alloca+      rqcorrPtr <- Call.alloca+      workPtr <- Call.ioarray work+      liftIO $ FFI.lar1v nPtr b1Ptr bnPtr lambdaPtr dPtr lPtr ldPtr lldPtr pivminPtr gaptolPtr zPtr wantncPtr negcntPtr ztzPtr mingmaPtr rPtr isuppzPtr nrminvPtr residPtr rqcorrPtr workPtr+      liftIO $ pure (,,,,,,,)+         <*> fmap fromIntegral (peek negcntPtr)+         <*> peek ztzPtr+         <*> peek mingmaPtr+         <*> fmap fromIntegral (peek rPtr)+         <*> Call.freezeArray isuppz+         <*> peek nrminvPtr+         <*> peek residPtr+         <*> peek rqcorrPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlar2v.f>+lar2v ::+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   IOCArray Int (Complex Double) {- ^ z -} ->+   Int {- ^ incx -} ->+   CArray Int Double {- ^ c -} ->+   CArray Int (Complex Double) {- ^ s -} ->+   Int {- ^ incc -} ->+   IO ()+lar2v n x y z incx c s incc = do+   xDim0 <- Call.sizes1 <$> getBounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   zDim0 <- Call.sizes1 <$> getBounds z+   let cDim0 = Call.sizes1 $ bounds c+   let sDim0 = Call.sizes1 $ bounds s+   Call.assert "lar2v: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)+   Call.assert "lar2v: 1+(n-1)*incx == yDim0" (1+(n-1)*incx == yDim0)+   Call.assert "lar2v: 1+(n-1)*incx == zDim0" (1+(n-1)*incx == zDim0)+   Call.assert "lar2v: 1+(n-1)*incc == cDim0" (1+(n-1)*incc == cDim0)+   Call.assert "lar2v: 1+(n-1)*incc == sDim0" (1+(n-1)*incc == sDim0)+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      yPtr <- Call.ioarray y+      zPtr <- Call.ioarray z+      incxPtr <- Call.cint incx+      cPtr <- Call.array c+      sPtr <- Call.array s+      inccPtr <- Call.cint incc+      liftIO $ FFI.lar2v nPtr xPtr yPtr zPtr incxPtr cPtr sPtr inccPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarcm.f>+larcm ::+   CArray (Int,Int) Double {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldc -} ->+   IO (CArray (Int,Int) (Complex Double))+larcm a b ldc = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let m = aDim0+   let lda = aDim1+   let n = bDim0+   let ldb = bDim1+   c <- Call.newArray2 n ldc+   rwork <- Call.newArray1 (2*m*n)+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      rworkPtr <- Call.ioarray rwork+      liftIO $ FFI.larcm mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr rworkPtr+      liftIO $ Call.freezeArray c++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarf.f>+larf ::+   Char {- ^ side -} ->+   Int {- ^ m -} ->+   CArray Int (Complex Double) {- ^ v -} ->+   Int {- ^ incv -} ->+   Complex Double {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO ()+larf side m v incv tau c workSize = do+   let vDim0 = Call.sizes1 $ bounds v+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _vSize = vDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      vPtr <- Call.array v+      incvPtr <- Call.cint incv+      tauPtr <- Call.complexDouble tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      liftIO $ FFI.larf sidePtr mPtr nPtr vPtr incvPtr tauPtr cPtr ldcPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfb.f>+larfb ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Char {- ^ direct -} ->+   Char {- ^ storev -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ v -} ->+   CArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ ldwork -} ->+   IO ()+larfb side trans direct storev m v t c ldwork = do+   let (vDim0,vDim1) = Call.sizes2 $ bounds v+   let (tDim0,tDim1) = Call.sizes2 $ bounds t+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _vSize = vDim0+   let ldv = vDim1+   let k = tDim0+   let ldt = tDim1+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray2 k ldwork+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      directPtr <- Call.char direct+      storevPtr <- Call.char storev+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      vPtr <- Call.array v+      ldvPtr <- Call.cint ldv+      tPtr <- Call.array t+      ldtPtr <- Call.cint ldt+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      ldworkPtr <- Call.cint ldwork+      liftIO $ FFI.larfb sidePtr transPtr directPtr storevPtr mPtr nPtr kPtr vPtr ldvPtr tPtr ldtPtr cPtr ldcPtr workPtr ldworkPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfg.f>+larfg ::+   Int {- ^ n -} ->+   Complex Double {- ^ alpha -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IO (Complex Double, Complex Double)+larfg n alpha x incx = do+   xDim0 <- Call.sizes1 <$> getBounds x+   let _xSize = xDim0+   evalContT $ do+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      tauPtr <- Call.alloca+      liftIO $ FFI.larfg nPtr alphaPtr xPtr incxPtr tauPtr+      liftIO $ pure (,)+         <*> peek alphaPtr+         <*> peek tauPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfgp.f>+larfgp ::+   Int {- ^ n -} ->+   Complex Double {- ^ alpha -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IO (Complex Double, Complex Double)+larfgp n alpha x incx = do+   xDim0 <- Call.sizes1 <$> getBounds x+   let _xSize = xDim0+   evalContT $ do+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      tauPtr <- Call.alloca+      liftIO $ FFI.larfgp nPtr alphaPtr xPtr incxPtr tauPtr+      liftIO $ pure (,)+         <*> peek alphaPtr+         <*> peek tauPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarft.f>+larft ::+   Char {- ^ direct -} ->+   Char {- ^ storev -} ->+   Int {- ^ n -} ->+   CArray (Int,Int) (Complex Double) {- ^ v -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ ldt -} ->+   IO (CArray (Int,Int) (Complex Double))+larft direct storev n v tau ldt = do+   let (vDim0,vDim1) = Call.sizes2 $ bounds v+   let tauDim0 = Call.sizes1 $ bounds tau+   let _vSize = vDim0+   let ldv = vDim1+   let k = tauDim0+   t <- Call.newArray2 k ldt+   evalContT $ do+      directPtr <- Call.char direct+      storevPtr <- Call.char storev+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      vPtr <- Call.array v+      ldvPtr <- Call.cint ldv+      tauPtr <- Call.array tau+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      liftIO $ FFI.larft directPtr storevPtr nPtr kPtr vPtr ldvPtr tauPtr tPtr ldtPtr+      liftIO $ Call.freezeArray t++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarfx.f>+larfx ::+   Char {- ^ side -} ->+   Int {- ^ m -} ->+   CArray Int (Complex Double) {- ^ v -} ->+   Complex Double {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO ()+larfx side m v tau c workSize = do+   let vDim0 = Call.sizes1 $ bounds v+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _vSize = vDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      vPtr <- Call.array v+      tauPtr <- Call.complexDouble tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      liftIO $ FFI.larfx sidePtr mPtr nPtr vPtr tauPtr cPtr ldcPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlargv.f>+largv ::+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   Int {- ^ incy -} ->+   Int {- ^ incc -} ->+   IO (CArray Int Double)+largv n x incx y incy incc = do+   xDim0 <- Call.sizes1 <$> getBounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   Call.assert "largv: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)+   Call.assert "largv: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)+   c <- Call.newArray1 (1+(n-1)*incc)+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      yPtr <- Call.ioarray y+      incyPtr <- Call.cint incy+      cPtr <- Call.ioarray c+      inccPtr <- Call.cint incc+      liftIO $ FFI.largv nPtr xPtr incxPtr yPtr incyPtr cPtr inccPtr+      liftIO $ Call.freezeArray c++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarnv.f>+larnv ::+   Int {- ^ idist -} ->+   IOCArray Int CInt {- ^ iseed -} ->+   Int {- ^ n -} ->+   IO (CArray Int (Complex Double))+larnv idist iseed n = do+   iseedDim0 <- Call.sizes1 <$> getBounds iseed+   Call.assert "larnv: 4 == iseedDim0" (4 == iseedDim0)+   x <- Call.newArray1 n+   evalContT $ do+      idistPtr <- Call.cint idist+      iseedPtr <- Call.ioarray iseed+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      liftIO $ FFI.larnv idistPtr iseedPtr nPtr xPtr+      liftIO $ Call.freezeArray x++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarrv.f>+larrv ::+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ l -} ->+   Double {- ^ pivmin -} ->+   CArray Int CInt {- ^ isplit -} ->+   Int {- ^ m -} ->+   Int {- ^ dol -} ->+   Int {- ^ dou -} ->+   Double {- ^ minrgp -} ->+   Double {- ^ rtol1 -} ->+   Double {- ^ rtol2 -} ->+   IOCArray Int Double {- ^ w -} ->+   IOCArray Int Double {- ^ werr -} ->+   IOCArray Int Double {- ^ wgap -} ->+   CArray Int CInt {- ^ iblock -} ->+   CArray Int CInt {- ^ indexw -} ->+   CArray Int Double {- ^ gers -} ->+   Int {- ^ ldz -} ->+   IO (CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+larrv vl vu d l pivmin isplit m dol dou minrgp rtol1 rtol2 w werr wgap iblock indexw gers ldz = do+   dDim0 <- Call.sizes1 <$> getBounds d+   lDim0 <- Call.sizes1 <$> getBounds l+   let isplitDim0 = Call.sizes1 $ bounds isplit+   wDim0 <- Call.sizes1 <$> getBounds w+   werrDim0 <- Call.sizes1 <$> getBounds werr+   wgapDim0 <- Call.sizes1 <$> getBounds wgap+   let iblockDim0 = Call.sizes1 $ bounds iblock+   let indexwDim0 = Call.sizes1 $ bounds indexw+   let gersDim0 = Call.sizes1 $ bounds gers+   let n = dDim0+   Call.assert "larrv: n == lDim0" (n == lDim0)+   Call.assert "larrv: n == isplitDim0" (n == isplitDim0)+   Call.assert "larrv: n == wDim0" (n == wDim0)+   Call.assert "larrv: n == werrDim0" (n == werrDim0)+   Call.assert "larrv: n == wgapDim0" (n == wgapDim0)+   Call.assert "larrv: n == iblockDim0" (n == iblockDim0)+   Call.assert "larrv: n == indexwDim0" (n == indexwDim0)+   Call.assert "larrv: 2*n == gersDim0" (2*n == gersDim0)+   z <- Call.newArray2 (maximum[1,m]) ldz+   isuppz <- Call.newArray1 (2*maximum[1,m])+   work <- Call.newArray1 (12*n)+   iwork <- Call.newArray1 (7*n)+   evalContT $ do+      nPtr <- Call.cint n+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      dPtr <- Call.ioarray d+      lPtr <- Call.ioarray l+      pivminPtr <- Call.double pivmin+      isplitPtr <- Call.array isplit+      mPtr <- Call.cint m+      dolPtr <- Call.cint dol+      douPtr <- Call.cint dou+      minrgpPtr <- Call.double minrgp+      rtol1Ptr <- Call.double rtol1+      rtol2Ptr <- Call.double rtol2+      wPtr <- Call.ioarray w+      werrPtr <- Call.ioarray werr+      wgapPtr <- Call.ioarray wgap+      iblockPtr <- Call.array iblock+      indexwPtr <- Call.array indexw+      gersPtr <- Call.array gers+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      isuppzPtr <- Call.ioarray isuppz+      workPtr <- Call.ioarray work+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.larrv nPtr vlPtr vuPtr dPtr lPtr pivminPtr isplitPtr mPtr dolPtr douPtr minrgpPtr rtol1Ptr rtol2Ptr wPtr werrPtr wgapPtr iblockPtr indexwPtr gersPtr zPtr ldzPtr isuppzPtr workPtr iworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray z+         <*> Call.freezeArray isuppz+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlartg.f>+lartg ::+   Complex Double {- ^ f -} ->+   Complex Double {- ^ g -} ->+   IO (Double, Complex Double, Complex Double)+lartg f g = do+   evalContT $ do+      fPtr <- Call.complexDouble f+      gPtr <- Call.complexDouble g+      csPtr <- Call.alloca+      snPtr <- Call.alloca+      rPtr <- Call.alloca+      liftIO $ FFI.lartg fPtr gPtr csPtr snPtr rPtr+      liftIO $ pure (,,)+         <*> peek csPtr+         <*> peek snPtr+         <*> peek rPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlartv.f>+lartv ::+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   Int {- ^ incy -} ->+   CArray Int Double {- ^ c -} ->+   CArray Int (Complex Double) {- ^ s -} ->+   Int {- ^ incc -} ->+   IO ()+lartv n x incx y incy c s incc = do+   xDim0 <- Call.sizes1 <$> getBounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   let cDim0 = Call.sizes1 $ bounds c+   let sDim0 = Call.sizes1 $ bounds s+   Call.assert "lartv: 1+(n-1)*incx == xDim0" (1+(n-1)*incx == xDim0)+   Call.assert "lartv: 1+(n-1)*incy == yDim0" (1+(n-1)*incy == yDim0)+   Call.assert "lartv: 1+(n-1)*incc == cDim0" (1+(n-1)*incc == cDim0)+   Call.assert "lartv: 1+(n-1)*incc == sDim0" (1+(n-1)*incc == sDim0)+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.ioarray x+      incxPtr <- Call.cint incx+      yPtr <- Call.ioarray y+      incyPtr <- Call.cint incy+      cPtr <- Call.array c+      sPtr <- Call.array s+      inccPtr <- Call.cint incc+      liftIO $ FFI.lartv nPtr xPtr incxPtr yPtr incyPtr cPtr sPtr inccPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarz.f>+larz ::+   Char {- ^ side -} ->+   Int {- ^ m -} ->+   Int {- ^ l -} ->+   CArray Int (Complex Double) {- ^ v -} ->+   Int {- ^ incv -} ->+   Complex Double {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO ()+larz side m l v incv tau c workSize = do+   let vDim0 = Call.sizes1 $ bounds v+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let n = cDim0+   let ldc = cDim1+   Call.assert "larz: 1+(l-1)*abs(incv) == vDim0" (1+(l-1)*abs(incv) == vDim0)+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      lPtr <- Call.cint l+      vPtr <- Call.array v+      incvPtr <- Call.cint incv+      tauPtr <- Call.complexDouble tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      liftIO $ FFI.larz sidePtr mPtr nPtr lPtr vPtr incvPtr tauPtr cPtr ldcPtr workPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarzb.f>+larzb ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Char {- ^ direct -} ->+   Char {- ^ storev -} ->+   Int {- ^ m -} ->+   Int {- ^ l -} ->+   CArray (Int,Int) (Complex Double) {- ^ v -} ->+   CArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ ldwork -} ->+   IO ()+larzb side trans direct storev m l v t c ldwork = do+   let (vDim0,vDim1) = Call.sizes2 $ bounds v+   let (tDim0,tDim1) = Call.sizes2 $ bounds t+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _nv = vDim0+   let ldv = vDim1+   let k = tDim0+   let ldt = tDim1+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray2 k ldwork+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      directPtr <- Call.char direct+      storevPtr <- Call.char storev+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      lPtr <- Call.cint l+      vPtr <- Call.array v+      ldvPtr <- Call.cint ldv+      tPtr <- Call.array t+      ldtPtr <- Call.cint ldt+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      ldworkPtr <- Call.cint ldwork+      liftIO $ FFI.larzb sidePtr transPtr directPtr storevPtr mPtr nPtr kPtr lPtr vPtr ldvPtr tPtr ldtPtr cPtr ldcPtr workPtr ldworkPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlarzt.f>+larzt ::+   Char {- ^ direct -} ->+   Char {- ^ storev -} ->+   Int {- ^ n -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ ldt -} ->+   IO (CArray (Int,Int) (Complex Double))+larzt direct storev n v tau ldt = do+   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v+   let tauDim0 = Call.sizes1 $ bounds tau+   let _vSize = vDim0+   let ldv = vDim1+   let k = tauDim0+   t <- Call.newArray2 k ldt+   evalContT $ do+      directPtr <- Call.char direct+      storevPtr <- Call.char storev+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      tauPtr <- Call.array tau+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      liftIO $ FFI.larzt directPtr storevPtr nPtr kPtr vPtr ldvPtr tauPtr tPtr ldtPtr+      liftIO $ Call.freezeArray t++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlascl.f>+lascl ::+   Char {- ^ type_ -} ->+   Int {- ^ kl -} ->+   Int {- ^ ku -} ->+   Double {- ^ cfrom -} ->+   Double {- ^ cto -} ->+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+lascl type_ kl ku cfrom cto m a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      type_Ptr <- Call.char type_+      klPtr <- Call.cint kl+      kuPtr <- Call.cint ku+      cfromPtr <- Call.double cfrom+      ctoPtr <- Call.double cto+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.lascl type_Ptr klPtr kuPtr cfromPtr ctoPtr mPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaset.f>+laset ::+   Char {- ^ uplo -} ->+   Int {- ^ m -} ->+   Int {- ^ n -} ->+   Complex Double {- ^ alpha -} ->+   Complex Double {- ^ beta -} ->+   Int {- ^ lda -} ->+   IO (CArray (Int,Int) (Complex Double))+laset uplo m n alpha beta lda = do+   a <- Call.newArray2 n lda+   evalContT $ do+      uploPtr <- Call.char uplo+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      betaPtr <- Call.complexDouble beta+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      liftIO $ FFI.laset uploPtr mPtr nPtr alphaPtr betaPtr aPtr ldaPtr+      liftIO $ Call.freezeArray a++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlasr.f>+lasr ::+   Char {- ^ side -} ->+   Char {- ^ pivot -} ->+   Char {- ^ direct -} ->+   Int {- ^ m -} ->+   CArray Int Double {- ^ c -} ->+   CArray Int Double {- ^ s -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO ()+lasr side pivot direct m c s a = do+   let cDim0 = Call.sizes1 $ bounds c+   let sDim0 = Call.sizes1 $ bounds s+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let _cSize = cDim0+   let _sSize = sDim0+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      sidePtr <- Call.char side+      pivotPtr <- Call.char pivot+      directPtr <- Call.char direct+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      cPtr <- Call.array c+      sPtr <- Call.array s+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      liftIO $ FFI.lasr sidePtr pivotPtr directPtr mPtr nPtr cPtr sPtr aPtr ldaPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlassq.f>+lassq ::+   CArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   Double {- ^ scale -} ->+   Double {- ^ sumsq -} ->+   IO (Double, Double)+lassq x incx scale sumsq = do+   let xDim0 = Call.sizes1 $ bounds x+   let n = xDim0+   evalContT $ do+      nPtr <- Call.cint n+      xPtr <- Call.array x+      incxPtr <- Call.cint incx+      scalePtr <- Call.double scale+      sumsqPtr <- Call.double sumsq+      liftIO $ FFI.lassq nPtr xPtr incxPtr scalePtr sumsqPtr+      liftIO $ pure (,)+         <*> peek scalePtr+         <*> peek sumsqPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlaswp.f>+laswp ::+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ k1 -} ->+   Int {- ^ k2 -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ incx -} ->+   IO ()+laswp a k1 k2 ipiv incx = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "laswp: k1+(k2-k1)*abs(incx) == ipivDim0" (k1+(k2-k1)*abs(incx) == ipivDim0)+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      k1Ptr <- Call.cint k1+      k2Ptr <- Call.cint k2+      ipivPtr <- Call.array ipiv+      incxPtr <- Call.cint incx+      liftIO $ FFI.laswp nPtr aPtr ldaPtr k1Ptr k2Ptr ipivPtr incxPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlasyf.f>+lasyf ::+   Char {- ^ uplo -} ->+   Int {- ^ nb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldw -} ->+   IO (Int, CArray Int CInt, CArray (Int,Int) (Complex Double), Int)+lasyf uplo nb a ldw = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   w <- Call.newArray2 nb ldw+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nbPtr <- Call.cint nb+      kbPtr <- Call.alloca+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      wPtr <- Call.ioarray w+      ldwPtr <- Call.cint ldw+      infoPtr <- Call.alloca+      liftIO $ FFI.lasyf uploPtr nPtr nbPtr kbPtr aPtr ldaPtr ipivPtr wPtr ldwPtr infoPtr+      liftIO $ pure (,,,)+         <*> fmap fromIntegral (peek kbPtr)+         <*> Call.freezeArray ipiv+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlat2c.f>+lat2c ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldsa -} ->+   IO (CArray (Int,Int) (Complex Float), Int)+lat2c uplo a ldsa = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   sa <- Call.newArray2 n ldsa+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      saPtr <- Call.ioarray sa+      ldsaPtr <- Call.cint ldsa+      infoPtr <- Call.alloca+      liftIO $ FFI.lat2c uploPtr nPtr aPtr ldaPtr saPtr ldsaPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray sa+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatbs.f>+latbs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Char {- ^ normin -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   IOCArray Int Double {- ^ cnorm -} ->+   IO (Double, Int)+latbs uplo trans diag normin kd ab x cnorm = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   xDim0 <- Call.sizes1 <$> getBounds x+   cnormDim0 <- Call.sizes1 <$> getBounds cnorm+   let n = abDim0+   let ldab = abDim1+   Call.assert "latbs: n == xDim0" (n == xDim0)+   Call.assert "latbs: n == cnormDim0" (n == cnormDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      norminPtr <- Call.char normin+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      xPtr <- Call.ioarray x+      scalePtr <- Call.alloca+      cnormPtr <- Call.ioarray cnorm+      infoPtr <- Call.alloca+      liftIO $ FFI.latbs uploPtr transPtr diagPtr norminPtr nPtr kdPtr abPtr ldabPtr xPtr scalePtr cnormPtr infoPtr+      liftIO $ pure (,)+         <*> peek scalePtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatdf.f>+latdf ::+   Int {- ^ ijob -} ->+   CArray (Int,Int) (Complex Double) {- ^ z -} ->+   IOCArray Int (Complex Double) {- ^ rhs -} ->+   Double {- ^ rdsum -} ->+   Double {- ^ rdscal -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray Int CInt {- ^ jpiv -} ->+   IO (Double, Double)+latdf ijob z rhs rdsum rdscal ipiv jpiv = do+   let (zDim0,zDim1) = Call.sizes2 $ bounds z+   rhsDim0 <- Call.sizes1 <$> getBounds rhs+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let jpivDim0 = Call.sizes1 $ bounds jpiv+   let n = zDim0+   let ldz = zDim1+   Call.assert "latdf: n == rhsDim0" (n == rhsDim0)+   Call.assert "latdf: n == ipivDim0" (n == ipivDim0)+   Call.assert "latdf: n == jpivDim0" (n == jpivDim0)+   evalContT $ do+      ijobPtr <- Call.cint ijob+      nPtr <- Call.cint n+      zPtr <- Call.array z+      ldzPtr <- Call.cint ldz+      rhsPtr <- Call.ioarray rhs+      rdsumPtr <- Call.double rdsum+      rdscalPtr <- Call.double rdscal+      ipivPtr <- Call.array ipiv+      jpivPtr <- Call.array jpiv+      liftIO $ FFI.latdf ijobPtr nPtr zPtr ldzPtr rhsPtr rdsumPtr rdscalPtr ipivPtr jpivPtr+      liftIO $ pure (,)+         <*> peek rdsumPtr+         <*> peek rdscalPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatps.f>+latps ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Char {- ^ normin -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   IOCArray Int Double {- ^ cnorm -} ->+   IO (Double, Int)+latps uplo trans diag normin ap x cnorm = do+   let apDim0 = Call.sizes1 $ bounds ap+   xDim0 <- Call.sizes1 <$> getBounds x+   cnormDim0 <- Call.sizes1 <$> getBounds cnorm+   let n = xDim0+   Call.assert "latps: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "latps: n == cnormDim0" (n == cnormDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      norminPtr <- Call.char normin+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      xPtr <- Call.ioarray x+      scalePtr <- Call.alloca+      cnormPtr <- Call.ioarray cnorm+      infoPtr <- Call.alloca+      liftIO $ FFI.latps uploPtr transPtr diagPtr norminPtr nPtr apPtr xPtr scalePtr cnormPtr infoPtr+      liftIO $ pure (,)+         <*> peek scalePtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrd.f>+latrd ::+   Char {- ^ uplo -} ->+   Int {- ^ nb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ ldw -} ->+   IO (CArray Int Double, CArray Int (Complex Double), CArray (Int,Int) (Complex Double))+latrd uplo nb a ldw = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   e <- Call.newArray1 (n-1)+   tau <- Call.newArray1 (n-1)+   w <- Call.newArray2 nb ldw+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nbPtr <- Call.cint nb+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ePtr <- Call.ioarray e+      tauPtr <- Call.ioarray tau+      wPtr <- Call.ioarray w+      ldwPtr <- Call.cint ldw+      liftIO $ FFI.latrd uploPtr nPtr nbPtr aPtr ldaPtr ePtr tauPtr wPtr ldwPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray e+         <*> Call.freezeArray tau+         <*> Call.freezeArray w++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrs.f>+latrs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Char {- ^ normin -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray Int (Complex Double) {- ^ x -} ->+   IOCArray Int Double {- ^ cnorm -} ->+   IO (Double, Int)+latrs uplo trans diag normin a x cnorm = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   xDim0 <- Call.sizes1 <$> getBounds x+   cnormDim0 <- Call.sizes1 <$> getBounds cnorm+   let n = aDim0+   let lda = aDim1+   Call.assert "latrs: n == xDim0" (n == xDim0)+   Call.assert "latrs: n == cnormDim0" (n == cnormDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      norminPtr <- Call.char normin+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      xPtr <- Call.ioarray x+      scalePtr <- Call.alloca+      cnormPtr <- Call.ioarray cnorm+      infoPtr <- Call.alloca+      liftIO $ FFI.latrs uploPtr transPtr diagPtr norminPtr nPtr aPtr ldaPtr xPtr scalePtr cnormPtr infoPtr+      liftIO $ pure (,)+         <*> peek scalePtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlatrz.f>+latrz ::+   Int {- ^ m -} ->+   Int {- ^ l -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double))+latrz m l a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 m+   work <- Call.newArray1 m+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      lPtr <- Call.cint l+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      liftIO $ FFI.latrz mPtr nPtr lPtr aPtr ldaPtr tauPtr workPtr+      liftIO $ Call.freezeArray tau++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlauu2.f>+lauu2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+lauu2 uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.lauu2 uploPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zlauum.f>+lauum ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+lauum uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.lauum uploPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbcon.f>+pbcon ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+pbcon uplo kd ab anorm = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.pbcon uploPtr nPtr kdPtr abPtr ldabPtr anormPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbequ.f>+pbequ ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (CArray Int Double, Double, Double, Int)+pbequ uplo kd ab = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   s <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.pbequ uploPtr nPtr kdPtr abPtr ldabPtr sPtr scondPtr amaxPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbrfs.f>+pbrfs ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray (Int,Int) (Complex Double) {- ^ afb -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+pbrfs uplo kd ab afb b x = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let (afbDim0,afbDim1) = Call.sizes2 $ bounds afb+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = abDim0+   let ldab = abDim1+   let ldafb = afbDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "pbrfs: n == afbDim0" (n == afbDim0)+   Call.assert "pbrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      afbPtr <- Call.array afb+      ldafbPtr <- Call.cint ldafb+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.pbrfs uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbstf.f>+pbstf ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (Int)+pbstf uplo kd ab = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      infoPtr <- Call.alloca+      liftIO $ FFI.pbstf uploPtr nPtr kdPtr abPtr ldabPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbsv.f>+pbsv ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+pbsv uplo kd ab b = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.pbsv uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbsvx.f>+pbsvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ afb -} ->+   Char {- ^ equed -} ->+   IOCArray Int Double {- ^ s -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+pbsvx fact uplo kd ab afb equed s b ldx = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   (afbDim0,afbDim1) <- Call.sizes2 <$> getBounds afb+   sDim0 <- Call.sizes1 <$> getBounds s+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let ldafb = afbDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "pbsvx: n == afbDim0" (n == afbDim0)+   Call.assert "pbsvx: n == sDim0" (n == sDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      afbPtr <- Call.ioarray afb+      ldafbPtr <- Call.cint ldafb+      equedPtr <- Call.char equed+      sPtr <- Call.ioarray s+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.pbsvx factPtr uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr afbPtr ldafbPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap castCCharToChar (peek equedPtr)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtf2.f>+pbtf2 ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (Int)+pbtf2 uplo kd ab = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      infoPtr <- Call.alloca+      liftIO $ FFI.pbtf2 uploPtr nPtr kdPtr abPtr ldabPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtrf.f>+pbtrf ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (Int)+pbtrf uplo kd ab = do+   (abDim0,abDim1) <- Call.sizes2 <$> getBounds ab+   let n = abDim0+   let ldab = abDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.ioarray ab+      ldabPtr <- Call.cint ldab+      infoPtr <- Call.alloca+      liftIO $ FFI.pbtrf uploPtr nPtr kdPtr abPtr ldabPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpbtrs.f>+pbtrs ::+   Char {- ^ uplo -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+pbtrs uplo kd ab b = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.pbtrs uploPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftrf.f>+pftrf ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ a -} ->+   IO (Int)+pftrf transr uplo n a = do+   aDim0 <- Call.sizes1 <$> getBounds a+   Call.assert "pftrf: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      infoPtr <- Call.alloca+      liftIO $ FFI.pftrf transrPtr uploPtr nPtr aPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftri.f>+pftri ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ a -} ->+   IO (Int)+pftri transr uplo n a = do+   aDim0 <- Call.sizes1 <$> getBounds a+   Call.assert "pftri: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      infoPtr <- Call.alloca+      liftIO $ FFI.pftri transrPtr uploPtr nPtr aPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpftrs.f>+pftrs ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+pftrs transr uplo n a b = do+   let aDim0 = Call.sizes1 $ bounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "pftrs: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.pftrs transrPtr uploPtr nPtr nrhsPtr aPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpocon.f>+pocon ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+pocon uplo a anorm = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.pocon uploPtr nPtr aPtr ldaPtr anormPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpoequ.f>+poequ ::+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, Double, Double, Int)+poequ a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.poequ nPtr aPtr ldaPtr sPtr scondPtr amaxPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpoequb.f>+poequb ::+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, Double, Double, Int)+poequb a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.poequb nPtr aPtr ldaPtr sPtr scondPtr amaxPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zporfs.f>+porfs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ af -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+porfs uplo a af b x = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (afDim0,afDim1) = Call.sizes2 $ bounds af+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "porfs: n == afDim0" (n == afDim0)+   Call.assert "porfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.array af+      ldafPtr <- Call.cint ldaf+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.porfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zposv.f>+posv ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+posv uplo a b = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.posv uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zposvx.f>+posvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->+   Char {- ^ equed -} ->+   IOCArray Int Double {- ^ s -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+posvx fact uplo a af equed s b ldx = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af+   sDim0 <- Call.sizes1 <$> getBounds s+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "posvx: n == afDim0" (n == afDim0)+   Call.assert "posvx: n == sDim0" (n == sDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      afPtr <- Call.ioarray af+      ldafPtr <- Call.cint ldaf+      equedPtr <- Call.char equed+      sPtr <- Call.ioarray s+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.posvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap castCCharToChar (peek equedPtr)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotf2.f>+potf2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+potf2 uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.potf2 uploPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotrf.f>+potrf ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+potrf uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.potrf uploPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotri.f>+potri ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+potri uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.potri uploPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpotrs.f>+potrs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+potrs uplo a b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.potrs uploPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppcon.f>+ppcon ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+ppcon uplo n ap anorm = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "ppcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ppcon uploPtr nPtr apPtr anormPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppequ.f>+ppequ ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IO (CArray Int Double, Double, Double, Int)+ppequ uplo n ap = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "ppequ: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   s <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.ppequ uploPtr nPtr apPtr sPtr scondPtr amaxPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpprfs.f>+pprfs ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ afp -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+pprfs uplo n ap afp b x = do+   let apDim0 = Call.sizes1 $ bounds ap+   let afpDim0 = Call.sizes1 $ bounds afp+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "pprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "pprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   Call.assert "pprfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      afpPtr <- Call.array afp+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.pprfs uploPtr nPtr nrhsPtr apPtr afpPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppsv.f>+ppsv ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+ppsv uplo n ap b = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "ppsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.ioarray ap+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.ppsv uploPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zppsvx.f>+ppsvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ afp -} ->+   Char {- ^ equed -} ->+   IOCArray Int Double {- ^ s -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (Char, CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+ppsvx fact uplo ap afp equed s b ldx = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   afpDim0 <- Call.sizes1 <$> getBounds afp+   sDim0 <- Call.sizes1 <$> getBounds s+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = sDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "ppsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "ppsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.ioarray ap+      afpPtr <- Call.ioarray afp+      equedPtr <- Call.char equed+      sPtr <- Call.ioarray s+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ppsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr equedPtr sPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap castCCharToChar (peek equedPtr)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptrf.f>+pptrf ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (Int)+pptrf uplo n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "pptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      infoPtr <- Call.alloca+      liftIO $ FFI.pptrf uploPtr nPtr apPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptri.f>+pptri ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (Int)+pptri uplo n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "pptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      infoPtr <- Call.alloca+      liftIO $ FFI.pptri uploPtr nPtr apPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpptrs.f>+pptrs ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+pptrs uplo n ap b = do+   let apDim0 = Call.sizes1 $ bounds ap+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "pptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.pptrs uploPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpstf2.f>+pstf2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ tol -} ->+   IO (CArray Int CInt, Int, Int)+pstf2 uplo a tol = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   piv <- Call.newArray1 n+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      pivPtr <- Call.ioarray piv+      rankPtr <- Call.alloca+      tolPtr <- Call.double tol+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.pstf2 uploPtr nPtr aPtr ldaPtr pivPtr rankPtr tolPtr workPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray piv+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpstrf.f>+pstrf ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Double {- ^ tol -} ->+   IO (CArray Int CInt, Int, Int)+pstrf uplo a tol = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   piv <- Call.newArray1 n+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      pivPtr <- Call.ioarray piv+      rankPtr <- Call.alloca+      tolPtr <- Call.double tol+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.pstrf uploPtr nPtr aPtr ldaPtr pivPtr rankPtr tolPtr workPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray piv+         <*> fmap fromIntegral (peek rankPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptcon.f>+ptcon ::+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+ptcon d e anorm = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   let n = dDim0+   Call.assert "ptcon: n-1 == eDim0" (n-1 == eDim0)+   rwork <- Call.newArray1 n+   evalContT $ do+      nPtr <- Call.cint n+      dPtr <- Call.array d+      ePtr <- Call.array e+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ptcon nPtr dPtr ePtr anormPtr rcondPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpteqr.f>+pteqr ::+   Char {- ^ compz -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   IO (Int)+pteqr compz d e z = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = dDim0+   let ldz = zDim1+   Call.assert "pteqr: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "pteqr: n == zDim0" (n == zDim0)+   work <- Call.newArray1 (4*n)+   evalContT $ do+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.pteqr compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptrfs.f>+ptrfs ::+   Char {- ^ uplo -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   CArray Int Double {- ^ df -} ->+   CArray Int (Complex Double) {- ^ ef -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+ptrfs uplo d e df ef b x = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   let dfDim0 = Call.sizes1 $ bounds df+   let efDim0 = Call.sizes1 $ bounds ef+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "ptrfs: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "ptrfs: n == dfDim0" (n == dfDim0)+   Call.assert "ptrfs: n-1 == efDim0" (n-1 == efDim0)+   Call.assert "ptrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 n+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.array d+      ePtr <- Call.array e+      dfPtr <- Call.array df+      efPtr <- Call.array ef+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ptrfs uploPtr nPtr nrhsPtr dPtr ePtr dfPtr efPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptsv.f>+ptsv ::+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int (Complex Double) {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+ptsv d e b = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "ptsv: n-1 == eDim0" (n-1 == eDim0)+   evalContT $ do+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.ptsv nPtr nrhsPtr dPtr ePtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptsvx.f>+ptsvx ::+   Char {- ^ fact -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   IOCArray Int Double {- ^ df -} ->+   IOCArray Int (Complex Double) {- ^ ef -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+ptsvx fact d e df ef b ldx = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   dfDim0 <- Call.sizes1 <$> getBounds df+   efDim0 <- Call.sizes1 <$> getBounds ef+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "ptsvx: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "ptsvx: n == dfDim0" (n == dfDim0)+   Call.assert "ptsvx: n-1 == efDim0" (n-1 == efDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 n+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.array d+      ePtr <- Call.array e+      dfPtr <- Call.ioarray df+      efPtr <- Call.ioarray ef+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ptsvx factPtr nPtr nrhsPtr dPtr ePtr dfPtr efPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpttrf.f>+pttrf ::+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int (Complex Double) {- ^ e -} ->+   IO (Int)+pttrf d e = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   let n = dDim0+   Call.assert "pttrf: n-1 == eDim0" (n-1 == eDim0)+   evalContT $ do+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      infoPtr <- Call.alloca+      liftIO $ FFI.pttrf nPtr dPtr ePtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zpttrs.f>+pttrs ::+   Char {- ^ uplo -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+pttrs uplo d e b = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "pttrs: n-1 == eDim0" (n-1 == eDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.array d+      ePtr <- Call.array e+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.pttrs uploPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zptts2.f>+ptts2 ::+   Int {- ^ iuplo -} ->+   CArray Int Double {- ^ d -} ->+   CArray Int (Complex Double) {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO ()+ptts2 iuplo d e b = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = dDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "ptts2: n-1 == eDim0" (n-1 == eDim0)+   evalContT $ do+      iuploPtr <- Call.cint iuplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      dPtr <- Call.array d+      ePtr <- Call.array e+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.ptts2 iuploPtr nPtr nrhsPtr dPtr ePtr bPtr ldbPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zrot.f>+rot ::+   IOCArray Int (Complex Double) {- ^ cx -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ cy -} ->+   Int {- ^ incy -} ->+   Double {- ^ c -} ->+   Complex Double {- ^ s -} ->+   IO ()+rot cx incx cy incy c s = do+   cxDim0 <- Call.sizes1 <$> getBounds cx+   cyDim0 <- Call.sizes1 <$> getBounds cy+   let n = cxDim0+   Call.assert "rot: n == cyDim0" (n == cyDim0)+   evalContT $ do+      nPtr <- Call.cint n+      cxPtr <- Call.ioarray cx+      incxPtr <- Call.cint incx+      cyPtr <- Call.ioarray cy+      incyPtr <- Call.cint incy+      cPtr <- Call.double c+      sPtr <- Call.complexDouble s+      liftIO $ FFI.rot nPtr cxPtr incxPtr cyPtr incyPtr cPtr sPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zdrscl.f>+rscl ::+   Int {- ^ n -} ->+   Double {- ^ sa -} ->+   IOCArray Int (Complex Double) {- ^ sx -} ->+   Int {- ^ incx -} ->+   IO ()+rscl n sa sx incx = do+   sxDim0 <- Call.sizes1 <$> getBounds sx+   let _sxSize = sxDim0+   evalContT $ do+      nPtr <- Call.cint n+      saPtr <- Call.double sa+      sxPtr <- Call.ioarray sx+      incxPtr <- Call.cint incx+      liftIO $ FFI.rscl nPtr saPtr sxPtr incxPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspcon.f>+spcon ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+spcon uplo ap ipiv anorm = do+   let apDim0 = Call.sizes1 $ bounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = ipivDim0+   Call.assert "spcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.spcon uploPtr nPtr apPtr ipivPtr anormPtr rcondPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspmv.f>+spmv ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   Complex Double {- ^ alpha -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   Complex Double {- ^ beta -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   Int {- ^ incy -} ->+   IO ()+spmv uplo n alpha ap x incx beta y incy = do+   let apDim0 = Call.sizes1 $ bounds ap+   let xDim0 = Call.sizes1 $ bounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   let _apSize = apDim0+   let _xSize = xDim0+   let _ySize = yDim0+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      apPtr <- Call.array ap+      xPtr <- Call.array x+      incxPtr <- Call.cint incx+      betaPtr <- Call.complexDouble beta+      yPtr <- Call.ioarray y+      incyPtr <- Call.cint incy+      liftIO $ FFI.spmv uploPtr nPtr alphaPtr apPtr xPtr incxPtr betaPtr yPtr incyPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspr.f>+spr ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   Complex Double {- ^ alpha -} ->+   CArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO ()+spr uplo n alpha x incx ap = do+   let xDim0 = Call.sizes1 $ bounds x+   apDim0 <- Call.sizes1 <$> getBounds ap+   let _xSize = xDim0+   let _apSize = apDim0+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      xPtr <- Call.array x+      incxPtr <- Call.cint incx+      apPtr <- Call.ioarray ap+      liftIO $ FFI.spr uploPtr nPtr alphaPtr xPtr incxPtr apPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsprfs.f>+sprfs ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ afp -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+sprfs uplo ap afp ipiv b x = do+   let apDim0 = Call.sizes1 $ bounds ap+   let afpDim0 = Call.sizes1 $ bounds afp+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "sprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "sprfs: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   Call.assert "sprfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      afpPtr <- Call.array afp+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.sprfs uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspsv.f>+spsv ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (CArray Int CInt, Int)+spsv uplo n ap b = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "spsv: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.spsv uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zspsvx.f>+spsvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IOCArray Int (Complex Double) {- ^ afp -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+spsvx fact uplo ap afp ipiv b ldx = do+   let apDim0 = Call.sizes1 $ bounds ap+   afpDim0 <- Call.sizes1 <$> getBounds afp+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "spsvx: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "spsvx: n*(n+1)`div`2 == afpDim0" (n*(n+1)`div`2 == afpDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      afpPtr <- Call.ioarray afp+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.spsvx factPtr uploPtr nPtr nrhsPtr apPtr afpPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptrf.f>+sptrf ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (CArray Int CInt, Int)+sptrf uplo n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "sptrf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.sptrf uploPtr nPtr apPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptri.f>+sptri ::+   Char {- ^ uplo -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IO (Int)+sptri uplo ap ipiv = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = ipivDim0+   Call.assert "sptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.sptri uploPtr nPtr apPtr ipivPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsptrs.f>+sptrs ::+   Char {- ^ uplo -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+sptrs uplo ap ipiv b = do+   let apDim0 = Call.sizes1 $ bounds ap+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = ipivDim0+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "sptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.sptrs uploPtr nPtr nrhsPtr apPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstedc.f>+stedc ::+   Char {- ^ compz -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ lwork -} ->+   Int {- ^ lrwork -} ->+   Int {- ^ liwork -} ->+   IO (Int)+stedc compz d e z lwork lrwork liwork = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = dDim0+   let ldz = zDim1+   Call.assert "stedc: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "stedc: n == zDim0" (n == zDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 (maximum[1,lrwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.stedc compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstegr.f>+stegr ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Double {- ^ abstol -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   Int {- ^ lwork -} ->+   Int {- ^ liwork -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+stegr jobz range d e vl vu il iu abstol m ldz lwork liwork = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   let n = dDim0+   Call.assert "stegr: n == eDim0" (n == eDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   isuppz <- Call.newArray1 (2*maximum[1,m])+   work <- Call.newArray1 lwork+   iwork <- Call.newArray1 liwork+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      abstolPtr <- Call.double abstol+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      isuppzPtr <- Call.ioarray isuppz+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.stegr jobzPtr rangePtr nPtr dPtr ePtr vlPtr vuPtr ilPtr iuPtr abstolPtr mPtr wPtr zPtr ldzPtr isuppzPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray isuppz+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstein.f>+stein ::+   CArray Int Double {- ^ d -} ->+   CArray Int Double {- ^ e -} ->+   Int {- ^ m -} ->+   CArray Int Double {- ^ w -} ->+   CArray Int CInt {- ^ iblock -} ->+   CArray Int CInt {- ^ isplit -} ->+   Int {- ^ ldz -} ->+   IO (CArray (Int,Int) (Complex Double), CArray Int CInt, Int)+stein d e m w iblock isplit ldz = do+   let dDim0 = Call.sizes1 $ bounds d+   let eDim0 = Call.sizes1 $ bounds e+   let wDim0 = Call.sizes1 $ bounds w+   let iblockDim0 = Call.sizes1 $ bounds iblock+   let isplitDim0 = Call.sizes1 $ bounds isplit+   let n = dDim0+   Call.assert "stein: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "stein: n == wDim0" (n == wDim0)+   Call.assert "stein: n == iblockDim0" (n == iblockDim0)+   Call.assert "stein: n == isplitDim0" (n == isplitDim0)+   z <- Call.newArray2 m ldz+   work <- Call.newArray1 (5*n)+   iwork <- Call.newArray1 n+   ifail <- Call.newArray1 m+   evalContT $ do+      nPtr <- Call.cint n+      dPtr <- Call.array d+      ePtr <- Call.array e+      mPtr <- Call.cint m+      wPtr <- Call.array w+      iblockPtr <- Call.array iblock+      isplitPtr <- Call.array isplit+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      iworkPtr <- Call.ioarray iwork+      ifailPtr <- Call.ioarray ifail+      infoPtr <- Call.alloca+      liftIO $ FFI.stein nPtr dPtr ePtr mPtr wPtr iblockPtr isplitPtr zPtr ldzPtr workPtr iworkPtr ifailPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray z+         <*> Call.freezeArray ifail+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zstemr.f>+stemr ::+   Char {- ^ jobz -} ->+   Char {- ^ range -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   Double {- ^ vl -} ->+   Double {- ^ vu -} ->+   Int {- ^ il -} ->+   Int {- ^ iu -} ->+   Int {- ^ m -} ->+   Int {- ^ ldz -} ->+   Int {- ^ nzc -} ->+   Bool {- ^ tryrac -} ->+   Int {- ^ lwork -} ->+   Int {- ^ liwork -} ->+   IO (Int, CArray Int Double, CArray (Int,Int) (Complex Double), CArray Int CInt, Bool, Int)+stemr jobz range d e vl vu il iu m ldz nzc tryrac lwork liwork = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   let n = dDim0+   Call.assert "stemr: n == eDim0" (n == eDim0)+   w <- Call.newArray1 n+   z <- Call.newArray2 (maximum[1,m]) ldz+   isuppz <- Call.newArray1 (2*maximum[1,m])+   work <- Call.newArray1 lwork+   iwork <- Call.newArray1 liwork+   evalContT $ do+      jobzPtr <- Call.char jobz+      rangePtr <- Call.char range+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      vlPtr <- Call.double vl+      vuPtr <- Call.double vu+      ilPtr <- Call.cint il+      iuPtr <- Call.cint iu+      mPtr <- Call.alloca+      wPtr <- Call.ioarray w+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      nzcPtr <- Call.cint nzc+      isuppzPtr <- Call.ioarray isuppz+      tryracPtr <- Call.bool tryrac+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.stemr jobzPtr rangePtr nPtr dPtr ePtr vlPtr vuPtr ilPtr iuPtr mPtr wPtr zPtr ldzPtr nzcPtr isuppzPtr tryracPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> fmap fromIntegral (peek mPtr)+         <*> Call.freezeArray w+         <*> Call.freezeArray z+         <*> Call.freezeArray isuppz+         <*> peek tryracPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsteqr.f>+steqr ::+   Char {- ^ compz -} ->+   IOCArray Int Double {- ^ d -} ->+   IOCArray Int Double {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   IO (Int)+steqr compz d e z = do+   dDim0 <- Call.sizes1 <$> getBounds d+   eDim0 <- Call.sizes1 <$> getBounds e+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = dDim0+   let ldz = zDim1+   Call.assert "steqr: n-1 == eDim0" (n-1 == eDim0)+   Call.assert "steqr: n == zDim0" (n == zDim0)+   work <- Call.newArray1 (maximum[1,2*n-2])+   evalContT $ do+      compzPtr <- Call.char compz+      nPtr <- Call.cint n+      dPtr <- Call.ioarray d+      ePtr <- Call.ioarray e+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.steqr compzPtr nPtr dPtr ePtr zPtr ldzPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dzsum1.f>+sum1 ::+   CArray Int (Complex Double) {- ^ cx -} ->+   Int {- ^ incx -} ->+   IO Double+sum1 cx incx = do+   let cxDim0 = Call.sizes1 $ bounds cx+   let n = cxDim0+   evalContT $ do+      nPtr <- Call.cint n+      cxPtr <- Call.array cx+      incxPtr <- Call.cint incx+      liftIO $ FFI.sum1 nPtr cxPtr incxPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsycon.f>+sycon ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Double {- ^ anorm -} ->+   IO (Double, Int)+sycon uplo a ipiv anorm = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "sycon: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      anormPtr <- Call.double anorm+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.sycon uploPtr nPtr aPtr ldaPtr ipivPtr anormPtr rcondPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyconv.f>+syconv ::+   Char {- ^ uplo -} ->+   Char {- ^ way -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IO (CArray Int (Complex Double), Int)+syconv uplo way a ipiv = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "syconv: n == ipivDim0" (n == ipivDim0)+   e <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      wayPtr <- Call.char way+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      ePtr <- Call.ioarray e+      infoPtr <- Call.alloca+      liftIO $ FFI.syconv uploPtr wayPtr nPtr aPtr ldaPtr ipivPtr ePtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray e+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyequb.f>+syequb ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int Double, Double, Double, Int)+syequb uplo a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   s <- Call.newArray1 n+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      sPtr <- Call.ioarray s+      scondPtr <- Call.alloca+      amaxPtr <- Call.alloca+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.syequb uploPtr nPtr aPtr ldaPtr sPtr scondPtr amaxPtr workPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> peek scondPtr+         <*> peek amaxPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsymv.f>+symv ::+   Char {- ^ uplo -} ->+   Complex Double {- ^ alpha -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   Complex Double {- ^ beta -} ->+   IOCArray Int (Complex Double) {- ^ y -} ->+   Int {- ^ incy -} ->+   IO ()+symv uplo alpha a x incx beta y incy = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let xDim0 = Call.sizes1 $ bounds x+   yDim0 <- Call.sizes1 <$> getBounds y+   let n = aDim0+   let lda = aDim1+   let _xSize = xDim0+   let _ySize = yDim0+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      xPtr <- Call.array x+      incxPtr <- Call.cint incx+      betaPtr <- Call.complexDouble beta+      yPtr <- Call.ioarray y+      incyPtr <- Call.cint incy+      liftIO $ FFI.symv uploPtr nPtr alphaPtr aPtr ldaPtr xPtr incxPtr betaPtr yPtr incyPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyr.f>+syr ::+   Char {- ^ uplo -} ->+   Complex Double {- ^ alpha -} ->+   CArray Int (Complex Double) {- ^ x -} ->+   Int {- ^ incx -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO ()+syr uplo alpha x incx a = do+   let xDim0 = Call.sizes1 $ bounds x+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let _xSize = xDim0+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      xPtr <- Call.array x+      incxPtr <- Call.cint incx+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      liftIO $ FFI.syr uploPtr nPtr alphaPtr xPtr incxPtr aPtr ldaPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyrfs.f>+syrfs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ af -} ->+   CArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+syrfs uplo a af ipiv b x = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (afDim0,afDim1) = Call.sizes2 $ bounds af+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (xDim0,xDim1) <- Call.sizes2 <$> getBounds x+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "syrfs: n == afDim0" (n == afDim0)+   Call.assert "syrfs: n == ipivDim0" (n == ipivDim0)+   Call.assert "syrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.array af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.array ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.syrfs uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsysv.f>+sysv ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int CInt, Int)+sysv uplo a b lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   ipiv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.sysv uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsysvx.f>+sysvx ::+   Char {- ^ fact -} ->+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ af -} ->+   IOCArray Int CInt {- ^ ipiv -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   Int {- ^ ldx -} ->+   Int {- ^ lwork -} ->+   IO (CArray (Int,Int) (Complex Double), Double, CArray Int Double, CArray Int Double, Int)+sysvx fact uplo a af ipiv b ldx lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   (afDim0,afDim1) <- Call.sizes2 <$> getBounds af+   ipivDim0 <- Call.sizes1 <$> getBounds ipiv+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let n = aDim0+   let lda = aDim1+   let ldaf = afDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "sysvx: n == afDim0" (n == afDim0)+   Call.assert "sysvx: n == ipivDim0" (n == ipivDim0)+   x <- Call.newArray2 nrhs ldx+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 n+   evalContT $ do+      factPtr <- Call.char fact+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      afPtr <- Call.ioarray af+      ldafPtr <- Call.cint ldaf+      ipivPtr <- Call.ioarray ipiv+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.ioarray x+      ldxPtr <- Call.cint ldx+      rcondPtr <- Call.alloca+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.sysvx factPtr uploPtr nPtr nrhsPtr aPtr ldaPtr afPtr ldafPtr ipivPtr bPtr ldbPtr xPtr ldxPtr rcondPtr ferrPtr berrPtr workPtr lworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray x+         <*> peek rcondPtr+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsyswapr.f>+syswapr ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ i1 -} ->+   Int {- ^ i2 -} ->+   IO ()+syswapr uplo a i1 i2 = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      i1Ptr <- Call.cint i1+      i2Ptr <- Call.cint i2+      liftIO $ FFI.syswapr uploPtr nPtr aPtr ldaPtr i1Ptr i2Ptr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytf2.f>+sytf2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int CInt, Int)+sytf2 uplo a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      infoPtr <- Call.alloca+      liftIO $ FFI.sytf2 uploPtr nPtr aPtr ldaPtr ipivPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrf.f>+sytrf ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int CInt, Int)+sytrf uplo a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   ipiv <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.ioarray ipiv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.sytrf uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ipiv+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri.f>+sytri ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IO (Int)+sytri uplo a ipiv = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "sytri: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (2*n)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.sytri uploPtr nPtr aPtr ldaPtr ipivPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri2.f>+sytri2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ nb -} ->+   Int {- ^ lwork -} ->+   IO (Int)+sytri2 uplo a ipiv nb lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "sytri2: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 (n+nb+1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.sytri2 uploPtr nPtr aPtr ldaPtr ipivPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytri2x.f>+sytri2x ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   Int {- ^ nb -} ->+   IO (Int)+sytri2x uplo a ipiv nb = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   let n = aDim0+   let lda = aDim1+   Call.assert "sytri2x: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray2 (nb+3) (n+nb+1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      workPtr <- Call.ioarray work+      nbPtr <- Call.cint nb+      infoPtr <- Call.alloca+      liftIO $ FFI.sytri2x uploPtr nPtr aPtr ldaPtr ipivPtr workPtr nbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrs.f>+sytrs ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+sytrs uplo a ipiv b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "sytrs: n == ipivDim0" (n == ipivDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.sytrs uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsytrs2.f>+sytrs2 ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int CInt {- ^ ipiv -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+sytrs2 uplo a ipiv b = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let ipivDim0 = Call.sizes1 $ bounds ipiv+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "sytrs2: n == ipivDim0" (n == ipivDim0)+   work <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      ipivPtr <- Call.array ipiv+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.sytrs2 uploPtr nPtr nrhsPtr aPtr ldaPtr ipivPtr bPtr ldbPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbcon.f>+tbcon ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IO (Double, Int)+tbcon norm uplo diag kd ab = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let n = abDim0+   let ldab = abDim1+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tbcon normPtr uploPtr diagPtr nPtr kdPtr abPtr ldabPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbrfs.f>+tbrfs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   CArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+tbrfs uplo trans diag kd ab b x = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let (xDim0,xDim1) = Call.sizes2 $ bounds x+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "tbrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.array x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tbrfs uploPtr transPtr diagPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztbtrs.f>+tbtrs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Int {- ^ kd -} ->+   CArray (Int,Int) (Complex Double) {- ^ ab -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+tbtrs uplo trans diag kd ab b = do+   let (abDim0,abDim1) = Call.sizes2 $ bounds ab+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = abDim0+   let ldab = abDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      kdPtr <- Call.cint kd+      nrhsPtr <- Call.cint nrhs+      abPtr <- Call.array ab+      ldabPtr <- Call.cint ldab+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.tbtrs uploPtr transPtr diagPtr nPtr kdPtr nrhsPtr abPtr ldabPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfsm.f>+tfsm ::+   Char {- ^ transr -} ->+   Char {- ^ side -} ->+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Int {- ^ m -} ->+   Complex Double {- ^ alpha -} ->+   CArray Int (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO ()+tfsm transr side uplo trans diag m alpha a b = do+   let aDim0 = Call.sizes1 $ bounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = bDim0+   let ldb = bDim1+   Call.assert "tfsm: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      sidePtr <- Call.char side+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      alphaPtr <- Call.complexDouble alpha+      aPtr <- Call.array a+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      liftIO $ FFI.tfsm transrPtr sidePtr uploPtr transPtr diagPtr mPtr nPtr alphaPtr aPtr bPtr ldbPtr++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztftri.f>+tftri ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ a -} ->+   IO (Int)+tftri transr uplo diag n a = do+   aDim0 <- Call.sizes1 <$> getBounds a+   Call.assert "tftri: n*(n+1)`div`2 == aDim0" (n*(n+1)`div`2 == aDim0)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      infoPtr <- Call.alloca+      liftIO $ FFI.tftri transrPtr uploPtr diagPtr nPtr aPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfttp.f>+tfttp ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ arf -} ->+   IO (CArray Int (Complex Double), Int)+tfttp transr uplo n arf = do+   let arfDim0 = Call.sizes1 $ bounds arf+   Call.assert "tfttp: n*(n+1)`div`2 == arfDim0" (n*(n+1)`div`2 == arfDim0)+   ap <- Call.newArray1 (n*(n+1)`div`2)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      arfPtr <- Call.array arf+      apPtr <- Call.ioarray ap+      infoPtr <- Call.alloca+      liftIO $ FFI.tfttp transrPtr uploPtr nPtr arfPtr apPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ap+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztfttr.f>+tfttr ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ arf -} ->+   Int {- ^ lda -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+tfttr transr uplo n arf lda = do+   let arfDim0 = Call.sizes1 $ bounds arf+   Call.assert "tfttr: n*(n+1)`div`2 == arfDim0" (n*(n+1)`div`2 == arfDim0)+   a <- Call.newArray2 n lda+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      arfPtr <- Call.array arf+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.tfttr transrPtr uploPtr nPtr arfPtr aPtr ldaPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray a+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgevc.f>+tgevc ::+   Char {- ^ side -} ->+   Char {- ^ howmny -} ->+   CArray Int Bool {- ^ select -} ->+   CArray (Int,Int) (Complex Double) {- ^ s -} ->+   CArray (Int,Int) (Complex Double) {- ^ p -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->+   IO (Int, Int)+tgevc side howmny select s p vl vr = do+   let selectDim0 = Call.sizes1 $ bounds select+   let (sDim0,sDim1) = Call.sizes2 $ bounds s+   let (pDim0,pDim1) = Call.sizes2 $ bounds p+   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl+   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr+   let n = selectDim0+   let lds = sDim1+   let ldp = pDim1+   let mm = vlDim0+   let ldvl = vlDim1+   let ldvr = vrDim1+   Call.assert "tgevc: n == sDim0" (n == sDim0)+   Call.assert "tgevc: n == pDim0" (n == pDim0)+   Call.assert "tgevc: mm == vrDim0" (mm == vrDim0)+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 (2*n)+   evalContT $ do+      sidePtr <- Call.char side+      howmnyPtr <- Call.char howmny+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      sPtr <- Call.array s+      ldsPtr <- Call.cint lds+      pPtr <- Call.array p+      ldpPtr <- Call.cint ldp+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      mmPtr <- Call.cint mm+      mPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tgevc sidePtr howmnyPtr selectPtr nPtr sPtr ldsPtr pPtr ldpPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek mPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgex2.f>+tgex2 ::+   Bool {- ^ wantq -} ->+   Bool {- ^ wantz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ j1 -} ->+   IO (Int)+tgex2 wantq wantz a b q z j1 = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let _aSize = aDim0+   let lda = aDim1+   let _bSize = bDim0+   let ldb = bDim1+   let n = qDim0+   let ldq = qDim1+   let ldz = zDim1+   Call.assert "tgex2: n == zDim0" (n == zDim0)+   evalContT $ do+      wantqPtr <- Call.bool wantq+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      j1Ptr <- Call.cint j1+      infoPtr <- Call.alloca+      liftIO $ FFI.tgex2 wantqPtr wantzPtr nPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr j1Ptr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgexc.f>+tgexc ::+   Bool {- ^ wantq -} ->+   Bool {- ^ wantz -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ ifst -} ->+   Int {- ^ ilst -} ->+   IO (Int, Int)+tgexc wantq wantz a b q z ifst ilst = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   let ldq = qDim1+   let ldz = zDim1+   Call.assert "tgexc: n == bDim0" (n == bDim0)+   Call.assert "tgexc: n == qDim0" (n == qDim0)+   Call.assert "tgexc: n == zDim0" (n == zDim0)+   evalContT $ do+      wantqPtr <- Call.bool wantq+      wantzPtr <- Call.bool wantz+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      ifstPtr <- Call.cint ifst+      ilstPtr <- Call.cint ilst+      infoPtr <- Call.alloca+      liftIO $ FFI.tgexc wantqPtr wantzPtr nPtr aPtr ldaPtr bPtr ldbPtr qPtr ldqPtr zPtr ldzPtr ifstPtr ilstPtr infoPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek ilstPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsen.f>+tgsen ::+   Int {- ^ ijob -} ->+   Bool {- ^ wantq -} ->+   Bool {- ^ wantz -} ->+   CArray Int Bool {- ^ select -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ z -} ->+   Int {- ^ lwork -} ->+   Int {- ^ liwork -} ->+   IO (CArray Int (Complex Double), CArray Int (Complex Double), Int, Double, Double, CArray Int Double, Int)+tgsen ijob wantq wantz select a b q z lwork liwork = do+   let selectDim0 = Call.sizes1 $ bounds select+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   (zDim0,zDim1) <- Call.sizes2 <$> getBounds z+   let n = selectDim0+   let lda = aDim1+   let ldb = bDim1+   let ldq = qDim1+   let ldz = zDim1+   Call.assert "tgsen: n == aDim0" (n == aDim0)+   Call.assert "tgsen: n == bDim0" (n == bDim0)+   Call.assert "tgsen: n == qDim0" (n == qDim0)+   Call.assert "tgsen: n == zDim0" (n == zDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   dif <- Call.newArray1 2+   work <- Call.newArray1 (maximum[1,lwork])+   iwork <- Call.newArray1 (maximum[1,liwork])+   evalContT $ do+      ijobPtr <- Call.cint ijob+      wantqPtr <- Call.bool wantq+      wantzPtr <- Call.bool wantz+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      zPtr <- Call.ioarray z+      ldzPtr <- Call.cint ldz+      mPtr <- Call.alloca+      plPtr <- Call.alloca+      prPtr <- Call.alloca+      difPtr <- Call.ioarray dif+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      iworkPtr <- Call.ioarray iwork+      liworkPtr <- Call.cint liwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tgsen ijobPtr wantqPtr wantzPtr selectPtr nPtr aPtr ldaPtr bPtr ldbPtr alphaPtr betaPtr qPtr ldqPtr zPtr ldzPtr mPtr plPtr prPtr difPtr workPtr lworkPtr iworkPtr liworkPtr infoPtr+      liftIO $ pure (,,,,,,)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> fmap fromIntegral (peek mPtr)+         <*> peek plPtr+         <*> peek prPtr+         <*> Call.freezeArray dif+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsja.f>+tgsja ::+   Char {- ^ jobu -} ->+   Char {- ^ jobv -} ->+   Char {- ^ jobq -} ->+   Int {- ^ k -} ->+   Int {- ^ l -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   Double {- ^ tola -} ->+   Double {- ^ tolb -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ u -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ v -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   IO (CArray Int Double, CArray Int Double, Int, Int)+tgsja jobu jobv jobq k l a b tola tolb u v q = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   (uDim0,uDim1) <- Call.sizes2 <$> getBounds u+   (vDim0,vDim1) <- Call.sizes2 <$> getBounds v+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   let n = aDim0+   let lda = aDim1+   let ldb = bDim1+   let m = uDim0+   let ldu = uDim1+   let p = vDim0+   let ldv = vDim1+   let ldq = qDim1+   Call.assert "tgsja: n == bDim0" (n == bDim0)+   Call.assert "tgsja: n == qDim0" (n == qDim0)+   alpha <- Call.newArray1 n+   beta <- Call.newArray1 n+   work <- Call.newArray1 (2*n)+   evalContT $ do+      jobuPtr <- Call.char jobu+      jobvPtr <- Call.char jobv+      jobqPtr <- Call.char jobq+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      lPtr <- Call.cint l+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      tolaPtr <- Call.double tola+      tolbPtr <- Call.double tolb+      alphaPtr <- Call.ioarray alpha+      betaPtr <- Call.ioarray beta+      uPtr <- Call.ioarray u+      lduPtr <- Call.cint ldu+      vPtr <- Call.ioarray v+      ldvPtr <- Call.cint ldv+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      workPtr <- Call.ioarray work+      ncyclePtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.tgsja jobuPtr jobvPtr jobqPtr mPtr pPtr nPtr kPtr lPtr aPtr ldaPtr bPtr ldbPtr tolaPtr tolbPtr alphaPtr betaPtr uPtr lduPtr vPtr ldvPtr qPtr ldqPtr workPtr ncyclePtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray alpha+         <*> Call.freezeArray beta+         <*> fmap fromIntegral (peek ncyclePtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsna.f>+tgsna ::+   Char {- ^ job -} ->+   Char {- ^ howmny -} ->+   CArray Int Bool {- ^ select -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   CArray (Int,Int) (Complex Double) {- ^ vl -} ->+   CArray (Int,Int) (Complex Double) {- ^ vr -} ->+   Int {- ^ mm -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, CArray Int Double, Int, Int)+tgsna job howmny select a b vl vr mm lwork = do+   let selectDim0 = Call.sizes1 $ bounds select+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let (vlDim0,vlDim1) = Call.sizes2 $ bounds vl+   let (vrDim0,vrDim1) = Call.sizes2 $ bounds vr+   let n = selectDim0+   let lda = aDim1+   let ldb = bDim1+   let m = vlDim0+   let ldvl = vlDim1+   let ldvr = vrDim1+   Call.assert "tgsna: n == aDim0" (n == aDim0)+   Call.assert "tgsna: n == bDim0" (n == bDim0)+   Call.assert "tgsna: m == vrDim0" (m == vrDim0)+   s <- Call.newArray1 mm+   dif <- Call.newArray1 mm+   work <- Call.newArray1 (maximum[1,lwork])+   iwork <- Call.newArray1 (n+2)+   evalContT $ do+      jobPtr <- Call.char job+      howmnyPtr <- Call.char howmny+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      vlPtr <- Call.array vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.array vr+      ldvrPtr <- Call.cint ldvr+      sPtr <- Call.ioarray s+      difPtr <- Call.ioarray dif+      mmPtr <- Call.cint mm+      mPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tgsna jobPtr howmnyPtr selectPtr nPtr aPtr ldaPtr bPtr ldbPtr vlPtr ldvlPtr vrPtr ldvrPtr sPtr difPtr mmPtr mPtr workPtr lworkPtr iworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> Call.freezeArray dif+         <*> fmap fromIntegral (peek mPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsy2.f>+tgsy2 ::+   Char {- ^ trans -} ->+   Int {- ^ ijob -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   CArray (Int,Int) (Complex Double) {- ^ d -} ->+   CArray (Int,Int) (Complex Double) {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->+   Double {- ^ rdsum -} ->+   Double {- ^ rdscal -} ->+   IO (Double, Double, Double, Int)+tgsy2 trans ijob a b c d e f rdsum rdscal = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let (dDim0,dDim1) = Call.sizes2 $ bounds d+   let (eDim0,eDim1) = Call.sizes2 $ bounds e+   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f+   let m = aDim0+   let lda = aDim1+   let n = bDim0+   let ldb = bDim1+   let ldc = cDim1+   let ldd = dDim1+   let lde = eDim1+   let ldf = fDim1+   Call.assert "tgsy2: n == cDim0" (n == cDim0)+   Call.assert "tgsy2: m == dDim0" (m == dDim0)+   Call.assert "tgsy2: n == eDim0" (n == eDim0)+   Call.assert "tgsy2: n == fDim0" (n == fDim0)+   evalContT $ do+      transPtr <- Call.char trans+      ijobPtr <- Call.cint ijob+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      dPtr <- Call.array d+      lddPtr <- Call.cint ldd+      ePtr <- Call.array e+      ldePtr <- Call.cint lde+      fPtr <- Call.ioarray f+      ldfPtr <- Call.cint ldf+      scalePtr <- Call.alloca+      rdsumPtr <- Call.double rdsum+      rdscalPtr <- Call.double rdscal+      infoPtr <- Call.alloca+      liftIO $ FFI.tgsy2 transPtr ijobPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr dPtr lddPtr ePtr ldePtr fPtr ldfPtr scalePtr rdsumPtr rdscalPtr infoPtr+      liftIO $ pure (,,,)+         <*> peek scalePtr+         <*> peek rdsumPtr+         <*> peek rdscalPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztgsyl.f>+tgsyl ::+   Char {- ^ trans -} ->+   Int {- ^ ijob -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   CArray (Int,Int) (Complex Double) {- ^ d -} ->+   CArray (Int,Int) (Complex Double) {- ^ e -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ f -} ->+   Int {- ^ lwork -} ->+   IO (Double, Double, Int)+tgsyl trans ijob a b c d e f lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let (dDim0,dDim1) = Call.sizes2 $ bounds d+   let (eDim0,eDim1) = Call.sizes2 $ bounds e+   (fDim0,fDim1) <- Call.sizes2 <$> getBounds f+   let m = aDim0+   let lda = aDim1+   let n = bDim0+   let ldb = bDim1+   let ldc = cDim1+   let ldd = dDim1+   let lde = eDim1+   let ldf = fDim1+   Call.assert "tgsyl: n == cDim0" (n == cDim0)+   Call.assert "tgsyl: m == dDim0" (m == dDim0)+   Call.assert "tgsyl: n == eDim0" (n == eDim0)+   Call.assert "tgsyl: n == fDim0" (n == fDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   iwork <- Call.newArray1 (m+n+2)+   evalContT $ do+      transPtr <- Call.char trans+      ijobPtr <- Call.cint ijob+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      dPtr <- Call.array d+      lddPtr <- Call.cint ldd+      ePtr <- Call.array e+      ldePtr <- Call.cint lde+      fPtr <- Call.ioarray f+      ldfPtr <- Call.cint ldf+      scalePtr <- Call.alloca+      difPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tgsyl transPtr ijobPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr dPtr lddPtr ePtr ldePtr fPtr ldfPtr scalePtr difPtr workPtr lworkPtr iworkPtr infoPtr+      liftIO $ pure (,,)+         <*> peek scalePtr+         <*> peek difPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpcon.f>+tpcon ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IO (Double, Int)+tpcon norm uplo diag n ap = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "tpcon: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tpcon normPtr uploPtr diagPtr nPtr apPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztprfs.f>+tprfs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   CArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+tprfs uplo trans diag n ap b x = do+   let apDim0 = Call.sizes1 $ bounds ap+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let (xDim0,xDim1) = Call.sizes2 $ bounds x+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "tprfs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "tprfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.array x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tprfs uploPtr transPtr diagPtr nPtr nrhsPtr apPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztptri.f>+tptri ::+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   IOCArray Int (Complex Double) {- ^ ap -} ->+   IO (Int)+tptri uplo diag n ap = do+   apDim0 <- Call.sizes1 <$> getBounds ap+   Call.assert "tptri: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      apPtr <- Call.ioarray ap+      infoPtr <- Call.alloca+      liftIO $ FFI.tptri uploPtr diagPtr nPtr apPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztptrs.f>+tptrs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+tptrs uplo trans diag n ap b = do+   let apDim0 = Call.sizes1 $ bounds ap+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let nrhs = bDim0+   let ldb = bDim1+   Call.assert "tptrs: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      apPtr <- Call.array ap+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.tptrs uploPtr transPtr diagPtr nPtr nrhsPtr apPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpttf.f>+tpttf ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   IO (CArray Int (Complex Double), Int)+tpttf transr uplo n ap = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "tpttf: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   arf <- Call.newArray1 (n*(n+1)`div`2)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      arfPtr <- Call.ioarray arf+      infoPtr <- Call.alloca+      liftIO $ FFI.tpttf transrPtr uploPtr nPtr apPtr arfPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray arf+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztpttr.f>+tpttr ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   Int {- ^ lda -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+tpttr uplo n ap lda = do+   let apDim0 = Call.sizes1 $ bounds ap+   Call.assert "tpttr: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   a <- Call.newArray2 n lda+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.tpttr uploPtr nPtr apPtr aPtr ldaPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray a+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrcon.f>+trcon ::+   Char {- ^ norm -} ->+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Double, Int)+trcon norm uplo diag a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      normPtr <- Call.char norm+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      rcondPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.trcon normPtr uploPtr diagPtr nPtr aPtr ldaPtr rcondPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> peek rcondPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrevc.f>+trevc ::+   Char {- ^ side -} ->+   Char {- ^ howmny -} ->+   CArray Int Bool {- ^ select -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vl -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ vr -} ->+   IO (Int, Int)+trevc side howmny select t vl vr = do+   let selectDim0 = Call.sizes1 $ bounds select+   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t+   (vlDim0,vlDim1) <- Call.sizes2 <$> getBounds vl+   (vrDim0,vrDim1) <- Call.sizes2 <$> getBounds vr+   let n = selectDim0+   let ldt = tDim1+   let mm = vlDim0+   let ldvl = vlDim1+   let ldvr = vrDim1+   Call.assert "trevc: n == tDim0" (n == tDim0)+   Call.assert "trevc: mm == vrDim0" (mm == vrDim0)+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      sidePtr <- Call.char side+      howmnyPtr <- Call.char howmny+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      vlPtr <- Call.ioarray vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.ioarray vr+      ldvrPtr <- Call.cint ldvr+      mmPtr <- Call.cint mm+      mPtr <- Call.alloca+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.trevc sidePtr howmnyPtr selectPtr nPtr tPtr ldtPtr vlPtr ldvlPtr vrPtr ldvrPtr mmPtr mPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,)+         <*> fmap fromIntegral (peek mPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrexc.f>+trexc ::+   Char {- ^ compq -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   Int {- ^ ifst -} ->+   Int {- ^ ilst -} ->+   IO (Int)+trexc compq t q ifst ilst = do+   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   let n = tDim0+   let ldt = tDim1+   let ldq = qDim1+   Call.assert "trexc: n == qDim0" (n == qDim0)+   evalContT $ do+      compqPtr <- Call.char compq+      nPtr <- Call.cint n+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      ifstPtr <- Call.cint ifst+      ilstPtr <- Call.cint ilst+      infoPtr <- Call.alloca+      liftIO $ FFI.trexc compqPtr nPtr tPtr ldtPtr qPtr ldqPtr ifstPtr ilstPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrrfs.f>+trrfs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   CArray (Int,Int) (Complex Double) {- ^ x -} ->+   IO (CArray Int Double, CArray Int Double, Int)+trrfs uplo trans diag a b x = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   let (xDim0,xDim1) = Call.sizes2 $ bounds x+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   let ldx = xDim1+   Call.assert "trrfs: nrhs == xDim0" (nrhs == xDim0)+   ferr <- Call.newArray1 nrhs+   berr <- Call.newArray1 nrhs+   work <- Call.newArray1 (2*n)+   rwork <- Call.newArray1 n+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      xPtr <- Call.array x+      ldxPtr <- Call.cint ldx+      ferrPtr <- Call.ioarray ferr+      berrPtr <- Call.ioarray berr+      workPtr <- Call.ioarray work+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.trrfs uploPtr transPtr diagPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr xPtr ldxPtr ferrPtr berrPtr workPtr rworkPtr infoPtr+      liftIO $ pure (,,)+         <*> Call.freezeArray ferr+         <*> Call.freezeArray berr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsen.f>+trsen ::+   Char {- ^ job -} ->+   Char {- ^ compq -} ->+   CArray Int Bool {- ^ select -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ t -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ q -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int, Double, Double, Int)+trsen job compq select t q lwork = do+   let selectDim0 = Call.sizes1 $ bounds select+   (tDim0,tDim1) <- Call.sizes2 <$> getBounds t+   (qDim0,qDim1) <- Call.sizes2 <$> getBounds q+   let n = selectDim0+   let ldt = tDim1+   let ldq = qDim1+   Call.assert "trsen: n == tDim0" (n == tDim0)+   Call.assert "trsen: n == qDim0" (n == qDim0)+   w <- Call.newArray1 n+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      jobPtr <- Call.char job+      compqPtr <- Call.char compq+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      tPtr <- Call.ioarray t+      ldtPtr <- Call.cint ldt+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      wPtr <- Call.ioarray w+      mPtr <- Call.alloca+      sPtr <- Call.alloca+      sepPtr <- Call.alloca+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.trsen jobPtr compqPtr selectPtr nPtr tPtr ldtPtr qPtr ldqPtr wPtr mPtr sPtr sepPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,,,,)+         <*> Call.freezeArray w+         <*> fmap fromIntegral (peek mPtr)+         <*> peek sPtr+         <*> peek sepPtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsna.f>+trsna ::+   Char {- ^ job -} ->+   Char {- ^ howmny -} ->+   CArray Int Bool {- ^ select -} ->+   CArray (Int,Int) (Complex Double) {- ^ t -} ->+   CArray (Int,Int) (Complex Double) {- ^ vl -} ->+   CArray (Int,Int) (Complex Double) {- ^ vr -} ->+   Int {- ^ mm -} ->+   Int {- ^ ldwork -} ->+   IO (CArray Int Double, CArray Int Double, Int, Int)+trsna job howmny select t vl vr mm ldwork = do+   let selectDim0 = Call.sizes1 $ bounds select+   let (tDim0,tDim1) = Call.sizes2 $ bounds t+   let (vlDim0,vlDim1) = Call.sizes2 $ bounds vl+   let (vrDim0,vrDim1) = Call.sizes2 $ bounds vr+   let n = selectDim0+   let ldt = tDim1+   let m = vlDim0+   let ldvl = vlDim1+   let ldvr = vrDim1+   Call.assert "trsna: n == tDim0" (n == tDim0)+   Call.assert "trsna: m == vrDim0" (m == vrDim0)+   s <- Call.newArray1 mm+   sep <- Call.newArray1 mm+   work <- Call.newArray2 (n+6) ldwork+   rwork <- Call.newArray1 n+   evalContT $ do+      jobPtr <- Call.char job+      howmnyPtr <- Call.char howmny+      selectPtr <- Call.array select+      nPtr <- Call.cint n+      tPtr <- Call.array t+      ldtPtr <- Call.cint ldt+      vlPtr <- Call.array vl+      ldvlPtr <- Call.cint ldvl+      vrPtr <- Call.array vr+      ldvrPtr <- Call.cint ldvr+      sPtr <- Call.ioarray s+      sepPtr <- Call.ioarray sep+      mmPtr <- Call.cint mm+      mPtr <- Call.alloca+      workPtr <- Call.ioarray work+      ldworkPtr <- Call.cint ldwork+      rworkPtr <- Call.ioarray rwork+      infoPtr <- Call.alloca+      liftIO $ FFI.trsna jobPtr howmnyPtr selectPtr nPtr tPtr ldtPtr vlPtr ldvlPtr vrPtr ldvrPtr sPtr sepPtr mmPtr mPtr workPtr ldworkPtr rworkPtr infoPtr+      liftIO $ pure (,,,)+         <*> Call.freezeArray s+         <*> Call.freezeArray sep+         <*> fmap fromIntegral (peek mPtr)+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrsyl.f>+trsyl ::+   Char {- ^ trana -} ->+   Char {- ^ tranb -} ->+   Int {- ^ isgn -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray (Int,Int) (Complex Double) {- ^ b -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   IO (Double, Int)+trsyl trana tranb isgn a b c = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let (bDim0,bDim1) = Call.sizes2 $ bounds b+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let m = aDim0+   let lda = aDim1+   let n = bDim0+   let ldb = bDim1+   let ldc = cDim1+   Call.assert "trsyl: n == cDim0" (n == cDim0)+   evalContT $ do+      tranaPtr <- Call.char trana+      tranbPtr <- Call.char tranb+      isgnPtr <- Call.cint isgn+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.array b+      ldbPtr <- Call.cint ldb+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      scalePtr <- Call.alloca+      infoPtr <- Call.alloca+      liftIO $ FFI.trsyl tranaPtr tranbPtr isgnPtr mPtr nPtr aPtr ldaPtr bPtr ldbPtr cPtr ldcPtr scalePtr infoPtr+      liftIO $ pure (,)+         <*> peek scalePtr+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrti2.f>+trti2 ::+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+trti2 uplo diag a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.trti2 uploPtr diagPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrtri.f>+trtri ::+   Char {- ^ uplo -} ->+   Char {- ^ diag -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (Int)+trtri uplo diag a = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      infoPtr <- Call.alloca+      liftIO $ FFI.trtri uploPtr diagPtr nPtr aPtr ldaPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrtrs.f>+trtrs ::+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Char {- ^ diag -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ b -} ->+   IO (Int)+trtrs uplo trans diag a b = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   (bDim0,bDim1) <- Call.sizes2 <$> getBounds b+   let n = aDim0+   let lda = aDim1+   let nrhs = bDim0+   let ldb = bDim1+   evalContT $ do+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      diagPtr <- Call.char diag+      nPtr <- Call.cint n+      nrhsPtr <- Call.cint nrhs+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      bPtr <- Call.ioarray b+      ldbPtr <- Call.cint ldb+      infoPtr <- Call.alloca+      liftIO $ FFI.trtrs uploPtr transPtr diagPtr nPtr nrhsPtr aPtr ldaPtr bPtr ldbPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrttf.f>+trttf ::+   Char {- ^ transr -} ->+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+trttf transr uplo a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   arf <- Call.newArray1 (n*(n+1)`div`2)+   evalContT $ do+      transrPtr <- Call.char transr+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      arfPtr <- Call.ioarray arf+      infoPtr <- Call.alloca+      liftIO $ FFI.trttf transrPtr uploPtr nPtr aPtr ldaPtr arfPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray arf+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztrttp.f>+trttp ::+   Char {- ^ uplo -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   IO (CArray Int (Complex Double), Int)+trttp uplo a = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let n = aDim0+   let lda = aDim1+   ap <- Call.newArray1 (n*(n+1)`div`2)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      apPtr <- Call.ioarray ap+      infoPtr <- Call.alloca+      liftIO $ FFI.trttp uploPtr nPtr aPtr ldaPtr apPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray ap+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/ztzrzf.f>+tzrzf ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int (Complex Double), Int)+tzrzf m a lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let n = aDim0+   let lda = aDim1+   tau <- Call.newArray1 m+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.ioarray tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.tzrzf mPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray tau+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunbdb.f>+unbdb ::+   Char {- ^ trans -} ->+   Char {- ^ signs -} ->+   Int {- ^ m -} ->+   Int {- ^ p -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x11 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x12 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x21 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x22 -} ->+   Int {- ^ lwork -} ->+   IO (CArray Int Double, CArray Int Double, CArray Int (Complex Double), CArray Int (Complex Double), CArray Int (Complex Double), CArray Int (Complex Double), Int)+unbdb trans signs m p x11 x12 x21 x22 lwork = do+   (x11Dim0,x11Dim1) <- Call.sizes2 <$> getBounds x11+   (x12Dim0,x12Dim1) <- Call.sizes2 <$> getBounds x12+   (x21Dim0,x21Dim1) <- Call.sizes2 <$> getBounds x21+   (x22Dim0,x22Dim1) <- Call.sizes2 <$> getBounds x22+   let q = x11Dim0+   let ldx11 = x11Dim1+   let ldx12 = x12Dim1+   let ldx21 = x21Dim1+   let ldx22 = x22Dim1+   Call.assert "unbdb: m-q == x12Dim0" (m-q == x12Dim0)+   Call.assert "unbdb: q == x21Dim0" (q == x21Dim0)+   Call.assert "unbdb: m-q == x22Dim0" (m-q == x22Dim0)+   theta <- Call.newArray1 q+   phi <- Call.newArray1 (q-1)+   taup1 <- Call.newArray1 p+   taup2 <- Call.newArray1 (m-p)+   tauq1 <- Call.newArray1 q+   tauq2 <- Call.newArray1 (m-q)+   work <- Call.newArray1 lwork+   evalContT $ do+      transPtr <- Call.char trans+      signsPtr <- Call.char signs+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      qPtr <- Call.cint q+      x11Ptr <- Call.ioarray x11+      ldx11Ptr <- Call.cint ldx11+      x12Ptr <- Call.ioarray x12+      ldx12Ptr <- Call.cint ldx12+      x21Ptr <- Call.ioarray x21+      ldx21Ptr <- Call.cint ldx21+      x22Ptr <- Call.ioarray x22+      ldx22Ptr <- Call.cint ldx22+      thetaPtr <- Call.ioarray theta+      phiPtr <- Call.ioarray phi+      taup1Ptr <- Call.ioarray taup1+      taup2Ptr <- Call.ioarray taup2+      tauq1Ptr <- Call.ioarray tauq1+      tauq2Ptr <- Call.ioarray tauq2+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unbdb transPtr signsPtr mPtr pPtr qPtr x11Ptr ldx11Ptr x12Ptr ldx12Ptr x21Ptr ldx21Ptr x22Ptr ldx22Ptr thetaPtr phiPtr taup1Ptr taup2Ptr tauq1Ptr tauq2Ptr workPtr lworkPtr infoPtr+      liftIO $ pure (,,,,,,)+         <*> Call.freezeArray theta+         <*> Call.freezeArray phi+         <*> Call.freezeArray taup1+         <*> Call.freezeArray taup2+         <*> Call.freezeArray tauq1+         <*> Call.freezeArray tauq2+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zuncsd.f>+uncsd ::+   Char {- ^ jobu1 -} ->+   Char {- ^ jobu2 -} ->+   Char {- ^ jobv1t -} ->+   Char {- ^ jobv2t -} ->+   Char {- ^ trans -} ->+   Char {- ^ signs -} ->+   Int {- ^ m -} ->+   Int {- ^ p -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x11 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x12 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x21 -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ x22 -} ->+   Int {- ^ r -} ->+   Int {- ^ ldu1 -} ->+   Int {- ^ ldu2 -} ->+   Int {- ^ ldv1t -} ->+   Int {- ^ ldv2t -} ->+   Int {- ^ lwork -} ->+   Int {- ^ rworkSize -} ->+   Int {- ^ lrwork -} ->+   IO (CArray Int Double, CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), CArray (Int,Int) (Complex Double), Int)+uncsd jobu1 jobu2 jobv1t jobv2t trans signs m p x11 x12 x21 x22 r ldu1 ldu2 ldv1t ldv2t lwork rworkSize lrwork = do+   (x11Dim0,x11Dim1) <- Call.sizes2 <$> getBounds x11+   (x12Dim0,x12Dim1) <- Call.sizes2 <$> getBounds x12+   (x21Dim0,x21Dim1) <- Call.sizes2 <$> getBounds x21+   (x22Dim0,x22Dim1) <- Call.sizes2 <$> getBounds x22+   let q = x11Dim0+   let ldx11 = x11Dim1+   let ldx12 = x12Dim1+   let ldx21 = x21Dim1+   let ldx22 = x22Dim1+   Call.assert "uncsd: m-q == x12Dim0" (m-q == x12Dim0)+   Call.assert "uncsd: q == x21Dim0" (q == x21Dim0)+   Call.assert "uncsd: m-q == x22Dim0" (m-q == x22Dim0)+   theta <- Call.newArray1 r+   u1 <- Call.newArray2 p ldu1+   u2 <- Call.newArray2 (m-p) ldu2+   v1t <- Call.newArray2 q ldv1t+   v2t <- Call.newArray2 (m-q) ldv2t+   work <- Call.newArray1 (maximum[1,lwork])+   rwork <- Call.newArray1 rworkSize+   iwork <- Call.newArray1 (m-minimum[p,m-p,q,m-q])+   evalContT $ do+      jobu1Ptr <- Call.char jobu1+      jobu2Ptr <- Call.char jobu2+      jobv1tPtr <- Call.char jobv1t+      jobv2tPtr <- Call.char jobv2t+      transPtr <- Call.char trans+      signsPtr <- Call.char signs+      mPtr <- Call.cint m+      pPtr <- Call.cint p+      qPtr <- Call.cint q+      x11Ptr <- Call.ioarray x11+      ldx11Ptr <- Call.cint ldx11+      x12Ptr <- Call.ioarray x12+      ldx12Ptr <- Call.cint ldx12+      x21Ptr <- Call.ioarray x21+      ldx21Ptr <- Call.cint ldx21+      x22Ptr <- Call.ioarray x22+      ldx22Ptr <- Call.cint ldx22+      thetaPtr <- Call.ioarray theta+      u1Ptr <- Call.ioarray u1+      ldu1Ptr <- Call.cint ldu1+      u2Ptr <- Call.ioarray u2+      ldu2Ptr <- Call.cint ldu2+      v1tPtr <- Call.ioarray v1t+      ldv1tPtr <- Call.cint ldv1t+      v2tPtr <- Call.ioarray v2t+      ldv2tPtr <- Call.cint ldv2t+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      rworkPtr <- Call.ioarray rwork+      lrworkPtr <- Call.cint lrwork+      iworkPtr <- Call.ioarray iwork+      infoPtr <- Call.alloca+      liftIO $ FFI.uncsd jobu1Ptr jobu2Ptr jobv1tPtr jobv2tPtr transPtr signsPtr mPtr pPtr qPtr x11Ptr ldx11Ptr x12Ptr ldx12Ptr x21Ptr ldx21Ptr x22Ptr ldx22Ptr thetaPtr u1Ptr ldu1Ptr u2Ptr ldu2Ptr v1tPtr ldv1tPtr v2tPtr ldv2tPtr workPtr lworkPtr rworkPtr lrworkPtr iworkPtr infoPtr+      liftIO $ pure (,,,,,)+         <*> Call.freezeArray theta+         <*> Call.freezeArray u1+         <*> Call.freezeArray u2+         <*> Call.freezeArray v1t+         <*> Call.freezeArray v2t+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zung2l.f>+ung2l ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IO (Int)+ung2l m a tau = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.ung2l mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zung2r.f>+ung2r ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IO (Int)+ung2r m a tau = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 n+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.ung2r mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungbr.f>+ungbr ::+   Char {- ^ vect -} ->+   Int {- ^ m -} ->+   Int {- ^ k -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+ungbr vect m k a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let _tauSize = tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      vectPtr <- Call.char vect+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ungbr vectPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunghr.f>+unghr ::+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unghr ilo ihi a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   Call.assert "unghr: n-1 == tauDim0" (n-1 == tauDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unghr nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungl2.f>+ungl2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IO (Int)+ungl2 m a tau = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 m+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.ungl2 mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunglq.f>+unglq ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unglq m a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unglq mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungql.f>+ungql ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+ungql m a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ungql mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungqr.f>+ungqr ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+ungqr m a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ungqr mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungr2.f>+ungr2 ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IO (Int)+ungr2 m a tau = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 m+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.ungr2 mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungrq.f>+ungrq ::+   Int {- ^ m -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+ungrq m a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   let k = tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ungrq mPtr nPtr kPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zungtr.f>+ungtr ::+   Char {- ^ uplo -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ lwork -} ->+   IO (Int)+ungtr uplo a tau lwork = do+   (aDim0,aDim1) <- Call.sizes2 <$> getBounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   let n = aDim0+   let lda = aDim1+   Call.assert "ungtr: n-1 == tauDim0" (n-1 == tauDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      aPtr <- Call.ioarray a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.ungtr uploPtr nPtr aPtr ldaPtr tauPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunm2l.f>+unm2l ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+unm2l side trans m a tau c workSize = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let k = aDim0+   let lda = aDim1+   let n = cDim0+   let ldc = cDim1+   Call.assert "unm2l: k == tauDim0" (k == tauDim0)+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.unm2l sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunm2r.f>+unm2r ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+unm2r side trans m a tau c workSize = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let k = aDim0+   let lda = aDim1+   let n = cDim0+   let ldc = cDim1+   Call.assert "unm2r: k == tauDim0" (k == tauDim0)+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.unm2r sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmbr.f>+unmbr ::+   Char {- ^ vect -} ->+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   Int {- ^ k -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmbr vect side trans m k a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let n = cDim0+   let ldc = cDim1+   Call.ignore "unmbr: minimum[nq,k] == tauDim0" tauDim0+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      vectPtr <- Call.char vect+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmbr vectPtr sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmhr.f>+unmhr ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   Int {- ^ ilo -} ->+   Int {- ^ ihi -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmhr side trans m ilo ihi a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let _tauSize = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      iloPtr <- Call.cint ilo+      ihiPtr <- Call.cint ihi+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmhr sidePtr transPtr mPtr nPtr iloPtr ihiPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunml2.f>+unml2 ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+unml2 side trans m a tau c workSize = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.unml2 sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmlq.f>+unmlq ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmlq side trans m a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmlq sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmql.f>+unmql ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmql side trans m a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let k = aDim0+   let lda = aDim1+   let n = cDim0+   let ldc = cDim1+   Call.assert "unmql: k == tauDim0" (k == tauDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmql sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmqr.f>+unmqr ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmqr side trans m a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let k = aDim0+   let lda = aDim1+   let n = cDim0+   let ldc = cDim1+   Call.assert "unmqr: k == tauDim0" (k == tauDim0)+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmqr sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmr2.f>+unmr2 ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+unmr2 side trans m a tau c workSize = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.unmr2 sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmr3.f>+unmr3 ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   Int {- ^ l -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+unmr3 side trans m l a tau c workSize = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      lPtr <- Call.cint l+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.unmr3 sidePtr transPtr mPtr nPtr kPtr lPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmrq.f>+unmrq ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmrq side trans m a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmrq sidePtr transPtr mPtr nPtr kPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmrz.f>+unmrz ::+   Char {- ^ side -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   Int {- ^ l -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmrz side trans m l a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let k = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      kPtr <- Call.cint k+      lPtr <- Call.cint l+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmrz sidePtr transPtr mPtr nPtr kPtr lPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zunmtr.f>+unmtr ::+   Char {- ^ side -} ->+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray (Int,Int) (Complex Double) {- ^ a -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ lwork -} ->+   IO (Int)+unmtr side uplo trans m a tau c lwork = do+   let (aDim0,aDim1) = Call.sizes2 $ bounds a+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _aSize = aDim0+   let lda = aDim1+   let _tauSize = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 (maximum[1,lwork])+   evalContT $ do+      sidePtr <- Call.char side+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      aPtr <- Call.array a+      ldaPtr <- Call.cint lda+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work+      lworkPtr <- Call.cint lwork+      infoPtr <- Call.alloca+      liftIO $ FFI.unmtr sidePtr uploPtr transPtr mPtr nPtr aPtr ldaPtr tauPtr cPtr ldcPtr workPtr lworkPtr infoPtr+      liftIO $ fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zupgtr.f>+upgtr ::+   Char {- ^ uplo -} ->+   Int {- ^ n -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   Int {- ^ ldq -} ->+   IO (CArray (Int,Int) (Complex Double), Int)+upgtr uplo n ap tau ldq = do+   let apDim0 = Call.sizes1 $ bounds ap+   let tauDim0 = Call.sizes1 $ bounds tau+   Call.assert "upgtr: n*(n+1)`div`2 == apDim0" (n*(n+1)`div`2 == apDim0)+   Call.assert "upgtr: n-1 == tauDim0" (n-1 == tauDim0)+   q <- Call.newArray2 n ldq+   work <- Call.newArray1 (n-1)+   evalContT $ do+      uploPtr <- Call.char uplo+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      tauPtr <- Call.array tau+      qPtr <- Call.ioarray q+      ldqPtr <- Call.cint ldq+      workPtr <- Call.ioarray work+      infoPtr <- Call.alloca+      liftIO $ FFI.upgtr uploPtr nPtr apPtr tauPtr qPtr ldqPtr workPtr infoPtr+      liftIO $ pure (,)+         <*> Call.freezeArray q+         <*> fmap fromIntegral (peek infoPtr)++-- | <http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zupmtr.f>+upmtr ::+   Char {- ^ side -} ->+   Char {- ^ uplo -} ->+   Char {- ^ trans -} ->+   Int {- ^ m -} ->+   CArray Int (Complex Double) {- ^ ap -} ->+   CArray Int (Complex Double) {- ^ tau -} ->+   IOCArray (Int,Int) (Complex Double) {- ^ c -} ->+   Int {- ^ workSize -} ->+   IO (Int)+upmtr side uplo trans m ap tau c workSize = do+   let apDim0 = Call.sizes1 $ bounds ap+   let tauDim0 = Call.sizes1 $ bounds tau+   (cDim0,cDim1) <- Call.sizes2 <$> getBounds c+   let _apSize = apDim0+   let _tauSize = tauDim0+   let n = cDim0+   let ldc = cDim1+   work <- Call.newArray1 workSize+   evalContT $ do+      sidePtr <- Call.char side+      uploPtr <- Call.char uplo+      transPtr <- Call.char trans+      mPtr <- Call.cint m+      nPtr <- Call.cint n+      apPtr <- Call.array ap+      tauPtr <- Call.array tau+      cPtr <- Call.ioarray c+      ldcPtr <- Call.cint ldc+      workPtr <- Call.ioarray work       infoPtr <- Call.alloca       liftIO $ FFI.upmtr sidePtr uploPtr transPtr mPtr nPtr apPtr tauPtr cPtr ldcPtr workPtr infoPtr       liftIO $ fmap fromIntegral (peek infoPtr)