-- Do not edit! Automatically generated by create-lapack-ffi.
module Numeric.LAPACK.FFI.Complex (
   bbcsd,
   bdsqr,
   gbbrd,
   gbcon,
   gbequ,
   gbequb,
   gbrfs,
   gbsv,
   gbsvx,
   gbtf2,
   gbtrf,
   gbtrs,
   gebak,
   gebal,
   gebd2,
   gebrd,
   gecon,
   geequ,
   geequb,
   gees,
   geesx,
   geev,
   geevx,
   gehd2,
   gehrd,
   gelq2,
   gelqf,
   gels,
   gelsd,
   gelss,
   gelsy,
   geql2,
   geqlf,
   geqp3,
   geqr2,
   geqr2p,
   geqrf,
   geqrfp,
   gerfs,
   gerq2,
   gerqf,
   gesc2,
   gesdd,
   gesv,
   gesvd,
   gesvx,
   getc2,
   getf2,
   getrf,
   getri,
   getrs,
   ggbak,
   ggbal,
   gges,
   ggesx,
   ggev,
   ggevx,
   ggglm,
   gghrd,
   gglse,
   ggqrf,
   ggrqf,
   gtcon,
   gtrfs,
   gtsv,
   gtsvx,
   gttrf,
   gttrs,
   gtts2,
   hbev,
   hbevd,
   hbevx,
   hbgst,
   hbgv,
   hbgvd,
   hbgvx,
   hbtrd,
   hecon,
   heequb,
   heev,
   heevd,
   heevr,
   heevx,
   hegs2,
   hegst,
   hegv,
   hegvd,
   hegvx,
   herfs,
   hesv,
   hesvx,
   heswapr,
   hetd2,
   hetf2,
   hetrd,
   hetrf,
   hetri,
   hetri2,
   hetri2x,
   hetrs,
   hetrs2,
   hfrk,
   hgeqz,
   hpcon,
   hpev,
   hpevd,
   hpevx,
   hpgst,
   hpgv,
   hpgvd,
   hpgvx,
   hprfs,
   hpsv,
   hpsvx,
   hptrd,
   hptrf,
   hptri,
   hptrs,
   hsein,
   hseqr,
   ilalc,
   ilalr,
   imax1,
   labrd,
   lacgv,
   lacn2,
   lacon,
   lacp2,
   lacpy,
   lacrm,
   lacrt,
   laed0,
   laed7,
   laed8,
   laein,
   laesy,
   laev2,
   lags2,
   lagtm,
   lahef,
   lahqr,
   lahr2,
   laic1,
   lals0,
   lalsa,
   lalsd,
   langb,
   lange,
   langt,
   lanhb,
   lanhe,
   lanhf,
   lanhp,
   lanhs,
   lanht,
   lansb,
   lansp,
   lansy,
   lantb,
   lantp,
   lantr,
   lapll,
   lapmr,
   lapmt,
   laqgb,
   laqge,
   laqhb,
   laqhe,
   laqhp,
   laqp2,
   laqps,
   laqr0,
   laqr1,
   laqr2,
   laqr3,
   laqr4,
   laqr5,
   laqsb,
   laqsp,
   laqsy,
   lar1v,
   lar2v,
   larcm,
   larf,
   larfb,
   larfg,
   larfgp,
   larft,
   larfx,
   largv,
   larnv,
   larrv,
   lartg,
   lartv,
   larz,
   larzb,
   larzt,
   lascl,
   laset,
   lasr,
   lassq,
   laswp,
   lasyf,
   latbs,
   latdf,
   latps,
   latrd,
   latrs,
   latrz,
   lauu2,
   lauum,
   pbcon,
   pbequ,
   pbrfs,
   pbstf,
   pbsv,
   pbsvx,
   pbtf2,
   pbtrf,
   pbtrs,
   pftrf,
   pftri,
   pftrs,
   pocon,
   poequ,
   poequb,
   porfs,
   posv,
   posvx,
   potf2,
   potrf,
   potri,
   potrs,
   ppcon,
   ppequ,
   pprfs,
   ppsv,
   ppsvx,
   pptrf,
   pptri,
   pptrs,
   pstf2,
   pstrf,
   ptcon,
   pteqr,
   ptrfs,
   ptsv,
   ptsvx,
   pttrf,
   pttrs,
   ptts2,
   rot,
   rscl,
   spcon,
   spmv,
   spr,
   sprfs,
   spsv,
   spsvx,
   sptrf,
   sptri,
   sptrs,
   stedc,
   stegr,
   stein,
   stemr,
   steqr,
   sum1,
   sycon,
   syconv,
   syequb,
   symv,
   syr,
   syrfs,
   sysv,
   sysvx,
   syswapr,
   sytf2,
   sytrf,
   sytri,
   sytri2,
   sytri2x,
   sytrs,
   sytrs2,
   tbcon,
   tbrfs,
   tbtrs,
   tfsm,
   tftri,
   tfttp,
   tfttr,
   tgevc,
   tgex2,
   tgexc,
   tgsen,
   tgsja,
   tgsna,
   tgsy2,
   tgsyl,
   tpcon,
   tprfs,
   tptri,
   tptrs,
   tpttf,
   tpttr,
   trcon,
   trevc,
   trexc,
   trrfs,
   trsen,
   trsna,
   trsyl,
   trti2,
   trtri,
   trtrs,
   trttf,
   trttp,
   tzrzf,
   unbdb,
   uncsd,
   ung2l,
   ung2r,
   ungbr,
   unghr,
   ungl2,
   unglq,
   ungql,
   ungqr,
   ungr2,
   ungrq,
   ungtr,
   unm2l,
   unm2r,
   unmbr,
   unmhr,
   unml2,
   unmlq,
   unmql,
   unmqr,
   unmr2,
   unmr3,
   unmrq,
   unmrz,
   unmtr,
   upgtr,
   upmtr,
   ) where

import qualified Numeric.LAPACK.FFI.ComplexFloat as C
import qualified Numeric.LAPACK.FFI.ComplexDouble as Z

import qualified Numeric.Netlib.Class as Class

import Data.Complex (Complex)
import Foreign.Ptr (FunPtr, Ptr)
import Foreign.C.Types



newtype BBCSD a = BBCSD {getBBCSD :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

bbcsd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
bbcsd = getBBCSD $ Class.switchReal (BBCSD C.bbcsd) (BBCSD Z.bbcsd)


newtype BDSQR a = BDSQR {getBDSQR :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

bdsqr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
bdsqr = getBDSQR $ Class.switchReal (BDSQR C.bdsqr) (BDSQR Z.bdsqr)


newtype GBBRD a = GBBRD {getGBBRD :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gbbrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gbbrd = getGBBRD $ Class.switchReal (GBBRD C.gbbrd) (GBBRD Z.gbbrd)


newtype GBCON a = GBCON {getGBCON :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gbcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gbcon = getGBCON $ Class.switchReal (GBCON C.gbcon) (GBCON Z.gbcon)


newtype GBEQU a = GBEQU {getGBEQU :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

gbequ :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gbequ = getGBEQU $ Class.switchReal (GBEQU C.gbequ) (GBEQU Z.gbequ)


newtype GBEQUB a = GBEQUB {getGBEQUB :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

gbequb :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gbequb = getGBEQUB $ Class.switchReal (GBEQUB C.gbequb) (GBEQUB Z.gbequb)


newtype GBRFS a = GBRFS {getGBRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gbrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gbrfs = getGBRFS $ Class.switchReal (GBRFS C.gbrfs) (GBRFS Z.gbrfs)


newtype GBSV a = GBSV {getGBSV :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gbsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gbsv = getGBSV $ Class.switchReal (GBSV C.gbsv) (GBSV Z.gbsv)


newtype GBSVX a = GBSVX {getGBSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gbsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gbsvx = getGBSVX $ Class.switchReal (GBSVX C.gbsvx) (GBSVX Z.gbsvx)


newtype GBTF2 a = GBTF2 {getGBTF2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

gbtf2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtf2 = getGBTF2 $ Class.switchReal (GBTF2 C.gbtf2) (GBTF2 Z.gbtf2)


newtype GBTRF a = GBTRF {getGBTRF :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

gbtrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtrf = getGBTRF $ Class.switchReal (GBTRF C.gbtrf) (GBTRF Z.gbtrf)


newtype GBTRS a = GBTRS {getGBTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gbtrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gbtrs = getGBTRS $ Class.switchReal (GBTRS C.gbtrs) (GBTRS Z.gbtrs)


newtype GEBAK a = GEBAK {getGEBAK :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gebak :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gebak = getGEBAK $ Class.switchReal (GEBAK C.gebak) (GEBAK Z.gebak)


newtype GEBAL a = GEBAL {getGEBAL :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

gebal :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gebal = getGEBAL $ Class.switchReal (GEBAL C.gebal) (GEBAL Z.gebal)


newtype GEBD2 a = GEBD2 {getGEBD2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gebd2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
gebd2 = getGEBD2 $ Class.switchReal (GEBD2 C.gebd2) (GEBD2 Z.gebd2)


newtype GEBRD a = GEBRD {getGEBRD :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gebrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gebrd = getGEBRD $ Class.switchReal (GEBRD C.gebrd) (GEBRD Z.gebrd)


newtype GECON a = GECON {getGECON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gecon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gecon = getGECON $ Class.switchReal (GECON C.gecon) (GECON Z.gecon)


newtype GEEQU a = GEEQU {getGEEQU :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

geequ :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geequ = getGEEQU $ Class.switchReal (GEEQU C.geequ) (GEEQU Z.geequ)


newtype GEEQUB a = GEEQUB {getGEEQUB :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

geequb :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geequb = getGEEQUB $ Class.switchReal (GEEQUB C.geequb) (GEEQUB Z.geequb)


newtype GEES a = GEES {getGEES :: Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> IO Bool) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()}

gees :: Class.Real a => Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> IO Bool) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()
gees = getGEES $ Class.switchReal (GEES C.gees) (GEES Z.gees)


newtype GEESX a = GEESX {getGEESX :: Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> IO Bool) -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()}

geesx :: Class.Real a => Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> IO Bool) -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()
geesx = getGEESX $ Class.switchReal (GEESX C.geesx) (GEESX Z.geesx)


newtype GEEV a = GEEV {getGEEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

geev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
geev = getGEEV $ Class.switchReal (GEEV C.geev) (GEEV Z.geev)


newtype GEEVX a = GEEVX {getGEEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

geevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
geevx = getGEEVX $ Class.switchReal (GEEVX C.geevx) (GEEVX Z.geevx)


newtype GEHD2 a = GEHD2 {getGEHD2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gehd2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
gehd2 = getGEHD2 $ Class.switchReal (GEHD2 C.gehd2) (GEHD2 Z.gehd2)


newtype GEHRD a = GEHRD {getGEHRD :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gehrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gehrd = getGEHRD $ Class.switchReal (GEHRD C.gehrd) (GEHRD Z.gehrd)


newtype GELQ2 a = GELQ2 {getGELQ2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gelq2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
gelq2 = getGELQ2 $ Class.switchReal (GELQ2 C.gelq2) (GELQ2 Z.gelq2)


newtype GELQF a = GELQF {getGELQF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gelqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gelqf = getGELQF $ Class.switchReal (GELQF C.gelqf) (GELQF Z.gelqf)


newtype GELS a = GELS {getGELS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gels :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gels = getGELS $ Class.switchReal (GELS C.gels) (GELS Z.gels)


newtype GELSD a = GELSD {getGELSD :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

gelsd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gelsd = getGELSD $ Class.switchReal (GELSD C.gelsd) (GELSD Z.gelsd)


newtype GELSS a = GELSS {getGELSS :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

gelss :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gelss = getGELSS $ Class.switchReal (GELSS C.gelss) (GELSS Z.gelss)


newtype GELSY a = GELSY {getGELSY :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

gelsy :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gelsy = getGELSY $ Class.switchReal (GELSY C.gelsy) (GELSY Z.gelsy)


newtype GEQL2 a = GEQL2 {getGEQL2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

geql2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
geql2 = getGEQL2 $ Class.switchReal (GEQL2 C.geql2) (GEQL2 Z.geql2)


newtype GEQLF a = GEQLF {getGEQLF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

geqlf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
geqlf = getGEQLF $ Class.switchReal (GEQLF C.geqlf) (GEQLF Z.geqlf)


newtype GEQP3 a = GEQP3 {getGEQP3 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

geqp3 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
geqp3 = getGEQP3 $ Class.switchReal (GEQP3 C.geqp3) (GEQP3 Z.geqp3)


newtype GEQR2 a = GEQR2 {getGEQR2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

geqr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
geqr2 = getGEQR2 $ Class.switchReal (GEQR2 C.geqr2) (GEQR2 Z.geqr2)


newtype GEQR2P a = GEQR2P {getGEQR2P :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

geqr2p :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
geqr2p = getGEQR2P $ Class.switchReal (GEQR2P C.geqr2p) (GEQR2P Z.geqr2p)


newtype GEQRF a = GEQRF {getGEQRF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

geqrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
geqrf = getGEQRF $ Class.switchReal (GEQRF C.geqrf) (GEQRF Z.geqrf)


newtype GEQRFP a = GEQRFP {getGEQRFP :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

geqrfp :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
geqrfp = getGEQRFP $ Class.switchReal (GEQRFP C.geqrfp) (GEQRFP Z.geqrfp)


newtype GERFS a = GERFS {getGERFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gerfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gerfs = getGERFS $ Class.switchReal (GERFS C.gerfs) (GERFS Z.gerfs)


newtype GERQ2 a = GERQ2 {getGERQ2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gerq2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
gerq2 = getGERQ2 $ Class.switchReal (GERQ2 C.gerq2) (GERQ2 Z.gerq2)


newtype GERQF a = GERQF {getGERQF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gerqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gerqf = getGERQF $ Class.switchReal (GERQF C.gerqf) (GERQF Z.gerqf)


newtype GESC2 a = GESC2 {getGESC2 :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> IO ()}

gesc2 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> IO ()
gesc2 = getGESC2 $ Class.switchReal (GESC2 C.gesc2) (GESC2 Z.gesc2)


newtype GESDD a = GESDD {getGESDD :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

gesdd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesdd = getGESDD $ Class.switchReal (GESDD C.gesdd) (GESDD Z.gesdd)


newtype GESV a = GESV {getGESV :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gesv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gesv = getGESV $ Class.switchReal (GESV C.gesv) (GESV Z.gesv)


newtype GESVD a = GESVD {getGESVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

gesvd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gesvd = getGESVD $ Class.switchReal (GESVD C.gesvd) (GESVD Z.gesvd)


newtype GESVX a = GESVX {getGESVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gesvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gesvx = getGESVX $ Class.switchReal (GESVX C.gesvx) (GESVX Z.gesvx)


newtype GETC2 a = GETC2 {getGETC2 :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

getc2 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getc2 = getGETC2 $ Class.switchReal (GETC2 C.getc2) (GETC2 Z.getc2)


newtype GETF2 a = GETF2 {getGETF2 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

getf2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getf2 = getGETF2 $ Class.switchReal (GETF2 C.getf2) (GETF2 Z.getf2)


newtype GETRF a = GETRF {getGETRF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

getrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getrf = getGETRF $ Class.switchReal (GETRF C.getrf) (GETRF Z.getrf)


newtype GETRI a = GETRI {getGETRI :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

getri :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
getri = getGETRI $ Class.switchReal (GETRI C.getri) (GETRI Z.getri)


newtype GETRS a = GETRS {getGETRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

getrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
getrs = getGETRS $ Class.switchReal (GETRS C.getrs) (GETRS Z.getrs)


newtype GGBAK a = GGBAK {getGGBAK :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ggbak :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ggbak = getGGBAK $ Class.switchReal (GGBAK C.ggbak) (GGBAK Z.ggbak)


newtype GGBAL a = GGBAL {getGGBAL :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

ggbal :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ggbal = getGGBAL $ Class.switchReal (GGBAL C.ggbal) (GGBAL Z.ggbal)


newtype GGES a = GGES {getGGES :: Ptr CChar -> Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> Ptr (Complex a) -> IO Bool) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()}

gges :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> Ptr (Complex a) -> IO Bool) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr Bool -> Ptr CInt -> IO ()
gges = getGGES $ Class.switchReal (GGES C.gges) (GGES Z.gges)


newtype GGESX a = GGESX {getGGESX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> Ptr (Complex a) -> IO Bool) -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr Bool -> Ptr CInt -> IO ()}

ggesx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> FunPtr (Ptr (Complex a) -> Ptr (Complex a) -> IO Bool) -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr Bool -> Ptr CInt -> IO ()
ggesx = getGGESX $ Class.switchReal (GGESX C.ggesx) (GGESX Z.ggesx)


newtype GGEV a = GGEV {getGGEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

ggev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
ggev = getGGEV $ Class.switchReal (GGEV C.ggev) (GGEV Z.ggev)


newtype GGEVX a = GGEVX {getGGEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr Bool -> Ptr CInt -> IO ()}

ggevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr Bool -> Ptr CInt -> IO ()
ggevx = getGGEVX $ Class.switchReal (GGEVX C.ggevx) (GGEVX Z.ggevx)


newtype GGGLM a = GGGLM {getGGGLM :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ggglm :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ggglm = getGGGLM $ Class.switchReal (GGGLM C.ggglm) (GGGLM Z.ggglm)


newtype GGHRD a = GGHRD {getGGHRD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gghrd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gghrd = getGGHRD $ Class.switchReal (GGHRD C.gghrd) (GGHRD Z.gghrd)


newtype GGLSE a = GGLSE {getGGLSE :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gglse :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gglse = getGGLSE $ Class.switchReal (GGLSE C.gglse) (GGLSE Z.gglse)


newtype GGQRF a = GGQRF {getGGQRF :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ggqrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ggqrf = getGGQRF $ Class.switchReal (GGQRF C.ggqrf) (GGQRF Z.ggqrf)


newtype GGRQF a = GGRQF {getGGRQF :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ggrqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ggrqf = getGGRQF $ Class.switchReal (GGRQF C.ggrqf) (GGRQF Z.ggrqf)


newtype GTCON a = GTCON {getGTCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gtcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
gtcon = getGTCON $ Class.switchReal (GTCON C.gtcon) (GTCON Z.gtcon)


newtype GTRFS a = GTRFS {getGTRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gtrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gtrfs = getGTRFS $ Class.switchReal (GTRFS C.gtrfs) (GTRFS Z.gtrfs)


newtype GTSV a = GTSV {getGTSV :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gtsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gtsv = getGTSV $ Class.switchReal (GTSV C.gtsv) (GTSV Z.gtsv)


newtype GTSVX a = GTSVX {getGTSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

gtsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
gtsvx = getGTSVX $ Class.switchReal (GTSVX C.gtsvx) (GTSVX Z.gtsvx)


newtype GTTRF a = GTTRF {getGTTRF :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gttrf :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gttrf = getGTTRF $ Class.switchReal (GTTRF C.gttrf) (GTTRF Z.gttrf)


newtype GTTRS a = GTTRS {getGTTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

gttrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
gttrs = getGTTRS $ Class.switchReal (GTTRS C.gttrs) (GTTRS Z.gttrs)


newtype GTTS2 a = GTTS2 {getGTTS2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

gtts2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
gtts2 = getGTTS2 $ Class.switchReal (GTTS2 C.gtts2) (GTTS2 Z.gtts2)


newtype HBEV a = HBEV {getHBEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hbev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hbev = getHBEV $ Class.switchReal (HBEV C.hbev) (HBEV Z.hbev)


newtype HBEVD a = HBEVD {getHBEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hbevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hbevd = getHBEVD $ Class.switchReal (HBEVD C.hbevd) (HBEVD Z.hbevd)


newtype HBEVX a = HBEVX {getHBEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hbevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hbevx = getHBEVX $ Class.switchReal (HBEVX C.hbevx) (HBEVX Z.hbevx)


newtype HBGST a = HBGST {getHBGST :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hbgst :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hbgst = getHBGST $ Class.switchReal (HBGST C.hbgst) (HBGST Z.hbgst)


newtype HBGV a = HBGV {getHBGV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hbgv :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hbgv = getHBGV $ Class.switchReal (HBGV C.hbgv) (HBGV Z.hbgv)


newtype HBGVD a = HBGVD {getHBGVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hbgvd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hbgvd = getHBGVD $ Class.switchReal (HBGVD C.hbgvd) (HBGVD Z.hbgvd)


newtype HBGVX a = HBGVX {getHBGVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hbgvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hbgvx = getHBGVX $ Class.switchReal (HBGVX C.hbgvx) (HBGVX Z.hbgvx)


newtype HBTRD a = HBTRD {getHBTRD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hbtrd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
hbtrd = getHBTRD $ Class.switchReal (HBTRD C.hbtrd) (HBTRD Z.hbtrd)


newtype HECON a = HECON {getHECON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hecon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
hecon = getHECON $ Class.switchReal (HECON C.hecon) (HECON Z.hecon)


newtype HEEQUB a = HEEQUB {getHEEQUB :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

heequb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
heequb = getHEEQUB $ Class.switchReal (HEEQUB C.heequb) (HEEQUB Z.heequb)


newtype HEEV a = HEEV {getHEEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

heev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
heev = getHEEV $ Class.switchReal (HEEV C.heev) (HEEV Z.heev)


newtype HEEVD a = HEEVD {getHEEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

heevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
heevd = getHEEVD $ Class.switchReal (HEEVD C.heevd) (HEEVD Z.heevd)


newtype HEEVR a = HEEVR {getHEEVR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

heevr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
heevr = getHEEVR $ Class.switchReal (HEEVR C.heevr) (HEEVR Z.heevr)


newtype HEEVX a = HEEVX {getHEEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

heevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
heevx = getHEEVX $ Class.switchReal (HEEVX C.heevx) (HEEVX Z.heevx)


newtype HEGS2 a = HEGS2 {getHEGS2 :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hegs2 :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hegs2 = getHEGS2 $ Class.switchReal (HEGS2 C.hegs2) (HEGS2 Z.hegs2)


newtype HEGST a = HEGST {getHEGST :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hegst :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hegst = getHEGST $ Class.switchReal (HEGST C.hegst) (HEGST Z.hegst)


newtype HEGV a = HEGV {getHEGV :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

hegv :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
hegv = getHEGV $ Class.switchReal (HEGV C.hegv) (HEGV Z.hegv)


newtype HEGVD a = HEGVD {getHEGVD :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hegvd :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hegvd = getHEGVD $ Class.switchReal (HEGVD C.hegvd) (HEGVD Z.hegvd)


newtype HEGVX a = HEGVX {getHEGVX :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hegvx :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hegvx = getHEGVX $ Class.switchReal (HEGVX C.hegvx) (HEGVX Z.hegvx)


newtype HERFS a = HERFS {getHERFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

herfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
herfs = getHERFS $ Class.switchReal (HERFS C.herfs) (HERFS Z.herfs)


newtype HESV a = HESV {getHESV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hesv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hesv = getHESV $ Class.switchReal (HESV C.hesv) (HESV Z.hesv)


newtype HESVX a = HESVX {getHESVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

hesvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
hesvx = getHESVX $ Class.switchReal (HESVX C.hesvx) (HESVX Z.hesvx)


newtype HESWAPR a = HESWAPR {getHESWAPR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

heswapr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
heswapr = getHESWAPR $ Class.switchReal (HESWAPR C.heswapr) (HESWAPR Z.heswapr)


newtype HETD2 a = HETD2 {getHETD2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hetd2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
hetd2 = getHETD2 $ Class.switchReal (HETD2 C.hetd2) (HETD2 Z.hetd2)


newtype HETF2 a = HETF2 {getHETF2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hetf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hetf2 = getHETF2 $ Class.switchReal (HETF2 C.hetf2) (HETF2 Z.hetf2)


newtype HETRD a = HETRD {getHETRD :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hetrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hetrd = getHETRD $ Class.switchReal (HETRD C.hetrd) (HETRD Z.hetrd)


newtype HETRF a = HETRF {getHETRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hetrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hetrf = getHETRF $ Class.switchReal (HETRF C.hetrf) (HETRF Z.hetrf)


newtype HETRI a = HETRI {getHETRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hetri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
hetri = getHETRI $ Class.switchReal (HETRI C.hetri) (HETRI Z.hetri)


newtype HETRI2 a = HETRI2 {getHETRI2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hetri2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hetri2 = getHETRI2 $ Class.switchReal (HETRI2 C.hetri2) (HETRI2 Z.hetri2)


newtype HETRI2X a = HETRI2X {getHETRI2X :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hetri2x :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hetri2x = getHETRI2X $ Class.switchReal (HETRI2X C.hetri2x) (HETRI2X Z.hetri2x)


newtype HETRS a = HETRS {getHETRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hetrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hetrs = getHETRS $ Class.switchReal (HETRS C.hetrs) (HETRS Z.hetrs)


newtype HETRS2 a = HETRS2 {getHETRS2 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hetrs2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
hetrs2 = getHETRS2 $ Class.switchReal (HETRS2 C.hetrs2) (HETRS2 Z.hetrs2)


newtype HFRK a = HFRK {getHFRK :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO ()}

hfrk :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO ()
hfrk = getHFRK $ Class.switchReal (HFRK C.hfrk) (HFRK Z.hfrk)


newtype HGEQZ a = HGEQZ {getHGEQZ :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

hgeqz :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
hgeqz = getHGEQZ $ Class.switchReal (HGEQZ C.hgeqz) (HGEQZ Z.hgeqz)


newtype HPCON a = HPCON {getHPCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hpcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
hpcon = getHPCON $ Class.switchReal (HPCON C.hpcon) (HPCON Z.hpcon)


newtype HPEV a = HPEV {getHPEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hpev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hpev = getHPEV $ Class.switchReal (HPEV C.hpev) (HPEV Z.hpev)


newtype HPEVD a = HPEVD {getHPEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hpevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hpevd = getHPEVD $ Class.switchReal (HPEVD C.hpevd) (HPEVD Z.hpevd)


newtype HPEVX a = HPEVX {getHPEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hpevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hpevx = getHPEVX $ Class.switchReal (HPEVX C.hpevx) (HPEVX Z.hpevx)


newtype HPGST a = HPGST {getHPGST :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hpgst :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
hpgst = getHPGST $ Class.switchReal (HPGST C.hpgst) (HPGST Z.hpgst)


newtype HPGV a = HPGV {getHPGV :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hpgv :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hpgv = getHPGV $ Class.switchReal (HPGV C.hpgv) (HPGV Z.hpgv)


newtype HPGVD a = HPGVD {getHPGVD :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hpgvd :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hpgvd = getHPGVD $ Class.switchReal (HPGVD C.hpgvd) (HPGVD Z.hpgvd)


newtype HPGVX a = HPGVX {getHPGVX :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hpgvx :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hpgvx = getHPGVX $ Class.switchReal (HPGVX C.hpgvx) (HPGVX Z.hpgvx)


newtype HPRFS a = HPRFS {getHPRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hprfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hprfs = getHPRFS $ Class.switchReal (HPRFS C.hprfs) (HPRFS Z.hprfs)


newtype HPSV a = HPSV {getHPSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hpsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hpsv = getHPSV $ Class.switchReal (HPSV C.hpsv) (HPSV Z.hpsv)


newtype HPSVX a = HPSVX {getHPSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

hpsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
hpsvx = getHPSVX $ Class.switchReal (HPSVX C.hpsvx) (HPSVX Z.hpsvx)


newtype HPTRD a = HPTRD {getHPTRD :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hptrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
hptrd = getHPTRD $ Class.switchReal (HPTRD C.hptrd) (HPTRD Z.hptrd)


newtype HPTRF a = HPTRF {getHPTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hptrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hptrf = getHPTRF $ Class.switchReal (HPTRF C.hptrf) (HPTRF Z.hptrf)


newtype HPTRI a = HPTRI {getHPTRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

hptri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
hptri = getHPTRI $ Class.switchReal (HPTRI C.hptri) (HPTRI Z.hptri)


newtype HPTRS a = HPTRS {getHPTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hptrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hptrs = getHPTRS $ Class.switchReal (HPTRS C.hptrs) (HPTRS Z.hptrs)


newtype HSEIN a = HSEIN {getHSEIN :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

hsein :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
hsein = getHSEIN $ Class.switchReal (HSEIN C.hsein) (HSEIN Z.hsein)


newtype HSEQR a = HSEQR {getHSEQR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

hseqr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
hseqr = getHSEQR $ Class.switchReal (HSEQR C.hseqr) (HSEQR Z.hseqr)


newtype ILALC a = ILALC {getILALC :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt}

ilalc :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt
ilalc = getILALC $ Class.switchReal (ILALC C.ilalc) (ILALC Z.ilalc)


newtype ILALR a = ILALR {getILALR :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt}

ilalr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt
ilalr = getILALR $ Class.switchReal (ILALR C.ilalr) (ILALR Z.ilalr)


newtype IMAX1 a = IMAX1 {getIMAX1 :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt}

imax1 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO CInt
imax1 = getIMAX1 $ Class.switchReal (IMAX1 C.imax1) (IMAX1 Z.imax1)


newtype LABRD a = LABRD {getLABRD :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

labrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
labrd = getLABRD $ Class.switchReal (LABRD C.labrd) (LABRD Z.labrd)


newtype LACGV a = LACGV {getLACGV :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lacgv :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
lacgv = getLACGV $ Class.switchReal (LACGV C.lacgv) (LACGV Z.lacgv)


newtype LACN2 a = LACN2 {getLACN2 :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

lacn2 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lacn2 = getLACN2 $ Class.switchReal (LACN2 C.lacn2) (LACN2 Z.lacn2)


newtype LACON a = LACON {getLACON :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

lacon :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
lacon = getLACON $ Class.switchReal (LACON C.lacon) (LACON Z.lacon)


newtype LACP2 a = LACP2 {getLACP2 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lacp2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
lacp2 = getLACP2 $ Class.switchReal (LACP2 C.lacp2) (LACP2 Z.lacp2)


newtype LACPY a = LACPY {getLACPY :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lacpy :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
lacpy = getLACPY $ Class.switchReal (LACPY C.lacpy) (LACPY Z.lacpy)


newtype LACRM a = LACRM {getLACRM :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()}

lacrm :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()
lacrm = getLACRM $ Class.switchReal (LACRM C.lacrm) (LACRM Z.lacrm)


newtype LACRT a = LACRT {getLACRT :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

lacrt :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
lacrt = getLACRT $ Class.switchReal (LACRT C.lacrt) (LACRT Z.lacrt)


newtype LAED0 a = LAED0 {getLAED0 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

laed0 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed0 = getLAED0 $ Class.switchReal (LAED0 C.laed0) (LAED0 Z.laed0)


newtype LAED7 a = LAED7 {getLAED7 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

laed7 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed7 = getLAED7 $ Class.switchReal (LAED7 C.laed7) (LAED7 Z.laed7)


newtype LAED8 a = LAED8 {getLAED8 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

laed8 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
laed8 = getLAED8 $ Class.switchReal (LAED8 C.laed8) (LAED8 Z.laed8)


newtype LAEIN a = LAEIN {getLAEIN :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laein :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laein = getLAEIN $ Class.switchReal (LAEIN C.laein) (LAEIN Z.laein)


newtype LAESY a = LAESY {getLAESY :: Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

laesy :: Class.Real a => Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
laesy = getLAESY $ Class.switchReal (LAESY C.laesy) (LAESY Z.laesy)


newtype LAEV2 a = LAEV2 {getLAEV2 :: Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> IO ()}

laev2 :: Class.Real a => Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> IO ()
laev2 = getLAEV2 $ Class.switchReal (LAEV2 C.laev2) (LAEV2 Z.laev2)


newtype LAGS2 a = LAGS2 {getLAGS2 :: Ptr Bool -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> IO ()}

lags2 :: Class.Real a => Ptr Bool -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> IO ()
lags2 = getLAGS2 $ Class.switchReal (LAGS2 C.lags2) (LAGS2 Z.lags2)


newtype LAGTM a = LAGTM {getLAGTM :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lagtm :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
lagtm = getLAGTM $ Class.switchReal (LAGTM C.lagtm) (LAGTM Z.lagtm)


newtype LAHEF a = LAHEF {getLAHEF :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lahef :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lahef = getLAHEF $ Class.switchReal (LAHEF C.lahef) (LAHEF Z.lahef)


newtype LAHQR a = LAHQR {getLAHQR :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lahqr :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lahqr = getLAHQR $ Class.switchReal (LAHQR C.lahqr) (LAHQR Z.lahqr)


newtype LAHR2 a = LAHR2 {getLAHR2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lahr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
lahr2 = getLAHR2 $ Class.switchReal (LAHR2 C.lahr2) (LAHR2 Z.lahr2)


newtype LAIC1 a = LAIC1 {getLAIC1 :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

laic1 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
laic1 = getLAIC1 $ Class.switchReal (LAIC1 C.laic1) (LAIC1 Z.laic1)


newtype LALS0 a = LALS0 {getLALS0 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lals0 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lals0 = getLALS0 $ Class.switchReal (LALS0 C.lals0) (LALS0 Z.lals0)


newtype LALSA a = LALSA {getLALSA :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

lalsa :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lalsa = getLALSA $ Class.switchReal (LALSA C.lalsa) (LALSA Z.lalsa)


newtype LALSD a = LALSD {getLALSD :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

lalsd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lalsd = getLALSD $ Class.switchReal (LALSD C.lalsd) (LALSD Z.lalsd)


newtype LANGB a = LANGB {getLANGB :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

langb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
langb = getLANGB $ Class.switchReal (LANGB C.langb) (LANGB Z.langb)


newtype LANGE a = LANGE {getLANGE :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lange :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lange = getLANGE $ Class.switchReal (LANGE C.lange) (LANGE Z.lange)


newtype LANGT a = LANGT {getLANGT :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO a}

langt :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO a
langt = getLANGT $ Class.switchReal (LANGT C.langt) (LANGT Z.langt)


newtype LANHB a = LANHB {getLANHB :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lanhb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lanhb = getLANHB $ Class.switchReal (LANHB C.lanhb) (LANHB Z.lanhb)


newtype LANHE a = LANHE {getLANHE :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lanhe :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lanhe = getLANHE $ Class.switchReal (LANHE C.lanhe) (LANHE Z.lanhe)


newtype LANHF a = LANHF {getLANHF :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a}

lanhf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a
lanhf = getLANHF $ Class.switchReal (LANHF C.lanhf) (LANHF Z.lanhf)


newtype LANHP a = LANHP {getLANHP :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a}

lanhp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a
lanhp = getLANHP $ Class.switchReal (LANHP C.lanhp) (LANHP Z.lanhp)


newtype LANHS a = LANHS {getLANHS :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lanhs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lanhs = getLANHS $ Class.switchReal (LANHS C.lanhs) (LANHS Z.lanhs)


newtype LANHT a = LANHT {getLANHT :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO a}

lanht :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO a
lanht = getLANHT $ Class.switchReal (LANHT C.lanht) (LANHT Z.lanht)


newtype LANSB a = LANSB {getLANSB :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lansb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lansb = getLANSB $ Class.switchReal (LANSB C.lansb) (LANSB Z.lansb)


newtype LANSP a = LANSP {getLANSP :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a}

lansp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a
lansp = getLANSP $ Class.switchReal (LANSP C.lansp) (LANSP Z.lansp)


newtype LANSY a = LANSY {getLANSY :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lansy :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lansy = getLANSY $ Class.switchReal (LANSY C.lansy) (LANSY Z.lansy)


newtype LANTB a = LANTB {getLANTB :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lantb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lantb = getLANTB $ Class.switchReal (LANTB C.lantb) (LANTB Z.lantb)


newtype LANTP a = LANTP {getLANTP :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a}

lantp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> IO a
lantp = getLANTP $ Class.switchReal (LANTP C.lantp) (LANTP Z.lantp)


newtype LANTR a = LANTR {getLANTR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a}

lantr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO a
lantr = getLANTR $ Class.switchReal (LANTR C.lantr) (LANTR Z.lantr)


newtype LAPLL a = LAPLL {getLAPLL :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()}

lapll :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()
lapll = getLAPLL $ Class.switchReal (LAPLL C.lapll) (LAPLL Z.lapll)


newtype LAPMR a = LAPMR {getLAPMR :: Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lapmr :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lapmr = getLAPMR $ Class.switchReal (LAPMR C.lapmr) (LAPMR Z.lapmr)


newtype LAPMT a = LAPMT {getLAPMT :: Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lapmt :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lapmt = getLAPMT $ Class.switchReal (LAPMT C.lapmt) (LAPMT Z.lapmt)


newtype LAQGB a = LAQGB {getLAQGB :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqgb :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqgb = getLAQGB $ Class.switchReal (LAQGB C.laqgb) (LAQGB Z.laqgb)


newtype LAQGE a = LAQGE {getLAQGE :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqge :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqge = getLAQGE $ Class.switchReal (LAQGE C.laqge) (LAQGE Z.laqge)


newtype LAQHB a = LAQHB {getLAQHB :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqhb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqhb = getLAQHB $ Class.switchReal (LAQHB C.laqhb) (LAQHB Z.laqhb)


newtype LAQHE a = LAQHE {getLAQHE :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqhe :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqhe = getLAQHE $ Class.switchReal (LAQHE C.laqhe) (LAQHE Z.laqhe)


newtype LAQHP a = LAQHP {getLAQHP :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqhp :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqhp = getLAQHP $ Class.switchReal (LAQHP C.laqhp) (LAQHP Z.laqhp)


newtype LAQP2 a = LAQP2 {getLAQP2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> IO ()}

laqp2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> IO ()
laqp2 = getLAQP2 $ Class.switchReal (LAQP2 C.laqp2) (LAQP2 Z.laqp2)


newtype LAQPS a = LAQPS {getLAQPS :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

laqps :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
laqps = getLAQPS $ Class.switchReal (LAQPS C.laqps) (LAQPS Z.laqps)


newtype LAQR0 a = LAQR0 {getLAQR0 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

laqr0 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
laqr0 = getLAQR0 $ Class.switchReal (LAQR0 C.laqr0) (LAQR0 Z.laqr0)


newtype LAQR1 a = LAQR1 {getLAQR1 :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

laqr1 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
laqr1 = getLAQR1 $ Class.switchReal (LAQR1 C.laqr1) (LAQR1 Z.laqr1)


newtype LAQR2 a = LAQR2 {getLAQR2 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

laqr2 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
laqr2 = getLAQR2 $ Class.switchReal (LAQR2 C.laqr2) (LAQR2 Z.laqr2)


newtype LAQR3 a = LAQR3 {getLAQR3 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

laqr3 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
laqr3 = getLAQR3 $ Class.switchReal (LAQR3 C.laqr3) (LAQR3 Z.laqr3)


newtype LAQR4 a = LAQR4 {getLAQR4 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

laqr4 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
laqr4 = getLAQR4 $ Class.switchReal (LAQR4 C.laqr4) (LAQR4 Z.laqr4)


newtype LAQR5 a = LAQR5 {getLAQR5 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

laqr5 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
laqr5 = getLAQR5 $ Class.switchReal (LAQR5 C.laqr5) (LAQR5 Z.laqr5)


newtype LAQSB a = LAQSB {getLAQSB :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqsb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsb = getLAQSB $ Class.switchReal (LAQSB C.laqsb) (LAQSB Z.laqsb)


newtype LAQSP a = LAQSP {getLAQSP :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqsp :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsp = getLAQSP $ Class.switchReal (LAQSP C.laqsp) (LAQSP Z.laqsp)


newtype LAQSY a = LAQSY {getLAQSY :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()}

laqsy :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsy = getLAQSY $ Class.switchReal (LAQSY C.laqsy) (LAQSY Z.laqsy)


newtype LAR1V a = LAR1V {getLAR1V :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lar1v :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lar1v = getLAR1V $ Class.switchReal (LAR1V C.lar1v) (LAR1V Z.lar1v)


newtype LAR2V a = LAR2V {getLAR2V :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lar2v :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
lar2v = getLAR2V $ Class.switchReal (LAR2V C.lar2v) (LAR2V Z.lar2v)


newtype LARCM a = LARCM {getLARCM :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()}

larcm :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> IO ()
larcm = getLARCM $ Class.switchReal (LARCM C.larcm) (LARCM Z.larcm)


newtype LARF a = LARF {getLARF :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
larf = getLARF $ Class.switchReal (LARF C.larf) (LARF Z.larf)


newtype LARFB a = LARFB {getLARFB :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

larfb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
larfb = getLARFB $ Class.switchReal (LARFB C.larfb) (LARFB Z.larfb)


newtype LARFG a = LARFG {getLARFG :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larfg :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
larfg = getLARFG $ Class.switchReal (LARFG C.larfg) (LARFG Z.larfg)


newtype LARFGP a = LARFGP {getLARFGP :: Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larfgp :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
larfgp = getLARFGP $ Class.switchReal (LARFGP C.larfgp) (LARFGP Z.larfgp)


newtype LARFT a = LARFT {getLARFT :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

larft :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
larft = getLARFT $ Class.switchReal (LARFT C.larft) (LARFT Z.larft)


newtype LARFX a = LARFX {getLARFX :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larfx :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
larfx = getLARFX $ Class.switchReal (LARFX C.larfx) (LARFX Z.larfx)


newtype LARGV a = LARGV {getLARGV :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

largv :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
largv = getLARGV $ Class.switchReal (LARGV C.largv) (LARGV Z.largv)


newtype LARNV a = LARNV {getLARNV :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larnv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> IO ()
larnv = getLARNV $ Class.switchReal (LARNV C.larnv) (LARNV Z.larnv)


newtype LARRV a = LARRV {getLARRV :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

larrv :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
larrv = getLARRV $ Class.switchReal (LARRV C.larrv) (LARRV Z.larrv)


newtype LARTG a = LARTG {getLARTG :: Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

lartg :: Class.Real a => Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
lartg = getLARTG $ Class.switchReal (LARTG C.lartg) (LARTG Z.lartg)


newtype LARTV a = LARTV {getLARTV :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lartv :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
lartv = getLARTV $ Class.switchReal (LARTV C.lartv) (LARTV Z.lartv)


newtype LARZ a = LARZ {getLARZ :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

larz :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
larz = getLARZ $ Class.switchReal (LARZ C.larz) (LARZ Z.larz)


newtype LARZB a = LARZB {getLARZB :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

larzb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
larzb = getLARZB $ Class.switchReal (LARZB C.larzb) (LARZB Z.larzb)


newtype LARZT a = LARZT {getLARZT :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

larzt :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
larzt = getLARZT $ Class.switchReal (LARZT C.larzt) (LARZT Z.larzt)


newtype LASCL a = LASCL {getLASCL :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lascl :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lascl = getLASCL $ Class.switchReal (LASCL C.lascl) (LASCL Z.lascl)


newtype LASET a = LASET {getLASET :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

laset :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
laset = getLASET $ Class.switchReal (LASET C.laset) (LASET Z.laset)


newtype LASR a = LASR {getLASR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

lasr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
lasr = getLASR $ Class.switchReal (LASR C.lasr) (LASR Z.lasr)


newtype LASSQ a = LASSQ {getLASSQ :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> IO ()}

lassq :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> IO ()
lassq = getLASSQ $ Class.switchReal (LASSQ C.lassq) (LASSQ Z.lassq)


newtype LASWP a = LASWP {getLASWP :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

laswp :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
laswp = getLASWP $ Class.switchReal (LASWP C.laswp) (LASWP Z.laswp)


newtype LASYF a = LASYF {getLASYF :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lasyf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lasyf = getLASYF $ Class.switchReal (LASYF C.lasyf) (LASYF Z.lasyf)


newtype LATBS a = LATBS {getLATBS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

latbs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latbs = getLATBS $ Class.switchReal (LATBS C.latbs) (LATBS Z.latbs)


newtype LATDF a = LATDF {getLATDF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

latdf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
latdf = getLATDF $ Class.switchReal (LATDF C.latdf) (LATDF Z.latdf)


newtype LATPS a = LATPS {getLATPS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

latps :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latps = getLATPS $ Class.switchReal (LATPS C.latps) (LATPS Z.latps)


newtype LATRD a = LATRD {getLATRD :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

latrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
latrd = getLATRD $ Class.switchReal (LATRD C.latrd) (LATRD Z.latrd)


newtype LATRS a = LATRS {getLATRS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

latrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latrs = getLATRS $ Class.switchReal (LATRS C.latrs) (LATRS Z.latrs)


newtype LATRZ a = LATRZ {getLATRZ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()}

latrz :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> IO ()
latrz = getLATRZ $ Class.switchReal (LATRZ C.latrz) (LATRZ Z.latrz)


newtype LAUU2 a = LAUU2 {getLAUU2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lauu2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lauu2 = getLAUU2 $ Class.switchReal (LAUU2 C.lauu2) (LAUU2 Z.lauu2)


newtype LAUUM a = LAUUM {getLAUUM :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

lauum :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
lauum = getLAUUM $ Class.switchReal (LAUUM C.lauum) (LAUUM Z.lauum)


newtype PBCON a = PBCON {getPBCON :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

pbcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
pbcon = getPBCON $ Class.switchReal (PBCON C.pbcon) (PBCON Z.pbcon)


newtype PBEQU a = PBEQU {getPBEQU :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

pbequ :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pbequ = getPBEQU $ Class.switchReal (PBEQU C.pbequ) (PBEQU Z.pbequ)


newtype PBRFS a = PBRFS {getPBRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

pbrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
pbrfs = getPBRFS $ Class.switchReal (PBRFS C.pbrfs) (PBRFS Z.pbrfs)


newtype PBSTF a = PBSTF {getPBSTF :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pbstf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pbstf = getPBSTF $ Class.switchReal (PBSTF C.pbstf) (PBSTF Z.pbstf)


newtype PBSV a = PBSV {getPBSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pbsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pbsv = getPBSV $ Class.switchReal (PBSV C.pbsv) (PBSV Z.pbsv)


newtype PBSVX a = PBSVX {getPBSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

pbsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
pbsvx = getPBSVX $ Class.switchReal (PBSVX C.pbsvx) (PBSVX Z.pbsvx)


newtype PBTF2 a = PBTF2 {getPBTF2 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pbtf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pbtf2 = getPBTF2 $ Class.switchReal (PBTF2 C.pbtf2) (PBTF2 Z.pbtf2)


newtype PBTRF a = PBTRF {getPBTRF :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pbtrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pbtrf = getPBTRF $ Class.switchReal (PBTRF C.pbtrf) (PBTRF Z.pbtrf)


newtype PBTRS a = PBTRS {getPBTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pbtrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pbtrs = getPBTRS $ Class.switchReal (PBTRS C.pbtrs) (PBTRS Z.pbtrs)


newtype PFTRF a = PFTRF {getPFTRF :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

pftrf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
pftrf = getPFTRF $ Class.switchReal (PFTRF C.pftrf) (PFTRF Z.pftrf)


newtype PFTRI a = PFTRI {getPFTRI :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

pftri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
pftri = getPFTRI $ Class.switchReal (PFTRI C.pftri) (PFTRI Z.pftri)


newtype PFTRS a = PFTRS {getPFTRS :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pftrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pftrs = getPFTRS $ Class.switchReal (PFTRS C.pftrs) (PFTRS Z.pftrs)


newtype POCON a = POCON {getPOCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

pocon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
pocon = getPOCON $ Class.switchReal (POCON C.pocon) (POCON Z.pocon)


newtype POEQU a = POEQU {getPOEQU :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

poequ :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
poequ = getPOEQU $ Class.switchReal (POEQU C.poequ) (POEQU Z.poequ)


newtype POEQUB a = POEQUB {getPOEQUB :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

poequb :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
poequb = getPOEQUB $ Class.switchReal (POEQUB C.poequb) (POEQUB Z.poequb)


newtype PORFS a = PORFS {getPORFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

porfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
porfs = getPORFS $ Class.switchReal (PORFS C.porfs) (PORFS Z.porfs)


newtype POSV a = POSV {getPOSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

posv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
posv = getPOSV $ Class.switchReal (POSV C.posv) (POSV Z.posv)


newtype POSVX a = POSVX {getPOSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

posvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
posvx = getPOSVX $ Class.switchReal (POSVX C.posvx) (POSVX Z.posvx)


newtype POTF2 a = POTF2 {getPOTF2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

potf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
potf2 = getPOTF2 $ Class.switchReal (POTF2 C.potf2) (POTF2 Z.potf2)


newtype POTRF a = POTRF {getPOTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

potrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
potrf = getPOTRF $ Class.switchReal (POTRF C.potrf) (POTRF Z.potrf)


newtype POTRI a = POTRI {getPOTRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

potri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
potri = getPOTRI $ Class.switchReal (POTRI C.potri) (POTRI Z.potri)


newtype POTRS a = POTRS {getPOTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

potrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
potrs = getPOTRS $ Class.switchReal (POTRS C.potrs) (POTRS Z.potrs)


newtype PPCON a = PPCON {getPPCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

ppcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
ppcon = getPPCON $ Class.switchReal (PPCON C.ppcon) (PPCON Z.ppcon)


newtype PPEQU a = PPEQU {getPPEQU :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

ppequ :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ppequ = getPPEQU $ Class.switchReal (PPEQU C.ppequ) (PPEQU Z.ppequ)


newtype PPRFS a = PPRFS {getPPRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

pprfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
pprfs = getPPRFS $ Class.switchReal (PPRFS C.pprfs) (PPRFS Z.pprfs)


newtype PPSV a = PPSV {getPPSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ppsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ppsv = getPPSV $ Class.switchReal (PPSV C.ppsv) (PPSV Z.ppsv)


newtype PPSVX a = PPSVX {getPPSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

ppsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CChar -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
ppsvx = getPPSVX $ Class.switchReal (PPSVX C.ppsvx) (PPSVX Z.ppsvx)


newtype PPTRF a = PPTRF {getPPTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

pptrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
pptrf = getPPTRF $ Class.switchReal (PPTRF C.pptrf) (PPTRF Z.pptrf)


newtype PPTRI a = PPTRI {getPPTRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

pptri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
pptri = getPPTRI $ Class.switchReal (PPTRI C.pptri) (PPTRI Z.pptri)


newtype PPTRS a = PPTRS {getPPTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pptrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pptrs = getPPTRS $ Class.switchReal (PPTRS C.pptrs) (PPTRS Z.pptrs)


newtype PSTF2 a = PSTF2 {getPSTF2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

pstf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pstf2 = getPSTF2 $ Class.switchReal (PSTF2 C.pstf2) (PSTF2 Z.pstf2)


newtype PSTRF a = PSTRF {getPSTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

pstrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pstrf = getPSTRF $ Class.switchReal (PSTRF C.pstrf) (PSTRF Z.pstrf)


newtype PTCON a = PTCON {getPTCON :: Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

ptcon :: Class.Real a => Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ptcon = getPTCON $ Class.switchReal (PTCON C.ptcon) (PTCON Z.ptcon)


newtype PTEQR a = PTEQR {getPTEQR :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

pteqr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pteqr = getPTEQR $ Class.switchReal (PTEQR C.pteqr) (PTEQR Z.pteqr)


newtype PTRFS a = PTRFS {getPTRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

ptrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
ptrfs = getPTRFS $ Class.switchReal (PTRFS C.ptrfs) (PTRFS Z.ptrfs)


newtype PTSV a = PTSV {getPTSV :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ptsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ptsv = getPTSV $ Class.switchReal (PTSV C.ptsv) (PTSV Z.ptsv)


newtype PTSVX a = PTSVX {getPTSVX :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

ptsvx :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
ptsvx = getPTSVX $ Class.switchReal (PTSVX C.ptsvx) (PTSVX Z.ptsvx)


newtype PTTRF a = PTTRF {getPTTRF :: Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

pttrf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
pttrf = getPTTRF $ Class.switchReal (PTTRF C.pttrf) (PTTRF Z.pttrf)


newtype PTTRS a = PTTRS {getPTTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

pttrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
pttrs = getPTTRS $ Class.switchReal (PTTRS C.pttrs) (PTTRS Z.pttrs)


newtype PTTS2 a = PTTS2 {getPTTS2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

ptts2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
ptts2 = getPTTS2 $ Class.switchReal (PTTS2 C.ptts2) (PTTS2 Z.ptts2)


newtype ROT a = ROT {getROT :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO ()}

rot :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> IO ()
rot = getROT $ Class.switchReal (ROT C.rot) (ROT Z.rot)


newtype RSCL a = RSCL {getRSCL :: Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

rscl :: Class.Real a => Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
rscl = getRSCL $ Class.switchReal (RSCL C.rscl) (RSCL Z.rscl)


newtype SPCON a = SPCON {getSPCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

spcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
spcon = getSPCON $ Class.switchReal (SPCON C.spcon) (SPCON Z.spcon)


newtype SPMV a = SPMV {getSPMV :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

spmv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
spmv = getSPMV $ Class.switchReal (SPMV C.spmv) (SPMV Z.spmv)


newtype SPR a = SPR {getSPR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()}

spr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> IO ()
spr = getSPR $ Class.switchReal (SPR C.spr) (SPR Z.spr)


newtype SPRFS a = SPRFS {getSPRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

sprfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
sprfs = getSPRFS $ Class.switchReal (SPRFS C.sprfs) (SPRFS Z.sprfs)


newtype SPSV a = SPSV {getSPSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

spsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
spsv = getSPSV $ Class.switchReal (SPSV C.spsv) (SPSV Z.spsv)


newtype SPSVX a = SPSVX {getSPSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

spsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
spsvx = getSPSVX $ Class.switchReal (SPSVX C.spsvx) (SPSVX Z.spsvx)


newtype SPTRF a = SPTRF {getSPTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sptrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sptrf = getSPTRF $ Class.switchReal (SPTRF C.sptrf) (SPTRF Z.sptrf)


newtype SPTRI a = SPTRI {getSPTRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

sptri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
sptri = getSPTRI $ Class.switchReal (SPTRI C.sptri) (SPTRI Z.sptri)


newtype SPTRS a = SPTRS {getSPTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sptrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sptrs = getSPTRS $ Class.switchReal (SPTRS C.sptrs) (SPTRS Z.sptrs)


newtype STEDC a = STEDC {getSTEDC :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stedc :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stedc = getSTEDC $ Class.switchReal (STEDC C.stedc) (STEDC Z.stedc)


newtype STEGR a = STEGR {getSTEGR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stegr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stegr = getSTEGR $ Class.switchReal (STEGR C.stegr) (STEGR Z.stegr)


newtype STEIN a = STEIN {getSTEIN :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stein :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stein = getSTEIN $ Class.switchReal (STEIN C.stein) (STEIN Z.stein)


newtype STEMR a = STEMR {getSTEMR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr Bool -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stemr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr Bool -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stemr = getSTEMR $ Class.switchReal (STEMR C.stemr) (STEMR Z.stemr)


newtype STEQR a = STEQR {getSTEQR :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

steqr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
steqr = getSTEQR $ Class.switchReal (STEQR C.steqr) (STEQR Z.steqr)


newtype SUM1 a = SUM1 {getSUM1 :: Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO a}

sum1 :: Class.Real a => Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO a
sum1 = getSUM1 $ Class.switchReal (SUM1 C.sum1) (SUM1 Z.sum1)


newtype SYCON a = SYCON {getSYCON :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

sycon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
sycon = getSYCON $ Class.switchReal (SYCON C.sycon) (SYCON Z.sycon)


newtype SYCONV a = SYCONV {getSYCONV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

syconv :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
syconv = getSYCONV $ Class.switchReal (SYCONV C.syconv) (SYCONV Z.syconv)


newtype SYEQUB a = SYEQUB {getSYEQUB :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()}

syequb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> IO ()
syequb = getSYEQUB $ Class.switchReal (SYEQUB C.syequb) (SYEQUB Z.syequb)


newtype SYMV a = SYMV {getSYMV :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

symv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
symv = getSYMV $ Class.switchReal (SYMV C.symv) (SYMV Z.symv)


newtype SYR a = SYR {getSYR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

syr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
syr = getSYR $ Class.switchReal (SYR C.syr) (SYR Z.syr)


newtype SYRFS a = SYRFS {getSYRFS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

syrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
syrfs = getSYRFS $ Class.switchReal (SYRFS C.syrfs) (SYRFS Z.syrfs)


newtype SYSV a = SYSV {getSYSV :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sysv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sysv = getSYSV $ Class.switchReal (SYSV C.sysv) (SYSV Z.sysv)


newtype SYSVX a = SYSVX {getSYSVX :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

sysvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sysvx = getSYSVX $ Class.switchReal (SYSVX C.sysvx) (SYSVX Z.sysvx)


newtype SYSWAPR a = SYSWAPR {getSYSWAPR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

syswapr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syswapr = getSYSWAPR $ Class.switchReal (SYSWAPR C.syswapr) (SYSWAPR Z.syswapr)


newtype SYTF2 a = SYTF2 {getSYTF2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sytf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sytf2 = getSYTF2 $ Class.switchReal (SYTF2 C.sytf2) (SYTF2 Z.sytf2)


newtype SYTRF a = SYTRF {getSYTRF :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sytrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sytrf = getSYTRF $ Class.switchReal (SYTRF C.sytrf) (SYTRF Z.sytrf)


newtype SYTRI a = SYTRI {getSYTRI :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

sytri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
sytri = getSYTRI $ Class.switchReal (SYTRI C.sytri) (SYTRI Z.sytri)


newtype SYTRI2 a = SYTRI2 {getSYTRI2 :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sytri2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sytri2 = getSYTRI2 $ Class.switchReal (SYTRI2 C.sytri2) (SYTRI2 Z.sytri2)


newtype SYTRI2X a = SYTRI2X {getSYTRI2X :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sytri2x :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sytri2x = getSYTRI2X $ Class.switchReal (SYTRI2X C.sytri2x) (SYTRI2X Z.sytri2x)


newtype SYTRS a = SYTRS {getSYTRS :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

sytrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
sytrs = getSYTRS $ Class.switchReal (SYTRS C.sytrs) (SYTRS Z.sytrs)


newtype SYTRS2 a = SYTRS2 {getSYTRS2 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

sytrs2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
sytrs2 = getSYTRS2 $ Class.switchReal (SYTRS2 C.sytrs2) (SYTRS2 Z.sytrs2)


newtype TBCON a = TBCON {getTBCON :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

tbcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
tbcon = getTBCON $ Class.switchReal (TBCON C.tbcon) (TBCON Z.tbcon)


newtype TBRFS a = TBRFS {getTBRFS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

tbrfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
tbrfs = getTBRFS $ Class.switchReal (TBRFS C.tbrfs) (TBRFS Z.tbrfs)


newtype TBTRS a = TBTRS {getTBTRS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tbtrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tbtrs = getTBTRS $ Class.switchReal (TBTRS C.tbtrs) (TBTRS Z.tbtrs)


newtype TFSM a = TFSM {getTFSM :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

tfsm :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
tfsm = getTFSM $ Class.switchReal (TFSM C.tfsm) (TFSM Z.tfsm)


newtype TFTRI a = TFTRI {getTFTRI :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

tftri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
tftri = getTFTRI $ Class.switchReal (TFTRI C.tftri) (TFTRI Z.tftri)


newtype TFTTP a = TFTTP {getTFTTP :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

tfttp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
tfttp = getTFTTP $ Class.switchReal (TFTTP C.tfttp) (TFTTP Z.tfttp)


newtype TFTTR a = TFTTR {getTFTTR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tfttr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tfttr = getTFTTR $ Class.switchReal (TFTTR C.tfttr) (TFTTR Z.tfttr)


newtype TGEVC a = TGEVC {getTGEVC :: Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

tgevc :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
tgevc = getTGEVC $ Class.switchReal (TGEVC C.tgevc) (TGEVC Z.tgevc)


newtype TGEX2 a = TGEX2 {getTGEX2 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

tgex2 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgex2 = getTGEX2 $ Class.switchReal (TGEX2 C.tgex2) (TGEX2 Z.tgex2)


newtype TGEXC a = TGEXC {getTGEXC :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

tgexc :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgexc = getTGEXC $ Class.switchReal (TGEXC C.tgexc) (TGEXC Z.tgexc)


newtype TGSEN a = TGSEN {getTGSEN :: Ptr CInt -> Ptr Bool -> Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

tgsen :: Class.Real a => Ptr CInt -> Ptr Bool -> Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsen = getTGSEN $ Class.switchReal (TGSEN C.tgsen) (TGSEN Z.tgsen)


newtype TGSJA a = TGSJA {getTGSJA :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tgsja :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tgsja = getTGSJA $ Class.switchReal (TGSJA C.tgsja) (TGSJA Z.tgsja)


newtype TGSNA a = TGSNA {getTGSNA :: Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

tgsna :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsna = getTGSNA $ Class.switchReal (TGSNA C.tgsna) (TGSNA Z.tgsna)


newtype TGSY2 a = TGSY2 {getTGSY2 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

tgsy2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tgsy2 = getTGSY2 $ Class.switchReal (TGSY2 C.tgsy2) (TGSY2 Z.tgsy2)


newtype TGSYL a = TGSYL {getTGSYL :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

tgsyl :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsyl = getTGSYL $ Class.switchReal (TGSYL C.tgsyl) (TGSYL Z.tgsyl)


newtype TPCON a = TPCON {getTPCON :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

tpcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
tpcon = getTPCON $ Class.switchReal (TPCON C.tpcon) (TPCON Z.tpcon)


newtype TPRFS a = TPRFS {getTPRFS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

tprfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
tprfs = getTPRFS $ Class.switchReal (TPRFS C.tprfs) (TPRFS Z.tprfs)


newtype TPTRI a = TPTRI {getTPTRI :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

tptri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
tptri = getTPTRI $ Class.switchReal (TPTRI C.tptri) (TPTRI Z.tptri)


newtype TPTRS a = TPTRS {getTPTRS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tptrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tptrs = getTPTRS $ Class.switchReal (TPTRS C.tptrs) (TPTRS Z.tptrs)


newtype TPTTF a = TPTTF {getTPTTF :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

tpttf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
tpttf = getTPTTF $ Class.switchReal (TPTTF C.tpttf) (TPTTF Z.tpttf)


newtype TPTTR a = TPTTR {getTPTTR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tpttr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tpttr = getTPTTR $ Class.switchReal (TPTTR C.tpttr) (TPTTR Z.tpttr)


newtype TRCON a = TRCON {getTRCON :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

trcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
trcon = getTRCON $ Class.switchReal (TRCON C.trcon) (TRCON Z.trcon)


newtype TREVC a = TREVC {getTREVC :: Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

trevc :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
trevc = getTREVC $ Class.switchReal (TREVC C.trevc) (TREVC Z.trevc)


newtype TREXC a = TREXC {getTREXC :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

trexc :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
trexc = getTREXC $ Class.switchReal (TREXC C.trexc) (TREXC Z.trexc)


newtype TRRFS a = TRRFS {getTRRFS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()}

trrfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr a -> Ptr CInt -> IO ()
trrfs = getTRRFS $ Class.switchReal (TRRFS C.trrfs) (TRRFS Z.trrfs)


newtype TRSEN a = TRSEN {getTRSEN :: Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

trsen :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
trsen = getTRSEN $ Class.switchReal (TRSEN C.trsen) (TRSEN Z.trsen)


newtype TRSNA a = TRSNA {getTRSNA :: Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

trsna :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr Bool -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trsna = getTRSNA $ Class.switchReal (TRSNA C.trsna) (TRSNA Z.trsna)


newtype TRSYL a = TRSYL {getTRSYL :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

trsyl :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trsyl = getTRSYL $ Class.switchReal (TRSYL C.trsyl) (TRSYL Z.trsyl)


newtype TRTI2 a = TRTI2 {getTRTI2 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

trti2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
trti2 = getTRTI2 $ Class.switchReal (TRTI2 C.trti2) (TRTI2 Z.trti2)


newtype TRTRI a = TRTRI {getTRTRI :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

trtri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
trtri = getTRTRI $ Class.switchReal (TRTRI C.trtri) (TRTRI Z.trtri)


newtype TRTRS a = TRTRS {getTRTRS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

trtrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
trtrs = getTRTRS $ Class.switchReal (TRTRS C.trtrs) (TRTRS Z.trtrs)


newtype TRTTF a = TRTTF {getTRTTF :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

trttf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
trttf = getTRTTF $ Class.switchReal (TRTTF C.trttf) (TRTTF Z.trttf)


newtype TRTTP a = TRTTP {getTRTTP :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

trttp :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
trttp = getTRTTP $ Class.switchReal (TRTTP C.trttp) (TRTTP Z.trttp)


newtype TZRZF a = TZRZF {getTZRZF :: Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

tzrzf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
tzrzf = getTZRZF $ Class.switchReal (TZRZF C.tzrzf) (TZRZF Z.tzrzf)


newtype UNBDB a = UNBDB {getUNBDB :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unbdb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr a -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unbdb = getUNBDB $ Class.switchReal (UNBDB C.unbdb) (UNBDB Z.unbdb)


newtype UNCSD a = UNCSD {getUNCSD :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

uncsd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
uncsd = getUNCSD $ Class.switchReal (UNCSD C.uncsd) (UNCSD Z.uncsd)


newtype UNG2L a = UNG2L {getUNG2L :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

ung2l :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
ung2l = getUNG2L $ Class.switchReal (UNG2L C.ung2l) (UNG2L Z.ung2l)


newtype UNG2R a = UNG2R {getUNG2R :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

ung2r :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
ung2r = getUNG2R $ Class.switchReal (UNG2R C.ung2r) (UNG2R Z.ung2r)


newtype UNGBR a = UNGBR {getUNGBR :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ungbr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ungbr = getUNGBR $ Class.switchReal (UNGBR C.ungbr) (UNGBR Z.ungbr)


newtype UNGHR a = UNGHR {getUNGHR :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unghr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unghr = getUNGHR $ Class.switchReal (UNGHR C.unghr) (UNGHR Z.unghr)


newtype UNGL2 a = UNGL2 {getUNGL2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

ungl2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
ungl2 = getUNGL2 $ Class.switchReal (UNGL2 C.ungl2) (UNGL2 Z.ungl2)


newtype UNGLQ a = UNGLQ {getUNGLQ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unglq :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unglq = getUNGLQ $ Class.switchReal (UNGLQ C.unglq) (UNGLQ Z.unglq)


newtype UNGQL a = UNGQL {getUNGQL :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ungql :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ungql = getUNGQL $ Class.switchReal (UNGQL C.ungql) (UNGQL Z.ungql)


newtype UNGQR a = UNGQR {getUNGQR :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ungqr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ungqr = getUNGQR $ Class.switchReal (UNGQR C.ungqr) (UNGQR Z.ungqr)


newtype UNGR2 a = UNGR2 {getUNGR2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()}

ungr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> IO ()
ungr2 = getUNGR2 $ Class.switchReal (UNGR2 C.ungr2) (UNGR2 Z.ungr2)


newtype UNGRQ a = UNGRQ {getUNGRQ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ungrq :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ungrq = getUNGRQ $ Class.switchReal (UNGRQ C.ungrq) (UNGRQ Z.ungrq)


newtype UNGTR a = UNGTR {getUNGTR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

ungtr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
ungtr = getUNGTR $ Class.switchReal (UNGTR C.ungtr) (UNGTR Z.ungtr)


newtype UNM2L a = UNM2L {getUNM2L :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

unm2l :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
unm2l = getUNM2L $ Class.switchReal (UNM2L C.unm2l) (UNM2L Z.unm2l)


newtype UNM2R a = UNM2R {getUNM2R :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

unm2r :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
unm2r = getUNM2R $ Class.switchReal (UNM2R C.unm2r) (UNM2R Z.unm2r)


newtype UNMBR a = UNMBR {getUNMBR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmbr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmbr = getUNMBR $ Class.switchReal (UNMBR C.unmbr) (UNMBR Z.unmbr)


newtype UNMHR a = UNMHR {getUNMHR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmhr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmhr = getUNMHR $ Class.switchReal (UNMHR C.unmhr) (UNMHR Z.unmhr)


newtype UNML2 a = UNML2 {getUNML2 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

unml2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
unml2 = getUNML2 $ Class.switchReal (UNML2 C.unml2) (UNML2 Z.unml2)


newtype UNMLQ a = UNMLQ {getUNMLQ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmlq :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmlq = getUNMLQ $ Class.switchReal (UNMLQ C.unmlq) (UNMLQ Z.unmlq)


newtype UNMQL a = UNMQL {getUNMQL :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmql :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmql = getUNMQL $ Class.switchReal (UNMQL C.unmql) (UNMQL Z.unmql)


newtype UNMQR a = UNMQR {getUNMQR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmqr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmqr = getUNMQR $ Class.switchReal (UNMQR C.unmqr) (UNMQR Z.unmqr)


newtype UNMR2 a = UNMR2 {getUNMR2 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

unmr2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
unmr2 = getUNMR2 $ Class.switchReal (UNMR2 C.unmr2) (UNMR2 Z.unmr2)


newtype UNMR3 a = UNMR3 {getUNMR3 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

unmr3 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
unmr3 = getUNMR3 $ Class.switchReal (UNMR3 C.unmr3) (UNMR3 Z.unmr3)


newtype UNMRQ a = UNMRQ {getUNMRQ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmrq :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmrq = getUNMRQ $ Class.switchReal (UNMRQ C.unmrq) (UNMRQ Z.unmrq)


newtype UNMRZ a = UNMRZ {getUNMRZ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmrz :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmrz = getUNMRZ $ Class.switchReal (UNMRZ C.unmrz) (UNMRZ Z.unmrz)


newtype UNMTR a = UNMTR {getUNMTR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()}

unmtr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> Ptr CInt -> IO ()
unmtr = getUNMTR $ Class.switchReal (UNMTR C.unmtr) (UNMTR Z.unmtr)


newtype UPGTR a = UPGTR {getUPGTR :: Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

upgtr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
upgtr = getUPGTR $ Class.switchReal (UPGTR C.upgtr) (UPGTR Z.upgtr)


newtype UPMTR a = UPMTR {getUPMTR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()}

upmtr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr (Complex a) -> Ptr CInt -> Ptr (Complex a) -> Ptr CInt -> IO ()
upmtr = getUPMTR $ Class.switchReal (UPMTR C.upmtr) (UPMTR Z.upmtr)
