-- Do not edit! Automatically generated by create-lapack-ffi.
module Numeric.LAPACK.FFI.Generic (
   gbsv,
   gbtf2,
   gbtrf,
   gbtrs,
   gehd2,
   gehrd,
   gelq2,
   gelqf,
   gels,
   geql2,
   geqlf,
   geqr2,
   geqr2p,
   geqrf,
   geqrfp,
   gerq2,
   gerqf,
   gesv,
   getc2,
   getf2,
   getrf,
   getri,
   getrs,
   ggglm,
   gghrd,
   gglse,
   ggqrf,
   ggrqf,
   gtsv,
   gttrf,
   gttrs,
   gtts2,
   ilalc,
   ilalr,
   lacpy,
   lahr2,
   lapmr,
   lapmt,
   larf,
   larfb,
   larfg,
   larfgp,
   larft,
   larfx,
   larnv,
   larz,
   larzb,
   larzt,
   laset,
   laswp,
   lasyf,
   latrz,
   lauu2,
   lauum,
   pbstf,
   pbsv,
   pbtf2,
   pbtrf,
   pbtrs,
   pftrf,
   pftri,
   pftrs,
   posv,
   potf2,
   potrf,
   potri,
   potrs,
   ppsv,
   pptrf,
   pptri,
   pptrs,
   spsv,
   sptrf,
   sptri,
   sptrs,
   syconv,
   sysv,
   syswapr,
   sytf2,
   sytrf,
   sytri,
   sytri2,
   sytri2x,
   sytrs,
   sytrs2,
   tbtrs,
   tfsm,
   tftri,
   tfttp,
   tfttr,
   tptri,
   tptrs,
   tpttf,
   tpttr,
   trti2,
   trtri,
   trtrs,
   trttf,
   trttp,
   tzrzf,
   ) where

import qualified Numeric.LAPACK.FFI.ComplexFloat as C
import qualified Numeric.LAPACK.FFI.ComplexDouble as Z
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 (Ptr)
import Foreign.C.Types



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.Floating 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.switchFloating (GBSV S.gbsv) (GBSV D.gbsv) (GBSV C.gbsv) (GBSV Z.gbsv)


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

gbtf2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtf2 = getGBTF2 $ Class.switchFloating (GBTF2 S.gbtf2) (GBTF2 D.gbtf2) (GBTF2 C.gbtf2) (GBTF2 Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
gbtrf = getGBTRF $ Class.switchFloating (GBTRF S.gbtrf) (GBTRF D.gbtrf) (GBTRF C.gbtrf) (GBTRF Z.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.Floating 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.switchFloating (GBTRS S.gbtrs) (GBTRS D.gbtrs) (GBTRS C.gbtrs) (GBTRS Z.gbtrs)


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

gehd2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gehd2 = getGEHD2 $ Class.switchFloating (GEHD2 S.gehd2) (GEHD2 D.gehd2) (GEHD2 C.gehd2) (GEHD2 Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gehrd = getGEHRD $ Class.switchFloating (GEHRD S.gehrd) (GEHRD D.gehrd) (GEHRD C.gehrd) (GEHRD Z.gehrd)


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

gelq2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gelq2 = getGELQ2 $ Class.switchFloating (GELQ2 S.gelq2) (GELQ2 D.gelq2) (GELQ2 C.gelq2) (GELQ2 Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gelqf = getGELQF $ Class.switchFloating (GELQF S.gelqf) (GELQF D.gelqf) (GELQF C.gelqf) (GELQF Z.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.Floating 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.switchFloating (GELS S.gels) (GELS D.gels) (GELS C.gels) (GELS Z.gels)


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

geql2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geql2 = getGEQL2 $ Class.switchFloating (GEQL2 S.geql2) (GEQL2 D.geql2) (GEQL2 C.geql2) (GEQL2 Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqlf = getGEQLF $ Class.switchFloating (GEQLF S.geqlf) (GEQLF D.geqlf) (GEQLF C.geqlf) (GEQLF Z.geqlf)


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

geqr2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geqr2 = getGEQR2 $ Class.switchFloating (GEQR2 S.geqr2) (GEQR2 D.geqr2) (GEQR2 C.geqr2) (GEQR2 Z.geqr2)


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

geqr2p :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
geqr2p = getGEQR2P $ Class.switchFloating (GEQR2P S.geqr2p) (GEQR2P D.geqr2p) (GEQR2P C.geqr2p) (GEQR2P Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqrf = getGEQRF $ Class.switchFloating (GEQRF S.geqrf) (GEQRF D.geqrf) (GEQRF C.geqrf) (GEQRF Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
geqrfp = getGEQRFP $ Class.switchFloating (GEQRFP S.geqrfp) (GEQRFP D.geqrfp) (GEQRFP C.geqrfp) (GEQRFP Z.geqrfp)


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

gerq2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
gerq2 = getGERQ2 $ Class.switchFloating (GERQ2 S.gerq2) (GERQ2 D.gerq2) (GERQ2 C.gerq2) (GERQ2 Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gerqf = getGERQF $ Class.switchFloating (GERQF S.gerqf) (GERQF D.gerqf) (GERQF C.gerqf) (GERQF Z.gerqf)


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

gesv :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gesv = getGESV $ Class.switchFloating (GESV S.gesv) (GESV D.gesv) (GESV C.gesv) (GESV Z.gesv)


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

getc2 :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getc2 = getGETC2 $ Class.switchFloating (GETC2 S.getc2) (GETC2 D.getc2) (GETC2 C.getc2) (GETC2 Z.getc2)


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

getf2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getf2 = getGETF2 $ Class.switchFloating (GETF2 S.getf2) (GETF2 D.getf2) (GETF2 C.getf2) (GETF2 Z.getf2)


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

getrf :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
getrf = getGETRF $ Class.switchFloating (GETRF S.getrf) (GETRF D.getrf) (GETRF C.getrf) (GETRF Z.getrf)


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

getri :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
getri = getGETRI $ Class.switchFloating (GETRI S.getri) (GETRI D.getri) (GETRI C.getri) (GETRI Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
getrs = getGETRS $ Class.switchFloating (GETRS S.getrs) (GETRS D.getrs) (GETRS C.getrs) (GETRS Z.getrs)


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.Floating 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.switchFloating (GGGLM S.ggglm) (GGGLM D.ggglm) (GGGLM C.ggglm) (GGGLM Z.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.Floating 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.switchFloating (GGHRD S.gghrd) (GGHRD D.gghrd) (GGHRD C.gghrd) (GGHRD Z.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.Floating 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.switchFloating (GGLSE S.gglse) (GGLSE D.gglse) (GGLSE C.gglse) (GGLSE Z.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.Floating 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.switchFloating (GGQRF S.ggqrf) (GGQRF D.ggqrf) (GGQRF C.ggqrf) (GGQRF Z.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.Floating 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.switchFloating (GGRQF S.ggrqf) (GGRQF D.ggrqf) (GGRQF C.ggrqf) (GGRQF Z.ggrqf)


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

gtsv :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gtsv = getGTSV $ Class.switchFloating (GTSV S.gtsv) (GTSV D.gtsv) (GTSV C.gtsv) (GTSV Z.gtsv)


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

gttrf :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
gttrf = getGTTRF $ Class.switchFloating (GTTRF S.gttrf) (GTTRF D.gttrf) (GTTRF C.gttrf) (GTTRF Z.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.Floating 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.switchFloating (GTTRS S.gttrs) (GTTRS D.gttrs) (GTTRS C.gttrs) (GTTRS Z.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.Floating 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.switchFloating (GTTS2 S.gtts2) (GTTS2 D.gtts2) (GTTS2 C.gtts2) (GTTS2 Z.gtts2)


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

ilalc :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO CInt
ilalc = getILALC $ Class.switchFloating (ILALC S.ilalc) (ILALC D.ilalc) (ILALC C.ilalc) (ILALC Z.ilalc)


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

ilalr :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO CInt
ilalr = getILALR $ Class.switchFloating (ILALR S.ilalr) (ILALR D.ilalr) (ILALR C.ilalr) (ILALR Z.ilalr)


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

lacpy :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
lacpy = getLACPY $ Class.switchFloating (LACPY S.lacpy) (LACPY D.lacpy) (LACPY C.lacpy) (LACPY Z.lacpy)


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.Floating 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.switchFloating (LAHR2 S.lahr2) (LAHR2 D.lahr2) (LAHR2 C.lahr2) (LAHR2 Z.lahr2)


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

lapmr :: Class.Floating a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lapmr = getLAPMR $ Class.switchFloating (LAPMR S.lapmr) (LAPMR D.lapmr) (LAPMR C.lapmr) (LAPMR Z.lapmr)


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

lapmt :: Class.Floating a => Ptr Bool -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lapmt = getLAPMT $ Class.switchFloating (LAPMT S.lapmt) (LAPMT D.lapmt) (LAPMT C.lapmt) (LAPMT Z.lapmt)


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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larf = getLARF $ Class.switchFloating (LARF S.larf) (LARF D.larf) (LARF C.larf) (LARF Z.larf)


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

larfb :: Class.Floating 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.switchFloating (LARFB S.larfb) (LARFB D.larfb) (LARFB C.larfb) (LARFB Z.larfb)


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

larfg :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfg = getLARFG $ Class.switchFloating (LARFG S.larfg) (LARFG D.larfg) (LARFG C.larfg) (LARFG Z.larfg)


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

larfgp :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfgp = getLARFGP $ Class.switchFloating (LARFGP S.larfgp) (LARFGP D.larfgp) (LARFGP C.larfgp) (LARFGP Z.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.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larft = getLARFT $ Class.switchFloating (LARFT S.larft) (LARFT D.larft) (LARFT C.larft) (LARFT Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> IO ()
larfx = getLARFX $ Class.switchFloating (LARFX S.larfx) (LARFX D.larfx) (LARFX C.larfx) (LARFX Z.larfx)


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

larnv :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> IO ()
larnv = getLARNV $ Class.switchFloating (LARNV S.larnv) (LARNV D.larnv) (LARNV C.larnv) (LARNV Z.larnv)


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.Floating 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.switchFloating (LARZ S.larz) (LARZ D.larz) (LARZ C.larz) (LARZ Z.larz)


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

larzb :: Class.Floating 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.switchFloating (LARZB S.larzb) (LARZB D.larzb) (LARZB C.larzb) (LARZB Z.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.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
larzt = getLARZT $ Class.switchFloating (LARZT S.larzt) (LARZT D.larzt) (LARZT C.larzt) (LARZT Z.larzt)


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

laset :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
laset = getLASET $ Class.switchFloating (LASET S.laset) (LASET D.laset) (LASET C.laset) (LASET Z.laset)


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

laswp :: Class.Floating a => Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
laswp = getLASWP $ Class.switchFloating (LASWP S.laswp) (LASWP D.laswp) (LASWP C.laswp) (LASWP Z.laswp)


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.Floating 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.switchFloating (LASYF S.lasyf) (LASYF D.lasyf) (LASYF C.lasyf) (LASYF Z.lasyf)


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

latrz :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> IO ()
latrz = getLATRZ $ Class.switchFloating (LATRZ S.latrz) (LATRZ D.latrz) (LATRZ C.latrz) (LATRZ Z.latrz)


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

lauu2 :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lauu2 = getLAUU2 $ Class.switchFloating (LAUU2 S.lauu2) (LAUU2 D.lauu2) (LAUU2 C.lauu2) (LAUU2 Z.lauu2)


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

lauum :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
lauum = getLAUUM $ Class.switchFloating (LAUUM S.lauum) (LAUUM D.lauum) (LAUUM C.lauum) (LAUUM Z.lauum)


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

pbstf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbstf = getPBSTF $ Class.switchFloating (PBSTF S.pbstf) (PBSTF D.pbstf) (PBSTF C.pbstf) (PBSTF Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbsv = getPBSV $ Class.switchFloating (PBSV S.pbsv) (PBSV D.pbsv) (PBSV C.pbsv) (PBSV Z.pbsv)


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

pbtf2 :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtf2 = getPBTF2 $ Class.switchFloating (PBTF2 S.pbtf2) (PBTF2 D.pbtf2) (PBTF2 C.pbtf2) (PBTF2 Z.pbtf2)


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

pbtrf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtrf = getPBTRF $ Class.switchFloating (PBTRF S.pbtrf) (PBTRF D.pbtrf) (PBTRF C.pbtrf) (PBTRF Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pbtrs = getPBTRS $ Class.switchFloating (PBTRS S.pbtrs) (PBTRS D.pbtrs) (PBTRS C.pbtrs) (PBTRS Z.pbtrs)


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

pftrf :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pftrf = getPFTRF $ Class.switchFloating (PFTRF S.pftrf) (PFTRF D.pftrf) (PFTRF C.pftrf) (PFTRF Z.pftrf)


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

pftri :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pftri = getPFTRI $ Class.switchFloating (PFTRI S.pftri) (PFTRI D.pftri) (PFTRI C.pftri) (PFTRI Z.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.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pftrs = getPFTRS $ Class.switchFloating (PFTRS S.pftrs) (PFTRS D.pftrs) (PFTRS C.pftrs) (PFTRS Z.pftrs)


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

posv :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
posv = getPOSV $ Class.switchFloating (POSV S.posv) (POSV D.posv) (POSV C.posv) (POSV Z.posv)


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

potf2 :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potf2 = getPOTF2 $ Class.switchFloating (POTF2 S.potf2) (POTF2 D.potf2) (POTF2 C.potf2) (POTF2 Z.potf2)


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

potrf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potrf = getPOTRF $ Class.switchFloating (POTRF S.potrf) (POTRF D.potrf) (POTRF C.potrf) (POTRF Z.potrf)


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

potri :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potri = getPOTRI $ Class.switchFloating (POTRI S.potri) (POTRI D.potri) (POTRI C.potri) (POTRI Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
potrs = getPOTRS $ Class.switchFloating (POTRS S.potrs) (POTRS D.potrs) (POTRS C.potrs) (POTRS Z.potrs)


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

ppsv :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ppsv = getPPSV $ Class.switchFloating (PPSV S.ppsv) (PPSV D.ppsv) (PPSV C.ppsv) (PPSV Z.ppsv)


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

pptrf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pptrf = getPPTRF $ Class.switchFloating (PPTRF S.pptrf) (PPTRF D.pptrf) (PPTRF C.pptrf) (PPTRF Z.pptrf)


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

pptri :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
pptri = getPPTRI $ Class.switchFloating (PPTRI S.pptri) (PPTRI D.pptri) (PPTRI C.pptri) (PPTRI Z.pptri)


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

pptrs :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
pptrs = getPPTRS $ Class.switchFloating (PPTRS S.pptrs) (PPTRS D.pptrs) (PPTRS C.pptrs) (PPTRS Z.pptrs)


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

spsv :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
spsv = getSPSV $ Class.switchFloating (SPSV S.spsv) (SPSV D.spsv) (SPSV C.spsv) (SPSV Z.spsv)


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

sptrf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sptrf = getSPTRF $ Class.switchFloating (SPTRF S.sptrf) (SPTRF D.sptrf) (SPTRF C.sptrf) (SPTRF Z.sptrf)


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

sptri :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sptri = getSPTRI $ Class.switchFloating (SPTRI S.sptri) (SPTRI D.sptri) (SPTRI C.sptri) (SPTRI Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sptrs = getSPTRS $ Class.switchFloating (SPTRS S.sptrs) (SPTRS D.sptrs) (SPTRS C.sptrs) (SPTRS Z.sptrs)


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

syconv :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
syconv = getSYCONV $ Class.switchFloating (SYCONV S.syconv) (SYCONV D.syconv) (SYCONV C.syconv) (SYCONV Z.syconv)


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.Floating 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.switchFloating (SYSV S.sysv) (SYSV D.sysv) (SYSV C.sysv) (SYSV Z.sysv)


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

syswapr :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
syswapr = getSYSWAPR $ Class.switchFloating (SYSWAPR S.syswapr) (SYSWAPR D.syswapr) (SYSWAPR C.syswapr) (SYSWAPR Z.syswapr)


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

sytf2 :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
sytf2 = getSYTF2 $ Class.switchFloating (SYTF2 S.sytf2) (SYTF2 D.sytf2) (SYTF2 C.sytf2) (SYTF2 Z.sytf2)


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

sytrf :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytrf = getSYTRF $ Class.switchFloating (SYTRF S.sytrf) (SYTRF D.sytrf) (SYTRF C.sytrf) (SYTRF Z.sytrf)


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

sytri :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
sytri = getSYTRI $ Class.switchFloating (SYTRI S.sytri) (SYTRI D.sytri) (SYTRI C.sytri) (SYTRI Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytri2 = getSYTRI2 $ Class.switchFloating (SYTRI2 S.sytri2) (SYTRI2 D.sytri2) (SYTRI2 C.sytri2) (SYTRI2 Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytri2x = getSYTRI2X $ Class.switchFloating (SYTRI2X S.sytri2x) (SYTRI2X D.sytri2x) (SYTRI2X C.sytri2x) (SYTRI2X Z.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.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
sytrs = getSYTRS $ Class.switchFloating (SYTRS S.sytrs) (SYTRS D.sytrs) (SYTRS C.sytrs) (SYTRS Z.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.Floating 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.switchFloating (SYTRS2 S.sytrs2) (SYTRS2 D.sytrs2) (SYTRS2 C.sytrs2) (SYTRS2 Z.sytrs2)


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.Floating 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.switchFloating (TBTRS S.tbtrs) (TBTRS D.tbtrs) (TBTRS C.tbtrs) (TBTRS Z.tbtrs)


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

tfsm :: Class.Floating 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.switchFloating (TFSM S.tfsm) (TFSM D.tfsm) (TFSM C.tfsm) (TFSM Z.tfsm)


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

tftri :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
tftri = getTFTRI $ Class.switchFloating (TFTRI S.tftri) (TFTRI D.tftri) (TFTRI C.tftri) (TFTRI Z.tftri)


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

tfttp :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tfttp = getTFTTP $ Class.switchFloating (TFTTP S.tfttp) (TFTTP D.tfttp) (TFTTP C.tfttp) (TFTTP Z.tfttp)


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

tfttr :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tfttr = getTFTTR $ Class.switchFloating (TFTTR S.tfttr) (TFTTR D.tfttr) (TFTTR C.tfttr) (TFTTR Z.tfttr)


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

tptri :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
tptri = getTPTRI $ Class.switchFloating (TPTRI S.tptri) (TPTRI D.tptri) (TPTRI C.tptri) (TPTRI Z.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.Floating a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tptrs = getTPTRS $ Class.switchFloating (TPTRS S.tptrs) (TPTRS D.tptrs) (TPTRS C.tptrs) (TPTRS Z.tptrs)


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

tpttf :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
tpttf = getTPTTF $ Class.switchFloating (TPTTF S.tpttf) (TPTTF D.tpttf) (TPTTF C.tpttf) (TPTTF Z.tpttf)


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

tpttr :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tpttr = getTPTTR $ Class.switchFloating (TPTTR S.tpttr) (TPTTR D.tpttr) (TPTTR C.tpttr) (TPTTR Z.tpttr)


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

trti2 :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trti2 = getTRTI2 $ Class.switchFloating (TRTI2 S.trti2) (TRTI2 D.trti2) (TRTI2 C.trti2) (TRTI2 Z.trti2)


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

trtri :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
trtri = getTRTRI $ Class.switchFloating (TRTRI S.trtri) (TRTRI D.trtri) (TRTRI C.trtri) (TRTRI Z.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.Floating 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.switchFloating (TRTRS S.trtrs) (TRTRS D.trtrs) (TRTRS C.trtrs) (TRTRS Z.trtrs)


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

trttf :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trttf = getTRTTF $ Class.switchFloating (TRTTF S.trttf) (TRTTF D.trttf) (TRTTF C.trttf) (TRTTF Z.trttf)


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

trttp :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
trttp = getTRTTP $ Class.switchFloating (TRTTP S.trttp) (TRTTP D.trttp) (TRTTP C.trttp) (TRTTP Z.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.Floating a => Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
tzrzf = getTZRZF $ Class.switchFloating (TZRZF S.tzrzf) (TZRZF D.tzrzf) (TZRZF C.tzrzf) (TZRZF Z.tzrzf)
