-- 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,
   hegs2,
   hegst,
   hpgst,
   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,
   ung2l,
   ung2r,
   ungbr,
   unghr,
   ungl2,
   unglq,
   ungql,
   ungqr,
   ungr2,
   ungrq,
   ungtr,
   unm2l,
   unm2r,
   unmbr,
   unmhr,
   unml2,
   unmlq,
   unmql,
   unmqr,
   unmr2,
   unmr3,
   unmrq,
   unmrz,
   unmtr,
   upgtr,
   upmtr,
   ) where

import qualified Numeric.LAPACK.FFI.ComplexFloat as C
import qualified Numeric.LAPACK.FFI.ComplexDouble as Z
import qualified Numeric.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 HEGS2 a = HEGS2 {getHEGS2 :: Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()}

hegs2 :: Class.Floating a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
hegs2 = getHEGS2 $ Class.switchFloating (HEGS2 S.sygs2) (HEGS2 D.sygs2) (HEGS2 C.hegs2) (HEGS2 Z.hegs2)


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

hegst :: Class.Floating a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
hegst = getHEGST $ Class.switchFloating (HEGST S.sygst) (HEGST D.sygst) (HEGST C.hegst) (HEGST Z.hegst)


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

hpgst :: Class.Floating a => Ptr CInt -> Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
hpgst = getHPGST $ Class.switchFloating (HPGST S.spgst) (HPGST D.spgst) (HPGST C.hpgst) (HPGST Z.hpgst)


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)


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

ung2l :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ung2l = getUNG2L $ Class.switchFloating (UNG2L S.org2l) (UNG2L D.org2l) (UNG2L C.ung2l) (UNG2L Z.ung2l)


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

ung2r :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ung2r = getUNG2R $ Class.switchFloating (UNG2R S.org2r) (UNG2R D.org2r) (UNG2R C.ung2r) (UNG2R Z.ung2r)


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

ungbr :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ungbr = getUNGBR $ Class.switchFloating (UNGBR S.orgbr) (UNGBR D.orgbr) (UNGBR C.ungbr) (UNGBR Z.ungbr)


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

unghr :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
unghr = getUNGHR $ Class.switchFloating (UNGHR S.orghr) (UNGHR D.orghr) (UNGHR C.unghr) (UNGHR Z.unghr)


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

ungl2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ungl2 = getUNGL2 $ Class.switchFloating (UNGL2 S.orgl2) (UNGL2 D.orgl2) (UNGL2 C.ungl2) (UNGL2 Z.ungl2)


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

unglq :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
unglq = getUNGLQ $ Class.switchFloating (UNGLQ S.orglq) (UNGLQ D.orglq) (UNGLQ C.unglq) (UNGLQ Z.unglq)


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

ungql :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ungql = getUNGQL $ Class.switchFloating (UNGQL S.orgql) (UNGQL D.orgql) (UNGQL C.ungql) (UNGQL Z.ungql)


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

ungqr :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ungqr = getUNGQR $ Class.switchFloating (UNGQR S.orgqr) (UNGQR D.orgqr) (UNGQR C.ungqr) (UNGQR Z.ungqr)


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

ungr2 :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> IO ()
ungr2 = getUNGR2 $ Class.switchFloating (UNGR2 S.orgr2) (UNGR2 D.orgr2) (UNGR2 C.ungr2) (UNGR2 Z.ungr2)


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

ungrq :: Class.Floating a => Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ungrq = getUNGRQ $ Class.switchFloating (UNGRQ S.orgrq) (UNGRQ D.orgrq) (UNGRQ C.ungrq) (UNGRQ Z.ungrq)


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

ungtr :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr CInt -> Ptr a -> Ptr a -> Ptr CInt -> Ptr CInt -> IO ()
ungtr = getUNGTR $ Class.switchFloating (UNGTR S.orgtr) (UNGTR D.orgtr) (UNGTR C.ungtr) (UNGTR Z.ungtr)


newtype UNM2L a = UNM2L {getUNM2L :: 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 ()}

unm2l :: Class.Floating 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 ()
unm2l = getUNM2L $ Class.switchFloating (UNM2L S.orm2l) (UNM2L D.orm2l) (UNM2L C.unm2l) (UNM2L Z.unm2l)


newtype UNM2R a = UNM2R {getUNM2R :: 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 ()}

unm2r :: Class.Floating 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 ()
unm2r = getUNM2R $ Class.switchFloating (UNM2R S.orm2r) (UNM2R D.orm2r) (UNM2R C.unm2r) (UNM2R Z.unm2r)


newtype UNMBR a = UNMBR {getUNMBR :: 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 ()}

unmbr :: Class.Floating 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 ()
unmbr = getUNMBR $ Class.switchFloating (UNMBR S.ormbr) (UNMBR D.ormbr) (UNMBR C.unmbr) (UNMBR Z.unmbr)


newtype UNMHR a = UNMHR {getUNMHR :: 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 ()}

unmhr :: Class.Floating 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 ()
unmhr = getUNMHR $ Class.switchFloating (UNMHR S.ormhr) (UNMHR D.ormhr) (UNMHR C.unmhr) (UNMHR Z.unmhr)


newtype UNML2 a = UNML2 {getUNML2 :: 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 ()}

unml2 :: Class.Floating 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 ()
unml2 = getUNML2 $ Class.switchFloating (UNML2 S.orml2) (UNML2 D.orml2) (UNML2 C.unml2) (UNML2 Z.unml2)


newtype UNMLQ a = UNMLQ {getUNMLQ :: 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 ()}

unmlq :: Class.Floating 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 ()
unmlq = getUNMLQ $ Class.switchFloating (UNMLQ S.ormlq) (UNMLQ D.ormlq) (UNMLQ C.unmlq) (UNMLQ Z.unmlq)


newtype UNMQL a = UNMQL {getUNMQL :: 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 ()}

unmql :: Class.Floating 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 ()
unmql = getUNMQL $ Class.switchFloating (UNMQL S.ormql) (UNMQL D.ormql) (UNMQL C.unmql) (UNMQL Z.unmql)


newtype UNMQR a = UNMQR {getUNMQR :: 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 ()}

unmqr :: Class.Floating 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 ()
unmqr = getUNMQR $ Class.switchFloating (UNMQR S.ormqr) (UNMQR D.ormqr) (UNMQR C.unmqr) (UNMQR Z.unmqr)


newtype UNMR2 a = UNMR2 {getUNMR2 :: 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 ()}

unmr2 :: Class.Floating 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 ()
unmr2 = getUNMR2 $ Class.switchFloating (UNMR2 S.ormr2) (UNMR2 D.ormr2) (UNMR2 C.unmr2) (UNMR2 Z.unmr2)


newtype UNMR3 a = UNMR3 {getUNMR3 :: 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 ()}

unmr3 :: Class.Floating 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 ()
unmr3 = getUNMR3 $ Class.switchFloating (UNMR3 S.ormr3) (UNMR3 D.ormr3) (UNMR3 C.unmr3) (UNMR3 Z.unmr3)


newtype UNMRQ a = UNMRQ {getUNMRQ :: 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 ()}

unmrq :: Class.Floating 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 ()
unmrq = getUNMRQ $ Class.switchFloating (UNMRQ S.ormrq) (UNMRQ D.ormrq) (UNMRQ C.unmrq) (UNMRQ Z.unmrq)


newtype UNMRZ a = UNMRZ {getUNMRZ :: 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 ()}

unmrz :: Class.Floating 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 ()
unmrz = getUNMRZ $ Class.switchFloating (UNMRZ S.ormrz) (UNMRZ D.ormrz) (UNMRZ C.unmrz) (UNMRZ Z.unmrz)


newtype UNMTR a = UNMTR {getUNMTR :: 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 ()}

unmtr :: Class.Floating 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 ()
unmtr = getUNMTR $ Class.switchFloating (UNMTR S.ormtr) (UNMTR D.ormtr) (UNMTR C.unmtr) (UNMTR Z.unmtr)


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

upgtr :: Class.Floating a => Ptr CChar -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
upgtr = getUPGTR $ Class.switchFloating (UPGTR S.opgtr) (UPGTR D.opgtr) (UPGTR C.upgtr) (UPGTR Z.upgtr)


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

upmtr :: Class.Floating a => Ptr CChar -> Ptr CChar -> Ptr CChar -> Ptr CInt -> Ptr CInt -> Ptr a -> Ptr a -> Ptr a -> Ptr CInt -> Ptr a -> Ptr CInt -> IO ()
upmtr = getUPMTR $ Class.switchFloating (UPMTR S.opmtr) (UPMTR D.opmtr) (UPMTR C.upmtr) (UPMTR Z.upmtr)