-- Do not edit! Automatically generated by create-lapack-ffi.
module Numeric.LAPACK.FFI.Real (
   bbcsd,
   bdsdc,
   bdsqr,
   disna,
   gbbrd,
   gbcon,
   gbequ,
   gbequb,
   gbrfs,
   gbsv,
   gbsvx,
   gbtf2,
   gbtrf,
   gbtrs,
   gebak,
   gebal,
   gebd2,
   gebrd,
   gecon,
   geequ,
   geequb,
   gees,
   geesx,
   geev,
   geevx,
   gehd2,
   gehrd,
   gejsv,
   gelq2,
   gelqf,
   gels,
   gelsd,
   gelss,
   gelsy,
   geql2,
   geqlf,
   geqp3,
   geqr2,
   geqr2p,
   geqrf,
   geqrfp,
   gerfs,
   gerq2,
   gerqf,
   gesc2,
   gesdd,
   gesv,
   gesvd,
   gesvj,
   gesvx,
   getc2,
   getf2,
   getrf,
   getri,
   getrs,
   ggbak,
   ggbal,
   gges,
   ggesx,
   ggev,
   ggevx,
   ggglm,
   gghrd,
   gglse,
   ggqrf,
   ggrqf,
   gsvj0,
   gsvj1,
   gtcon,
   gtrfs,
   gtsv,
   gtsvx,
   gttrf,
   gttrs,
   gtts2,
   hgeqz,
   hsein,
   hseqr,
   ilalc,
   ilalr,
   isnan,
   labad,
   labrd,
   lacn2,
   lacon,
   lacpy,
   ladiv,
   lae2,
   laebz,
   laed0,
   laed1,
   laed2,
   laed3,
   laed4,
   laed5,
   laed6,
   laed7,
   laed8,
   laed9,
   laeda,
   laein,
   laev2,
   laexc,
   lag2,
   lags2,
   lagtf,
   lagtm,
   lagts,
   lagv2,
   lahqr,
   lahr2,
   laic1,
   laisnan,
   laln2,
   lals0,
   lalsa,
   lalsd,
   lamrg,
   laneg,
   langb,
   lange,
   langt,
   lanhs,
   lansb,
   lansf,
   lansp,
   lanst,
   lansy,
   lantb,
   lantp,
   lantr,
   lanv2,
   lapll,
   lapmr,
   lapmt,
   lapy2,
   lapy3,
   laqgb,
   laqge,
   laqp2,
   laqps,
   laqr0,
   laqr1,
   laqr2,
   laqr3,
   laqr4,
   laqr5,
   laqsb,
   laqsp,
   laqsy,
   laqtr,
   lar1v,
   lar2v,
   larf,
   larfb,
   larfg,
   larfgp,
   larft,
   larfx,
   largv,
   larnv,
   larra,
   larrb,
   larrc,
   larrd,
   larre,
   larrf,
   larrj,
   larrk,
   larrr,
   larrv,
   lartg,
   lartgp,
   lartgs,
   lartv,
   laruv,
   larz,
   larzb,
   larzt,
   las2,
   lascl,
   lasd0,
   lasd1,
   lasd2,
   lasd3,
   lasd4,
   lasd5,
   lasd6,
   lasd7,
   lasd8,
   lasda,
   lasdq,
   laset,
   lasq1,
   lasq2,
   lasq4,
   lasq5,
   lasq6,
   lasr,
   lasrt,
   lassq,
   lasv2,
   laswp,
   lasy2,
   lasyf,
   latbs,
   latdf,
   latps,
   latrd,
   latrs,
   latrz,
   lauu2,
   lauum,
   opgtr,
   opmtr,
   orbdb,
   orcsd,
   org2l,
   org2r,
   orgbr,
   orghr,
   orgl2,
   orglq,
   orgql,
   orgqr,
   orgr2,
   orgrq,
   orgtr,
   orm2l,
   orm2r,
   ormbr,
   ormhr,
   orml2,
   ormlq,
   ormql,
   ormqr,
   ormr2,
   ormr3,
   ormrq,
   ormrz,
   ormtr,
   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,
   rscl,
   sbev,
   sbevd,
   sbevx,
   sbgst,
   sbgv,
   sbgvd,
   sbgvx,
   sbtrd,
   sfrk,
   spcon,
   spev,
   spevd,
   spevx,
   spgst,
   spgv,
   spgvd,
   spgvx,
   sprfs,
   spsv,
   spsvx,
   sptrd,
   sptrf,
   sptri,
   sptrs,
   stebz,
   stedc,
   stegr,
   stein,
   stemr,
   steqr,
   sterf,
   stev,
   stevd,
   stevr,
   stevx,
   sycon,
   syconv,
   syequb,
   syev,
   syevd,
   syevr,
   syevx,
   sygs2,
   sygst,
   sygv,
   sygvd,
   sygvx,
   syrfs,
   sysv,
   sysvx,
   syswapr,
   sytd2,
   sytf2,
   sytrd,
   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,
   ) where

import qualified Numeric.LAPACK.FFI.Float as S
import qualified Numeric.LAPACK.FFI.Double as D

import qualified Numeric.Netlib.Class as Class

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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 S.bbcsd) (BBCSD D.bbcsd)


newtype BDSDC a = BDSDC {getBDSDC :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

bdsdc :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
bdsdc = getBDSDC $ Class.switchReal (BDSDC S.bdsdc) (BDSDC D.bdsdc)


newtype BDSQR a = BDSQR {getBDSQR :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
bdsqr = getBDSQR $ Class.switchReal (BDSQR S.bdsqr) (BDSQR D.bdsqr)


newtype DISNA a = DISNA {getDISNA :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

disna :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
disna = getDISNA $ Class.switchReal (DISNA S.disna) (DISNA D.disna)


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

gbbrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gbbrd = getGBBRD $ Class.switchReal (GBBRD S.gbbrd) (GBBRD D.gbbrd)


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

gbcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gbcon = getGBCON $ Class.switchReal (GBCON S.gbcon) (GBCON D.gbcon)


newtype GBEQU a = GBEQU {getGBEQU :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gbequ = getGBEQU $ Class.switchReal (GBEQU S.gbequ) (GBEQU D.gbequ)


newtype GBEQUB a = GBEQUB {getGBEQUB :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gbequb = getGBEQUB $ Class.switchReal (GBEQUB S.gbequb) (GBEQUB D.gbequb)


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

gbrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gbrfs = getGBRFS $ Class.switchReal (GBRFS S.gbrfs) (GBRFS D.gbrfs)


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

gbsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gbsv = getGBSV $ Class.switchReal (GBSV S.gbsv) (GBSV D.gbsv)


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

gbsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gbsvx = getGBSVX $ Class.switchReal (GBSVX S.gbsvx) (GBSVX D.gbsvx)


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

gbtf2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtf2 = getGBTF2 $ Class.switchReal (GBTF2 S.gbtf2) (GBTF2 D.gbtf2)


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

gbtrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtrf = getGBTRF $ Class.switchReal (GBTRF S.gbtrf) (GBTRF D.gbtrf)


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

gbtrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gbtrs = getGBTRS $ Class.switchReal (GBTRS S.gbtrs) (GBTRS D.gbtrs)


newtype GEBAK a = GEBAK {getGEBAK :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr CInt -> IO ()
gebak = getGEBAK $ Class.switchReal (GEBAK S.gebak) (GEBAK D.gebak)


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

gebal :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gebal = getGEBAL $ Class.switchReal (GEBAL S.gebal) (GEBAL D.gebal)


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

gebd2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gebd2 = getGEBD2 $ Class.switchReal (GEBD2 S.gebd2) (GEBD2 D.gebd2)


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

gebrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gebrd = getGEBRD $ Class.switchReal (GEBRD S.gebrd) (GEBRD D.gebrd)


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

gecon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gecon = getGECON $ Class.switchReal (GECON S.gecon) (GECON D.gecon)


newtype GEEQU a = GEEQU {getGEEQU :: Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geequ = getGEEQU $ Class.switchReal (GEEQU S.geequ) (GEEQU D.geequ)


newtype GEEQUB a = GEEQUB {getGEEQUB :: Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geequb = getGEEQUB $ Class.switchReal (GEEQUB S.geequb) (GEEQUB D.geequb)


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

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


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

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


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

geev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geev = getGEEV $ Class.switchReal (GEEV S.geev) (GEEV D.geev)


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

geevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
geevx = getGEEVX $ Class.switchReal (GEEVX S.geevx) (GEEVX D.geevx)


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

gehd2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gehd2 = getGEHD2 $ Class.switchReal (GEHD2 S.gehd2) (GEHD2 D.gehd2)


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

gehrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gehrd = getGEHRD $ Class.switchReal (GEHRD S.gehrd) (GEHRD D.gehrd)


newtype GEJSV a = GEJSV {getGEJSV :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

gejsv :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gejsv = getGEJSV $ Class.switchReal (GEJSV S.gejsv) (GEJSV D.gejsv)


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

gelq2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gelq2 = getGELQ2 $ Class.switchReal (GELQ2 S.gelq2) (GELQ2 D.gelq2)


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

gelqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gelqf = getGELQF $ Class.switchReal (GELQF S.gelqf) (GELQF D.gelqf)


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

gels :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gels = getGELS $ Class.switchReal (GELS S.gels) (GELS D.gels)


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

gelsd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gelsd = getGELSD $ Class.switchReal (GELSD S.gelsd) (GELSD D.gelsd)


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

gelss :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gelss = getGELSS $ Class.switchReal (GELSS S.gelss) (GELSS D.gelss)


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

gelsy :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gelsy = getGELSY $ Class.switchReal (GELSY S.gelsy) (GELSY D.gelsy)


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

geql2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geql2 = getGEQL2 $ Class.switchReal (GEQL2 S.geql2) (GEQL2 D.geql2)


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

geqlf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqlf = getGEQLF $ Class.switchReal (GEQLF S.geqlf) (GEQLF D.geqlf)


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

geqp3 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqp3 = getGEQP3 $ Class.switchReal (GEQP3 S.geqp3) (GEQP3 D.geqp3)


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

geqr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geqr2 = getGEQR2 $ Class.switchReal (GEQR2 S.geqr2) (GEQR2 D.geqr2)


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

geqr2p :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geqr2p = getGEQR2P $ Class.switchReal (GEQR2P S.geqr2p) (GEQR2P D.geqr2p)


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

geqrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqrf = getGEQRF $ Class.switchReal (GEQRF S.geqrf) (GEQRF D.geqrf)


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

geqrfp :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqrfp = getGEQRFP $ Class.switchReal (GEQRFP S.geqrfp) (GEQRFP D.geqrfp)


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

gerfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gerfs = getGERFS $ Class.switchReal (GERFS S.gerfs) (GERFS D.gerfs)


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

gerq2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gerq2 = getGERQ2 $ Class.switchReal (GERQ2 S.gerq2) (GERQ2 D.gerq2)


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

gerqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gerqf = getGERQF $ Class.switchReal (GERQF S.gerqf) (GERQF D.gerqf)


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

gesc2 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> IO ()
gesc2 = getGESC2 $ Class.switchReal (GESC2 S.gesc2) (GESC2 D.gesc2)


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

gesdd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gesdd = getGESDD $ Class.switchReal (GESDD S.gesdd) (GESDD D.gesdd)


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

gesv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesv = getGESV $ Class.switchReal (GESV S.gesv) (GESV D.gesv)


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

gesvd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesvd = getGESVD $ Class.switchReal (GESVD S.gesvd) (GESVD D.gesvd)


newtype GESVJ a = GESVJ {getGESVJ :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

gesvj :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesvj = getGESVJ $ Class.switchReal (GESVJ S.gesvj) (GESVJ D.gesvj)


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

gesvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesvx = getGESVX $ Class.switchReal (GESVX S.gesvx) (GESVX D.gesvx)


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

getc2 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getc2 = getGETC2 $ Class.switchReal (GETC2 S.getc2) (GETC2 D.getc2)


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

getf2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getf2 = getGETF2 $ Class.switchReal (GETF2 S.getf2) (GETF2 D.getf2)


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

getrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getrf = getGETRF $ Class.switchReal (GETRF S.getrf) (GETRF D.getrf)


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

getri :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
getri = getGETRI $ Class.switchReal (GETRI S.getri) (GETRI D.getri)


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

getrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
getrs = getGETRS $ Class.switchReal (GETRS S.getrs) (GETRS D.getrs)


newtype GGBAK a = GGBAK {getGGBAK :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr CInt -> IO ()
ggbak = getGGBAK $ Class.switchReal (GGBAK S.ggbak) (GGBAK D.ggbak)


newtype GGBAL a = GGBAL {getGGBAL :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ggbal = getGGBAL $ Class.switchReal (GGBAL S.ggbal) (GGBAL D.ggbal)


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

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


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

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


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

ggev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ggev = getGGEV $ Class.switchReal (GGEV S.ggev) (GGEV D.ggev)


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

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


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

ggglm :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ggglm = getGGGLM $ Class.switchReal (GGGLM S.ggglm) (GGGLM D.ggglm)


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

gghrd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gghrd = getGGHRD $ Class.switchReal (GGHRD S.gghrd) (GGHRD D.gghrd)


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

gglse :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gglse = getGGLSE $ Class.switchReal (GGLSE S.gglse) (GGLSE D.gglse)


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

ggqrf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ggqrf = getGGQRF $ Class.switchReal (GGQRF S.ggqrf) (GGQRF D.ggqrf)


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

ggrqf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ggrqf = getGGRQF $ Class.switchReal (GGRQF S.ggrqf) (GGRQF D.ggrqf)


newtype GSVJ0 a = GSVJ0 {getGSVJ0 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

gsvj0 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gsvj0 = getGSVJ0 $ Class.switchReal (GSVJ0 S.gsvj0) (GSVJ0 D.gsvj0)


newtype GSVJ1 a = GSVJ1 {getGSVJ1 :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

gsvj1 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gsvj1 = getGSVJ1 $ Class.switchReal (GSVJ1 S.gsvj1) (GSVJ1 D.gsvj1)


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

gtcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gtcon = getGTCON $ Class.switchReal (GTCON S.gtcon) (GTCON D.gtcon)


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

gtrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gtrfs = getGTRFS $ Class.switchReal (GTRFS S.gtrfs) (GTRFS D.gtrfs)


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

gtsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gtsv = getGTSV $ Class.switchReal (GTSV S.gtsv) (GTSV D.gtsv)


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

gtsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gtsvx = getGTSVX $ Class.switchReal (GTSVX S.gtsvx) (GTSVX D.gtsvx)


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

gttrf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gttrf = getGTTRF $ Class.switchReal (GTTRF S.gttrf) (GTTRF D.gttrf)


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

gttrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gttrs = getGTTRS $ Class.switchReal (GTTRS S.gttrs) (GTTRS D.gttrs)


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

gtts2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
gtts2 = getGTTS2 $ Class.switchReal (GTTS2 S.gtts2) (GTTS2 D.gtts2)


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

hgeqz :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
hgeqz = getHGEQZ $ Class.switchReal (HGEQZ S.hgeqz) (HGEQZ D.hgeqz)


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

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


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

hseqr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
hseqr = getHSEQR $ Class.switchReal (HSEQR S.hseqr) (HSEQR D.hseqr)


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

ilalc :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO CInt
ilalc = getILALC $ Class.switchReal (ILALC S.ilalc) (ILALC D.ilalc)


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

ilalr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO CInt
ilalr = getILALR $ Class.switchReal (ILALR S.ilalr) (ILALR D.ilalr)


newtype ISNAN a = ISNAN {getISNAN :: Ptr a -> IO Bool}

isnan :: Class.Real a => Ptr a -> IO Bool
isnan = getISNAN $ Class.switchReal (ISNAN S.isnan) (ISNAN D.isnan)


newtype LABAD a = LABAD {getLABAD :: Ptr a -> Ptr a -> IO ()}

labad :: Class.Real a => Ptr a -> Ptr a -> IO ()
labad = getLABAD $ Class.switchReal (LABAD S.labad) (LABAD D.labad)


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

labrd :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
labrd = getLABRD $ Class.switchReal (LABRD S.labrd) (LABRD D.labrd)


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

lacn2 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lacn2 = getLACN2 $ Class.switchReal (LACN2 S.lacn2) (LACN2 D.lacn2)


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

lacon :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lacon = getLACON $ Class.switchReal (LACON S.lacon) (LACON D.lacon)


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

lacpy :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lacpy = getLACPY $ Class.switchReal (LACPY S.lacpy) (LACPY D.lacpy)


newtype LADIV a = LADIV {getLADIV :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

ladiv :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
ladiv = getLADIV $ Class.switchReal (LADIV S.ladiv) (LADIV D.ladiv)


newtype LAE2 a = LAE2 {getLAE2 :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lae2 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lae2 = getLAE2 $ Class.switchReal (LAE2 S.lae2) (LAE2 D.lae2)


newtype LAEBZ a = LAEBZ {getLAEBZ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

laebz :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laebz = getLAEBZ $ Class.switchReal (LAEBZ S.laebz) (LAEBZ D.laebz)


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

laed0 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed0 = getLAED0 $ Class.switchReal (LAED0 S.laed0) (LAED0 D.laed0)


newtype LAED1 a = LAED1 {getLAED1 :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

laed1 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed1 = getLAED1 $ Class.switchReal (LAED1 S.laed1) (LAED1 D.laed1)


newtype LAED2 a = LAED2 {getLAED2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

laed2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
laed2 = getLAED2 $ Class.switchReal (LAED2 S.laed2) (LAED2 D.laed2)


newtype LAED3 a = LAED3 {getLAED3 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laed3 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laed3 = getLAED3 $ Class.switchReal (LAED3 S.laed3) (LAED3 D.laed3)


newtype LAED4 a = LAED4 {getLAED4 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laed4 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laed4 = getLAED4 $ Class.switchReal (LAED4 S.laed4) (LAED4 D.laed4)


newtype LAED5 a = LAED5 {getLAED5 :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

laed5 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
laed5 = getLAED5 $ Class.switchReal (LAED5 S.laed5) (LAED5 D.laed5)


newtype LAED6 a = LAED6 {getLAED6 :: Ptr CInt -> Ptr Bool -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laed6 :: Class.Real a => Ptr CInt -> Ptr Bool -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laed6 = getLAED6 $ Class.switchReal (LAED6 S.laed6) (LAED6 D.laed6)


newtype LAED7 a = LAED7 {getLAED7 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed7 = getLAED7 $ Class.switchReal (LAED7 S.laed7) (LAED7 D.laed7)


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

laed8 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
laed8 = getLAED8 $ Class.switchReal (LAED8 S.laed8) (LAED8 D.laed8)


newtype LAED9 a = LAED9 {getLAED9 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

laed9 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laed9 = getLAED9 $ Class.switchReal (LAED9 S.laed9) (LAED9 D.laed9)


newtype LAEDA a = LAEDA {getLAEDA :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laeda :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laeda = getLAEDA $ Class.switchReal (LAEDA S.laeda) (LAEDA D.laeda)


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

laein :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laein = getLAEIN $ Class.switchReal (LAEIN S.laein) (LAEIN D.laein)


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

laev2 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
laev2 = getLAEV2 $ Class.switchReal (LAEV2 S.laev2) (LAEV2 D.laev2)


newtype LAEXC a = LAEXC {getLAEXC :: Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

laexc :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
laexc = getLAEXC $ Class.switchReal (LAEXC S.laexc) (LAEXC D.laexc)


newtype LAG2 a = LAG2 {getLAG2 :: Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lag2 :: Class.Real a => Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lag2 = getLAG2 $ Class.switchReal (LAG2 S.lag2) (LAG2 D.lag2)


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

lags2 :: Class.Real a => Ptr Bool -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lags2 = getLAGS2 $ Class.switchReal (LAGS2 S.lags2) (LAGS2 D.lags2)


newtype LAGTF a = LAGTF {getLAGTF :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

lagtf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lagtf = getLAGTF $ Class.switchReal (LAGTF S.lagtf) (LAGTF D.lagtf)


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

lagtm :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lagtm = getLAGTM $ Class.switchReal (LAGTM S.lagtm) (LAGTM D.lagtm)


newtype LAGTS a = LAGTS {getLAGTS :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lagts :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lagts = getLAGTS $ Class.switchReal (LAGTS S.lagts) (LAGTS D.lagts)


newtype LAGV2 a = LAGV2 {getLAGV2 :: Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lagv2 :: Class.Real a => Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lagv2 = getLAGV2 $ Class.switchReal (LAGV2 S.lagv2) (LAGV2 D.lagv2)


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

lahqr :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lahqr = getLAHQR $ Class.switchReal (LAHQR S.lahqr) (LAHQR D.lahqr)


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

lahr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lahr2 = getLAHR2 $ Class.switchReal (LAHR2 S.lahr2) (LAHR2 D.lahr2)


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

laic1 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
laic1 = getLAIC1 $ Class.switchReal (LAIC1 S.laic1) (LAIC1 D.laic1)


newtype LAISNAN a = LAISNAN {getLAISNAN :: Ptr a -> Ptr a -> IO Bool}

laisnan :: Class.Real a => Ptr a -> Ptr a -> IO Bool
laisnan = getLAISNAN $ Class.switchReal (LAISNAN S.laisnan) (LAISNAN D.laisnan)


newtype LALN2 a = LALN2 {getLALN2 :: Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laln2 :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laln2 = getLALN2 $ Class.switchReal (LALN2 S.laln2) (LALN2 D.laln2)


newtype LALS0 a = LALS0 {getLALS0 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr 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 S.lals0) (LALS0 D.lals0)


newtype LALSA a = LALSA {getLALSA :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr 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 S.lalsa) (LALSA D.lalsa)


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

lalsd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lalsd = getLALSD $ Class.switchReal (LALSD S.lalsd) (LALSD D.lalsd)


newtype LAMRG a = LAMRG {getLAMRG :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

lamrg :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
lamrg = getLAMRG $ Class.switchReal (LAMRG S.lamrg) (LAMRG D.lamrg)


newtype LANEG a = LANEG {getLANEG :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO CInt}

laneg :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO CInt
laneg = getLANEG $ Class.switchReal (LANEG S.laneg) (LANEG D.laneg)


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

langb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
langb = getLANGB $ Class.switchReal (LANGB S.langb) (LANGB D.langb)


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

lange :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lange = getLANGE $ Class.switchReal (LANGE S.lange) (LANGE D.lange)


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

langt :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> IO a
langt = getLANGT $ Class.switchReal (LANGT S.langt) (LANGT D.langt)


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

lanhs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lanhs = getLANHS $ Class.switchReal (LANHS S.lanhs) (LANHS D.lanhs)


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

lansb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lansb = getLANSB $ Class.switchReal (LANSB S.lansb) (LANSB D.lansb)


newtype LANSF a = LANSF {getLANSF :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a}

lansf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a
lansf = getLANSF $ Class.switchReal (LANSF S.lansf) (LANSF D.lansf)


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

lansp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a
lansp = getLANSP $ Class.switchReal (LANSP S.lansp) (LANSP D.lansp)


newtype LANST a = LANST {getLANST :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a}

lanst :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a
lanst = getLANST $ Class.switchReal (LANST S.lanst) (LANST D.lanst)


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

lansy :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lansy = getLANSY $ Class.switchReal (LANSY S.lansy) (LANSY D.lansy)


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

lantb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lantb = getLANTB $ Class.switchReal (LANTB S.lantb) (LANTB D.lantb)


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

lantp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> IO a
lantp = getLANTP $ Class.switchReal (LANTP S.lantp) (LANTP D.lantp)


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

lantr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO a
lantr = getLANTR $ Class.switchReal (LANTR S.lantr) (LANTR D.lantr)


newtype LANV2 a = LANV2 {getLANV2 :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lanv2 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lanv2 = getLANV2 $ Class.switchReal (LANV2 S.lanv2) (LANV2 D.lanv2)


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

lapll :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
lapll = getLAPLL $ Class.switchReal (LAPLL S.lapll) (LAPLL D.lapll)


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

lapmr :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lapmr = getLAPMR $ Class.switchReal (LAPMR S.lapmr) (LAPMR D.lapmr)


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

lapmt :: Class.Real a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lapmt = getLAPMT $ Class.switchReal (LAPMT S.lapmt) (LAPMT D.lapmt)


newtype LAPY2 a = LAPY2 {getLAPY2 :: Ptr a -> Ptr a -> IO a}

lapy2 :: Class.Real a => Ptr a -> Ptr a -> IO a
lapy2 = getLAPY2 $ Class.switchReal (LAPY2 S.lapy2) (LAPY2 D.lapy2)


newtype LAPY3 a = LAPY3 {getLAPY3 :: Ptr a -> Ptr a -> Ptr a -> IO a}

lapy3 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> IO a
lapy3 = getLAPY3 $ Class.switchReal (LAPY3 S.lapy3) (LAPY3 D.lapy3)


newtype LAQGB a = LAQGB {getLAQGB :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqgb = getLAQGB $ Class.switchReal (LAQGB S.laqgb) (LAQGB D.laqgb)


newtype LAQGE a = LAQGE {getLAQGE :: Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqge = getLAQGE $ Class.switchReal (LAQGE S.laqge) (LAQGE D.laqge)


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

laqp2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
laqp2 = getLAQP2 $ Class.switchReal (LAQP2 S.laqp2) (LAQP2 D.laqp2)


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

laqps :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laqps = getLAQPS $ Class.switchReal (LAQPS S.laqps) (LAQPS D.laqps)


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

laqr0 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laqr0 = getLAQR0 $ Class.switchReal (LAQR0 S.laqr0) (LAQR0 D.laqr0)


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

laqr1 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
laqr1 = getLAQR1 $ Class.switchReal (LAQR1 S.laqr1) (LAQR1 D.laqr1)


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

laqr2 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
laqr2 = getLAQR2 $ Class.switchReal (LAQR2 S.laqr2) (LAQR2 D.laqr2)


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

laqr3 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
laqr3 = getLAQR3 $ Class.switchReal (LAQR3 S.laqr3) (LAQR3 D.laqr3)


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

laqr4 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
laqr4 = getLAQR4 $ Class.switchReal (LAQR4 S.laqr4) (LAQR4 D.laqr4)


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

laqr5 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
laqr5 = getLAQR5 $ Class.switchReal (LAQR5 S.laqr5) (LAQR5 D.laqr5)


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

laqsb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsb = getLAQSB $ Class.switchReal (LAQSB S.laqsb) (LAQSB D.laqsb)


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

laqsp :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsp = getLAQSP $ Class.switchReal (LAQSP S.laqsp) (LAQSP D.laqsp)


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

laqsy :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CChar -> IO ()
laqsy = getLAQSY $ Class.switchReal (LAQSY S.laqsy) (LAQSY D.laqsy)


newtype LAQTR a = LAQTR {getLAQTR :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

laqtr :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laqtr = getLAQTR $ Class.switchReal (LAQTR S.laqtr) (LAQTR D.laqtr)


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 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 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 S.lar1v) (LAR1V D.lar1v)


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

lar2v :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lar2v = getLAR2V $ Class.switchReal (LAR2V S.lar2v) (LAR2V D.lar2v)


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

larf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larf = getLARF $ Class.switchReal (LARF S.larf) (LARF D.larf)


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

larfb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
larfb = getLARFB $ Class.switchReal (LARFB S.larfb) (LARFB D.larfb)


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

larfg :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfg = getLARFG $ Class.switchReal (LARFG S.larfg) (LARFG D.larfg)


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

larfgp :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfgp = getLARFGP $ Class.switchReal (LARFGP S.larfgp) (LARFGP D.larfgp)


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

larft :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larft = getLARFT $ Class.switchReal (LARFT S.larft) (LARFT D.larft)


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

larfx :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfx = getLARFX $ Class.switchReal (LARFX S.larfx) (LARFX D.larfx)


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

largv :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
largv = getLARGV $ Class.switchReal (LARGV S.largv) (LARGV D.largv)


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

larnv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> IO ()
larnv = getLARNV $ Class.switchReal (LARNV S.larnv) (LARNV D.larnv)


newtype LARRA a = LARRA {getLARRA :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

larra :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
larra = getLARRA $ Class.switchReal (LARRA S.larra) (LARRA D.larra)


newtype LARRB a = LARRB {getLARRB :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

larrb :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
larrb = getLARRB $ Class.switchReal (LARRB S.larrb) (LARRB D.larrb)


newtype LARRC a = LARRC {getLARRC :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

larrc :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
larrc = getLARRC $ Class.switchReal (LARRC S.larrc) (LARRC D.larrc)


newtype LARRD a = LARRD {getLARRD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

larrd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
larrd = getLARRD $ Class.switchReal (LARRD S.larrd) (LARRD D.larrd)


newtype LARRE a = LARRE {getLARRE :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

larre :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
larre = getLARRE $ Class.switchReal (LARRE S.larre) (LARRE D.larre)


newtype LARRF a = LARRF {getLARRF :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

larrf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larrf = getLARRF $ Class.switchReal (LARRF S.larrf) (LARRF D.larrf)


newtype LARRJ a = LARRJ {getLARRJ :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

larrj :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larrj = getLARRJ $ Class.switchReal (LARRJ S.larrj) (LARRJ D.larrj)


newtype LARRK a = LARRK {getLARRK :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

larrk :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larrk = getLARRK $ Class.switchReal (LARRK S.larrk) (LARRK D.larrk)


newtype LARRR a = LARRR {getLARRR :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

larrr :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larrr = getLARRR $ Class.switchReal (LARRR S.larrr) (LARRR D.larrr)


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 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 a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
larrv = getLARRV $ Class.switchReal (LARRV S.larrv) (LARRV D.larrv)


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

lartg :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lartg = getLARTG $ Class.switchReal (LARTG S.lartg) (LARTG D.lartg)


newtype LARTGP a = LARTGP {getLARTGP :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lartgp :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lartgp = getLARTGP $ Class.switchReal (LARTGP S.lartgp) (LARTGP D.lartgp)


newtype LARTGS a = LARTGS {getLARTGS :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lartgs :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lartgs = getLARTGS $ Class.switchReal (LARTGS S.lartgs) (LARTGS D.lartgs)


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

lartv :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lartv = getLARTV $ Class.switchReal (LARTV S.lartv) (LARTV D.lartv)


newtype LARUV a = LARUV {getLARUV :: Ptr CInt -> Ptr CInt -> Ptr a -> IO ()}

laruv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> IO ()
laruv = getLARUV $ Class.switchReal (LARUV S.laruv) (LARUV D.laruv)


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

larz :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larz = getLARZ $ Class.switchReal (LARZ S.larz) (LARZ D.larz)


newtype LARZB a = LARZB {getLARZB :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
larzb = getLARZB $ Class.switchReal (LARZB S.larzb) (LARZB D.larzb)


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

larzt :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larzt = getLARZT $ Class.switchReal (LARZT S.larzt) (LARZT D.larzt)


newtype LAS2 a = LAS2 {getLAS2 :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

las2 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
las2 = getLAS2 $ Class.switchReal (LAS2 S.las2) (LAS2 D.las2)


newtype LASCL a = LASCL {getLASCL :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr CInt -> IO ()
lascl = getLASCL $ Class.switchReal (LASCL S.lascl) (LASCL D.lascl)


newtype LASD0 a = LASD0 {getLASD0 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasd0 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasd0 = getLASD0 $ Class.switchReal (LASD0 S.lasd0) (LASD0 D.lasd0)


newtype LASD1 a = LASD1 {getLASD1 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasd1 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasd1 = getLASD1 $ Class.switchReal (LASD1 S.lasd1) (LASD1 D.lasd1)


newtype LASD2 a = LASD2 {getLASD2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

lasd2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
lasd2 = getLASD2 $ Class.switchReal (LASD2 S.lasd2) (LASD2 D.lasd2)


newtype LASD3 a = LASD3 {getLASD3 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasd3 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasd3 = getLASD3 $ Class.switchReal (LASD3 S.lasd3) (LASD3 D.lasd3)


newtype LASD4 a = LASD4 {getLASD4 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lasd4 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lasd4 = getLASD4 $ Class.switchReal (LASD4 S.lasd4) (LASD4 D.lasd4)


newtype LASD5 a = LASD5 {getLASD5 :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lasd5 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lasd5 = getLASD5 $ Class.switchReal (LASD5 S.lasd5) (LASD5 D.lasd5)


newtype LASD6 a = LASD6 {getLASD6 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr 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 -> Ptr CInt -> IO ()}

lasd6 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr 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 -> Ptr CInt -> IO ()
lasd6 = getLASD6 $ Class.switchReal (LASD6 S.lasd6) (LASD6 D.lasd6)


newtype LASD7 a = LASD7 {getLASD7 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lasd7 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lasd7 = getLASD7 $ Class.switchReal (LASD7 S.lasd7) (LASD7 D.lasd7)


newtype LASD8 a = LASD8 {getLASD8 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lasd8 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lasd8 = getLASD8 $ Class.switchReal (LASD8 S.lasd8) (LASD8 D.lasd8)


newtype LASDA a = LASDA {getLASDA :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> 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 ()}

lasda :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> 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 ()
lasda = getLASDA $ Class.switchReal (LASDA S.lasda) (LASDA D.lasda)


newtype LASDQ a = LASDQ {getLASDQ :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasdq :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasdq = getLASDQ $ Class.switchReal (LASDQ S.lasdq) (LASDQ D.lasdq)


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

laset :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laset = getLASET $ Class.switchReal (LASET S.laset) (LASET D.laset)


newtype LASQ1 a = LASQ1 {getLASQ1 :: Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

lasq1 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lasq1 = getLASQ1 $ Class.switchReal (LASQ1 S.lasq1) (LASQ1 D.lasq1)


newtype LASQ2 a = LASQ2 {getLASQ2 :: Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasq2 :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasq2 = getLASQ2 $ Class.switchReal (LASQ2 S.lasq2) (LASQ2 D.lasq2)


newtype LASQ4 a = LASQ4 {getLASQ4 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()}

lasq4 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
lasq4 = getLASQ4 $ Class.switchReal (LASQ4 S.lasq4) (LASQ4 D.lasq4)


newtype LASQ5 a = LASQ5 {getLASQ5 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr Bool -> Ptr a -> IO ()}

lasq5 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr Bool -> Ptr a -> IO ()
lasq5 = getLASQ5 $ Class.switchReal (LASQ5 S.lasq5) (LASQ5 D.lasq5)


newtype LASQ6 a = LASQ6 {getLASQ6 :: Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lasq6 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lasq6 = getLASQ6 $ Class.switchReal (LASQ6 S.lasq6) (LASQ6 D.lasq6)


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

lasr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
lasr = getLASR $ Class.switchReal (LASR S.lasr) (LASR D.lasr)


newtype LASRT a = LASRT {getLASRT :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasrt :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasrt = getLASRT $ Class.switchReal (LASRT S.lasrt) (LASRT D.lasrt)


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

lassq :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> IO ()
lassq = getLASSQ $ Class.switchReal (LASSQ S.lassq) (LASSQ D.lassq)


newtype LASV2 a = LASV2 {getLASV2 :: Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()}

lasv2 :: Class.Real a => Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> IO ()
lasv2 = getLASV2 $ Class.switchReal (LASV2 S.lasv2) (LASV2 D.lasv2)


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

laswp :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
laswp = getLASWP $ Class.switchReal (LASWP S.laswp) (LASWP D.laswp)


newtype LASY2 a = LASY2 {getLASY2 :: Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

lasy2 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lasy2 = getLASY2 $ Class.switchReal (LASY2 S.lasy2) (LASY2 D.lasy2)


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

lasyf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lasyf = getLASYF $ Class.switchReal (LASYF S.lasyf) (LASYF D.lasyf)


newtype LATBS a = LATBS {getLATBS :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latbs = getLATBS $ Class.switchReal (LATBS S.latbs) (LATBS D.latbs)


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

latdf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
latdf = getLATDF $ Class.switchReal (LATDF S.latdf) (LATDF D.latdf)


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

latps :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latps = getLATPS $ Class.switchReal (LATPS S.latps) (LATPS D.latps)


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

latrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latrd = getLATRD $ Class.switchReal (LATRD S.latrd) (LATRD D.latrd)


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

latrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
latrs = getLATRS $ Class.switchReal (LATRS S.latrs) (LATRS D.latrs)


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

latrz :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> IO ()
latrz = getLATRZ $ Class.switchReal (LATRZ S.latrz) (LATRZ D.latrz)


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

lauu2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lauu2 = getLAUU2 $ Class.switchReal (LAUU2 S.lauu2) (LAUU2 D.lauu2)


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

lauum :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lauum = getLAUUM $ Class.switchReal (LAUUM S.lauum) (LAUUM D.lauum)


newtype OPGTR a = OPGTR {getOPGTR :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

opgtr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
opgtr = getOPGTR $ Class.switchReal (OPGTR S.opgtr) (OPGTR D.opgtr)


newtype OPMTR a = OPMTR {getOPMTR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

opmtr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
opmtr = getOPMTR $ Class.switchReal (OPMTR S.opmtr) (OPMTR D.opmtr)


newtype ORBDB a = ORBDB {getORBDB :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orbdb :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orbdb = getORBDB $ Class.switchReal (ORBDB S.orbdb) (ORBDB D.orbdb)


newtype ORCSD a = ORCSD {getORCSD :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

orcsd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
orcsd = getORCSD $ Class.switchReal (ORCSD S.orcsd) (ORCSD D.orcsd)


newtype ORG2L a = ORG2L {getORG2L :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

org2l :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
org2l = getORG2L $ Class.switchReal (ORG2L S.org2l) (ORG2L D.org2l)


newtype ORG2R a = ORG2R {getORG2R :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

org2r :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
org2r = getORG2R $ Class.switchReal (ORG2R S.org2r) (ORG2R D.org2r)


newtype ORGBR a = ORGBR {getORGBR :: Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orgbr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orgbr = getORGBR $ Class.switchReal (ORGBR S.orgbr) (ORGBR D.orgbr)


newtype ORGHR a = ORGHR {getORGHR :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orghr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orghr = getORGHR $ Class.switchReal (ORGHR S.orghr) (ORGHR D.orghr)


newtype ORGL2 a = ORGL2 {getORGL2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

orgl2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
orgl2 = getORGL2 $ Class.switchReal (ORGL2 S.orgl2) (ORGL2 D.orgl2)


newtype ORGLQ a = ORGLQ {getORGLQ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orglq :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orglq = getORGLQ $ Class.switchReal (ORGLQ S.orglq) (ORGLQ D.orglq)


newtype ORGQL a = ORGQL {getORGQL :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orgql :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orgql = getORGQL $ Class.switchReal (ORGQL S.orgql) (ORGQL D.orgql)


newtype ORGQR a = ORGQR {getORGQR :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orgqr :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orgqr = getORGQR $ Class.switchReal (ORGQR S.orgqr) (ORGQR D.orgqr)


newtype ORGR2 a = ORGR2 {getORGR2 :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

orgr2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
orgr2 = getORGR2 $ Class.switchReal (ORGR2 S.orgr2) (ORGR2 D.orgr2)


newtype ORGRQ a = ORGRQ {getORGRQ :: Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orgrq :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orgrq = getORGRQ $ Class.switchReal (ORGRQ S.orgrq) (ORGRQ D.orgrq)


newtype ORGTR a = ORGTR {getORGTR :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

orgtr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
orgtr = getORGTR $ Class.switchReal (ORGTR S.orgtr) (ORGTR D.orgtr)


newtype ORM2L a = ORM2L {getORM2L :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

orm2l :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
orm2l = getORM2L $ Class.switchReal (ORM2L S.orm2l) (ORM2L D.orm2l)


newtype ORM2R a = ORM2R {getORM2R :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

orm2r :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
orm2r = getORM2R $ Class.switchReal (ORM2R S.orm2r) (ORM2R D.orm2r)


newtype ORMBR a = ORMBR {getORMBR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormbr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormbr = getORMBR $ Class.switchReal (ORMBR S.ormbr) (ORMBR D.ormbr)


newtype ORMHR a = ORMHR {getORMHR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormhr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormhr = getORMHR $ Class.switchReal (ORMHR S.ormhr) (ORMHR D.ormhr)


newtype ORML2 a = ORML2 {getORML2 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

orml2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
orml2 = getORML2 $ Class.switchReal (ORML2 S.orml2) (ORML2 D.orml2)


newtype ORMLQ a = ORMLQ {getORMLQ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormlq :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormlq = getORMLQ $ Class.switchReal (ORMLQ S.ormlq) (ORMLQ D.ormlq)


newtype ORMQL a = ORMQL {getORMQL :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormql :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormql = getORMQL $ Class.switchReal (ORMQL S.ormql) (ORMQL D.ormql)


newtype ORMQR a = ORMQR {getORMQR :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormqr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormqr = getORMQR $ Class.switchReal (ORMQR S.ormqr) (ORMQR D.ormqr)


newtype ORMR2 a = ORMR2 {getORMR2 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

ormr2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
ormr2 = getORMR2 $ Class.switchReal (ORMR2 S.ormr2) (ORMR2 D.ormr2)


newtype ORMR3 a = ORMR3 {getORMR3 :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

ormr3 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
ormr3 = getORMR3 $ Class.switchReal (ORMR3 S.ormr3) (ORMR3 D.ormr3)


newtype ORMRQ a = ORMRQ {getORMRQ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormrq :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormrq = getORMRQ $ Class.switchReal (ORMRQ S.ormrq) (ORMRQ D.ormrq)


newtype ORMRZ a = ORMRZ {getORMRZ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormrz :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormrz = getORMRZ $ Class.switchReal (ORMRZ S.ormrz) (ORMRZ D.ormrz)


newtype ORMTR a = ORMTR {getORMTR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

ormtr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ormtr = getORMTR $ Class.switchReal (ORMTR S.ormtr) (ORMTR D.ormtr)


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

pbcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbcon = getPBCON $ Class.switchReal (PBCON S.pbcon) (PBCON D.pbcon)


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

pbequ :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pbequ = getPBEQU $ Class.switchReal (PBEQU S.pbequ) (PBEQU D.pbequ)


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

pbrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbrfs = getPBRFS $ Class.switchReal (PBRFS S.pbrfs) (PBRFS D.pbrfs)


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

pbstf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbstf = getPBSTF $ Class.switchReal (PBSTF S.pbstf) (PBSTF D.pbstf)


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

pbsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbsv = getPBSV $ Class.switchReal (PBSV S.pbsv) (PBSV D.pbsv)


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

pbsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbsvx = getPBSVX $ Class.switchReal (PBSVX S.pbsvx) (PBSVX D.pbsvx)


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

pbtf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtf2 = getPBTF2 $ Class.switchReal (PBTF2 S.pbtf2) (PBTF2 D.pbtf2)


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

pbtrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtrf = getPBTRF $ Class.switchReal (PBTRF S.pbtrf) (PBTRF D.pbtrf)


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

pbtrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtrs = getPBTRS $ Class.switchReal (PBTRS S.pbtrs) (PBTRS D.pbtrs)


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

pftrf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pftrf = getPFTRF $ Class.switchReal (PFTRF S.pftrf) (PFTRF D.pftrf)


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

pftri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pftri = getPFTRI $ Class.switchReal (PFTRI S.pftri) (PFTRI D.pftri)


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

pftrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pftrs = getPFTRS $ Class.switchReal (PFTRS S.pftrs) (PFTRS D.pftrs)


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

pocon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pocon = getPOCON $ Class.switchReal (POCON S.pocon) (POCON D.pocon)


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

poequ :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
poequ = getPOEQU $ Class.switchReal (POEQU S.poequ) (POEQU D.poequ)


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

poequb :: Class.Real a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
poequb = getPOEQUB $ Class.switchReal (POEQUB S.poequb) (POEQUB D.poequb)


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

porfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
porfs = getPORFS $ Class.switchReal (PORFS S.porfs) (PORFS D.porfs)


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

posv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
posv = getPOSV $ Class.switchReal (POSV S.posv) (POSV D.posv)


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

posvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CChar -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
posvx = getPOSVX $ Class.switchReal (POSVX S.posvx) (POSVX D.posvx)


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

potf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potf2 = getPOTF2 $ Class.switchReal (POTF2 S.potf2) (POTF2 D.potf2)


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

potrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potrf = getPOTRF $ Class.switchReal (POTRF S.potrf) (POTRF D.potrf)


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

potri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potri = getPOTRI $ Class.switchReal (POTRI S.potri) (POTRI D.potri)


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

potrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potrs = getPOTRS $ Class.switchReal (POTRS S.potrs) (POTRS D.potrs)


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

ppcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ppcon = getPPCON $ Class.switchReal (PPCON S.ppcon) (PPCON D.ppcon)


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

ppequ :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ppequ = getPPEQU $ Class.switchReal (PPEQU S.ppequ) (PPEQU D.ppequ)


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

pprfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pprfs = getPPRFS $ Class.switchReal (PPRFS S.pprfs) (PPRFS D.pprfs)


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

ppsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ppsv = getPPSV $ Class.switchReal (PPSV S.ppsv) (PPSV D.ppsv)


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

ppsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CChar -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ppsvx = getPPSVX $ Class.switchReal (PPSVX S.ppsvx) (PPSVX D.ppsvx)


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

pptrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pptrf = getPPTRF $ Class.switchReal (PPTRF S.pptrf) (PPTRF D.pptrf)


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

pptri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pptri = getPPTRI $ Class.switchReal (PPTRI S.pptri) (PPTRI D.pptri)


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

pptrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pptrs = getPPTRS $ Class.switchReal (PPTRS S.pptrs) (PPTRS D.pptrs)


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

pstf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pstf2 = getPSTF2 $ Class.switchReal (PSTF2 S.pstf2) (PSTF2 D.pstf2)


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

pstrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pstrf = getPSTRF $ Class.switchReal (PSTRF S.pstrf) (PSTRF D.pstrf)


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

ptcon :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ptcon = getPTCON $ Class.switchReal (PTCON S.ptcon) (PTCON D.ptcon)


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

pteqr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pteqr = getPTEQR $ Class.switchReal (PTEQR S.pteqr) (PTEQR D.pteqr)


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

ptrfs :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ptrfs = getPTRFS $ Class.switchReal (PTRFS S.ptrfs) (PTRFS D.ptrfs)


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

ptsv :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ptsv = getPTSV $ Class.switchReal (PTSV S.ptsv) (PTSV D.ptsv)


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

ptsvx :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ptsvx = getPTSVX $ Class.switchReal (PTSVX S.ptsvx) (PTSVX D.ptsvx)


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

pttrf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
pttrf = getPTTRF $ Class.switchReal (PTTRF S.pttrf) (PTTRF D.pttrf)


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

pttrs :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pttrs = getPTTRS $ Class.switchReal (PTTRS S.pttrs) (PTTRS D.pttrs)


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

ptts2 :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ptts2 = getPTTS2 $ Class.switchReal (PTTS2 S.ptts2) (PTTS2 D.ptts2)


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

rscl :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
rscl = getRSCL $ Class.switchReal (RSCL S.rscl) (RSCL D.rscl)


newtype SBEV a = SBEV {getSBEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

sbev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sbev = getSBEV $ Class.switchReal (SBEV S.sbev) (SBEV D.sbev)


newtype SBEVD a = SBEVD {getSBEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sbevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sbevd = getSBEVD $ Class.switchReal (SBEVD S.sbevd) (SBEVD D.sbevd)


newtype SBEVX a = SBEVX {getSBEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sbevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sbevx = getSBEVX $ Class.switchReal (SBEVX S.sbevx) (SBEVX D.sbevx)


newtype SBGST a = SBGST {getSBGST :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

sbgst :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sbgst = getSBGST $ Class.switchReal (SBGST S.sbgst) (SBGST D.sbgst)


newtype SBGV a = SBGV {getSBGV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

sbgv :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sbgv = getSBGV $ Class.switchReal (SBGV S.sbgv) (SBGV D.sbgv)


newtype SBGVD a = SBGVD {getSBGVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sbgvd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sbgvd = getSBGVD $ Class.switchReal (SBGVD S.sbgvd) (SBGVD D.sbgvd)


newtype SBGVX a = SBGVX {getSBGVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sbgvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sbgvx = getSBGVX $ Class.switchReal (SBGVX S.sbgvx) (SBGVX D.sbgvx)


newtype SBTRD a = SBTRD {getSBTRD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

sbtrd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sbtrd = getSBTRD $ Class.switchReal (SBTRD S.sbtrd) (SBTRD D.sbtrd)


newtype SFRK a = SFRK {getSFRK :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> IO ()}

sfrk :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> IO ()
sfrk = getSFRK $ Class.switchReal (SFRK S.sfrk) (SFRK D.sfrk)


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

spcon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
spcon = getSPCON $ Class.switchReal (SPCON S.spcon) (SPCON D.spcon)


newtype SPEV a = SPEV {getSPEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

spev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
spev = getSPEV $ Class.switchReal (SPEV S.spev) (SPEV D.spev)


newtype SPEVD a = SPEVD {getSPEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

spevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
spevd = getSPEVD $ Class.switchReal (SPEVD S.spevd) (SPEVD D.spevd)


newtype SPEVX a = SPEVX {getSPEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

spevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
spevx = getSPEVX $ Class.switchReal (SPEVX S.spevx) (SPEVX D.spevx)


newtype SPGST a = SPGST {getSPGST :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

spgst :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
spgst = getSPGST $ Class.switchReal (SPGST S.spgst) (SPGST D.spgst)


newtype SPGV a = SPGV {getSPGV :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

spgv :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
spgv = getSPGV $ Class.switchReal (SPGV S.spgv) (SPGV D.spgv)


newtype SPGVD a = SPGVD {getSPGVD :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

spgvd :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
spgvd = getSPGVD $ Class.switchReal (SPGVD S.spgvd) (SPGVD D.spgvd)


newtype SPGVX a = SPGVX {getSPGVX :: Ptr CInt -> Ptr CChar -> 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

spgvx :: Class.Real a => Ptr CInt -> Ptr CChar -> 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
spgvx = getSPGVX $ Class.switchReal (SPGVX S.spgvx) (SPGVX D.spgvx)


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

sprfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sprfs = getSPRFS $ Class.switchReal (SPRFS S.sprfs) (SPRFS D.sprfs)


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

spsv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
spsv = getSPSV $ Class.switchReal (SPSV S.spsv) (SPSV D.spsv)


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

spsvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
spsvx = getSPSVX $ Class.switchReal (SPSVX S.spsvx) (SPSVX D.spsvx)


newtype SPTRD a = SPTRD {getSPTRD :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

sptrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
sptrd = getSPTRD $ Class.switchReal (SPTRD S.sptrd) (SPTRD D.sptrd)


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

sptrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sptrf = getSPTRF $ Class.switchReal (SPTRF S.sptrf) (SPTRF D.sptrf)


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

sptri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sptri = getSPTRI $ Class.switchReal (SPTRI S.sptri) (SPTRI D.sptri)


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

sptrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sptrs = getSPTRS $ Class.switchReal (SPTRS S.sptrs) (SPTRS D.sptrs)


newtype STEBZ a = STEBZ {getSTEBZ :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

stebz :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
stebz = getSTEBZ $ Class.switchReal (STEBZ S.stebz) (STEBZ D.stebz)


newtype STEDC a = STEDC {getSTEDC :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stedc = getSTEDC $ Class.switchReal (STEDC S.stedc) (STEDC D.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 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 a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stegr = getSTEGR $ Class.switchReal (STEGR S.stegr) (STEGR D.stegr)


newtype STEIN a = STEIN {getSTEIN :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stein = getSTEIN $ Class.switchReal (STEIN S.stein) (STEIN D.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 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 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 S.stemr) (STEMR D.stemr)


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

steqr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
steqr = getSTEQR $ Class.switchReal (STEQR S.steqr) (STEQR D.steqr)


newtype STERF a = STERF {getSTERF :: Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

sterf :: Class.Real a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
sterf = getSTERF $ Class.switchReal (STERF S.sterf) (STERF D.sterf)


newtype STEV a = STEV {getSTEV :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()}

stev :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
stev = getSTEV $ Class.switchReal (STEV S.stev) (STEV D.stev)


newtype STEVD a = STEVD {getSTEVD :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stevd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stevd = getSTEVD $ Class.switchReal (STEVD S.stevd) (STEVD D.stevd)


newtype STEVR a = STEVR {getSTEVR :: 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 a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stevr :: 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 a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stevr = getSTEVR $ Class.switchReal (STEVR S.stevr) (STEVR D.stevr)


newtype STEVX a = STEVX {getSTEVX :: 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

stevx :: 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
stevx = getSTEVX $ Class.switchReal (STEVX S.stevx) (STEVX D.stevx)


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

sycon :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sycon = getSYCON $ Class.switchReal (SYCON S.sycon) (SYCON D.sycon)


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

syconv :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
syconv = getSYCONV $ Class.switchReal (SYCONV S.syconv) (SYCONV D.syconv)


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

syequb :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
syequb = getSYEQUB $ Class.switchReal (SYEQUB S.syequb) (SYEQUB D.syequb)


newtype SYEV a = SYEV {getSYEV :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

syev :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
syev = getSYEV $ Class.switchReal (SYEV S.syev) (SYEV D.syev)


newtype SYEVD a = SYEVD {getSYEVD :: Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

syevd :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syevd = getSYEVD $ Class.switchReal (SYEVD S.syevd) (SYEVD D.syevd)


newtype SYEVR a = SYEVR {getSYEVR :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

syevr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syevr = getSYEVR $ Class.switchReal (SYEVR S.syevr) (SYEVR D.syevr)


newtype SYEVX a = SYEVX {getSYEVX :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

syevx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syevx = getSYEVX $ Class.switchReal (SYEVX S.syevx) (SYEVX D.syevx)


newtype SYGS2 a = SYGS2 {getSYGS2 :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

sygs2 :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sygs2 = getSYGS2 $ Class.switchReal (SYGS2 S.sygs2) (SYGS2 D.sygs2)


newtype SYGST a = SYGST {getSYGST :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

sygst :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sygst = getSYGST $ Class.switchReal (SYGST S.sygst) (SYGST D.sygst)


newtype SYGV a = SYGV {getSYGV :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

sygv :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sygv = getSYGV $ Class.switchReal (SYGV S.sygv) (SYGV D.sygv)


newtype SYGVD a = SYGVD {getSYGVD :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sygvd :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sygvd = getSYGVD $ Class.switchReal (SYGVD S.sygvd) (SYGVD D.sygvd)


newtype SYGVX a = SYGVX {getSYGVX :: Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()}

sygvx :: Class.Real a => Ptr CInt -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sygvx = getSYGVX $ Class.switchReal (SYGVX S.sygvx) (SYGVX D.sygvx)


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

syrfs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
syrfs = getSYRFS $ Class.switchReal (SYRFS S.syrfs) (SYRFS D.syrfs)


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

sysv :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sysv = getSYSV $ Class.switchReal (SYSV S.sysv) (SYSV D.sysv)


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

sysvx :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sysvx = getSYSVX $ Class.switchReal (SYSVX S.sysvx) (SYSVX D.sysvx)


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

syswapr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syswapr = getSYSWAPR $ Class.switchReal (SYSWAPR S.syswapr) (SYSWAPR D.syswapr)


newtype SYTD2 a = SYTD2 {getSYTD2 :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()}

sytd2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
sytd2 = getSYTD2 $ Class.switchReal (SYTD2 S.sytd2) (SYTD2 D.sytd2)


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

sytf2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sytf2 = getSYTF2 $ Class.switchReal (SYTF2 S.sytf2) (SYTF2 D.sytf2)


newtype SYTRD a = SYTRD {getSYTRD :: Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

sytrd :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytrd = getSYTRD $ Class.switchReal (SYTRD S.sytrd) (SYTRD D.sytrd)


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

sytrf :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytrf = getSYTRF $ Class.switchReal (SYTRF S.sytrf) (SYTRF D.sytrf)


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

sytri :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sytri = getSYTRI $ Class.switchReal (SYTRI S.sytri) (SYTRI D.sytri)


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

sytri2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytri2 = getSYTRI2 $ Class.switchReal (SYTRI2 S.sytri2) (SYTRI2 D.sytri2)


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

sytri2x :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytri2x = getSYTRI2X $ Class.switchReal (SYTRI2X S.sytri2x) (SYTRI2X D.sytri2x)


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

sytrs :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytrs = getSYTRS $ Class.switchReal (SYTRS S.sytrs) (SYTRS D.sytrs)


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

sytrs2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sytrs2 = getSYTRS2 $ Class.switchReal (SYTRS2 S.sytrs2) (SYTRS2 D.sytrs2)


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

tbcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tbcon = getTBCON $ Class.switchReal (TBCON S.tbcon) (TBCON D.tbcon)


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

tbrfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tbrfs = getTBRFS $ Class.switchReal (TBRFS S.tbrfs) (TBRFS D.tbrfs)


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

tbtrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tbtrs = getTBTRS $ Class.switchReal (TBTRS S.tbtrs) (TBTRS D.tbtrs)


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

tfsm :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tfsm = getTFSM $ Class.switchReal (TFSM S.tfsm) (TFSM D.tfsm)


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

tftri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
tftri = getTFTRI $ Class.switchReal (TFTRI S.tftri) (TFTRI D.tftri)


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

tfttp :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tfttp = getTFTTP $ Class.switchReal (TFTTP S.tfttp) (TFTTP D.tfttp)


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

tfttr :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tfttr = getTFTTR $ Class.switchReal (TFTTR S.tfttr) (TFTTR D.tfttr)


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

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


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

tgex2 :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tgex2 = getTGEX2 $ Class.switchReal (TGEX2 S.tgex2) (TGEX2 D.tgex2)


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

tgexc :: Class.Real a => Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tgexc = getTGEXC $ Class.switchReal (TGEXC S.tgexc) (TGEXC D.tgexc)


newtype TGSEN a = TGSEN {getTGSEN :: Ptr CInt -> Ptr Bool -> Ptr Bool -> Ptr Bool -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsen = getTGSEN $ Class.switchReal (TGSEN S.tgsen) (TGSEN D.tgsen)


newtype TGSJA a = TGSJA {getTGSJA :: Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr 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 a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tgsja = getTGSJA $ Class.switchReal (TGSJA S.tgsja) (TGSJA D.tgsja)


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

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


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

tgsy2 :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsy2 = getTGSY2 $ Class.switchReal (TGSY2 S.tgsy2) (TGSY2 D.tgsy2)


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

tgsyl :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
tgsyl = getTGSYL $ Class.switchReal (TGSYL S.tgsyl) (TGSYL D.tgsyl)


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

tpcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tpcon = getTPCON $ Class.switchReal (TPCON S.tpcon) (TPCON D.tpcon)


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

tprfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tprfs = getTPRFS $ Class.switchReal (TPRFS S.tprfs) (TPRFS D.tprfs)


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

tptri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
tptri = getTPTRI $ Class.switchReal (TPTRI S.tptri) (TPTRI D.tptri)


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

tptrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tptrs = getTPTRS $ Class.switchReal (TPTRS S.tptrs) (TPTRS D.tptrs)


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

tpttf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tpttf = getTPTTF $ Class.switchReal (TPTTF S.tpttf) (TPTTF D.tpttf)


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

tpttr :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tpttr = getTPTTR $ Class.switchReal (TPTTR S.tpttr) (TPTTR D.tpttr)


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

trcon :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trcon = getTRCON $ Class.switchReal (TRCON S.trcon) (TRCON D.trcon)


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

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


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

trexc :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trexc = getTREXC $ Class.switchReal (TREXC S.trexc) (TREXC D.trexc)


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

trrfs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trrfs = getTRRFS $ Class.switchReal (TRRFS S.trrfs) (TRRFS D.trrfs)


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

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


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

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


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

trsyl :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trsyl = getTRSYL $ Class.switchReal (TRSYL S.trsyl) (TRSYL D.trsyl)


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

trti2 :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trti2 = getTRTI2 $ Class.switchReal (TRTI2 S.trti2) (TRTI2 D.trti2)


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

trtri :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trtri = getTRTRI $ Class.switchReal (TRTRI S.trtri) (TRTRI D.trtri)


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

trtrs :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trtrs = getTRTRS $ Class.switchReal (TRTRS S.trtrs) (TRTRS D.trtrs)


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

trttf :: Class.Real a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trttf = getTRTTF $ Class.switchReal (TRTTF S.trttf) (TRTTF D.trttf)


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

trttp :: Class.Real a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trttp = getTRTTP $ Class.switchReal (TRTTP S.trttp) (TRTTP D.trttp)


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

tzrzf :: Class.Real a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tzrzf = getTZRZF $ Class.switchReal (TZRZF S.tzrzf) (TZRZF D.tzrzf)