29 files changed, 488 insertions, 478 deletions

diff --git a/hmatrix.cabal b/hmatrix.cabal
index 3d58fa2..4f10e34 100644
--- a/hmatrix.cabal
+++ b/hmatrix.cabal
@@ -1,5 +1,5 @@
 Name:               hmatrix
-Version:            0.8.3.1
+Version:            0.8.3.2
 License:            GPL
 License-file:       LICENSE
 Author:             Alberto Ruiz
@@ -56,6 +56,11 @@ flag unsafe
     description:    Compile the library with bound checking disabled.
     default:        False
 
+flag safe-cheap
+    description:    use slower non-blocking "safe" foreign calls
+                    to GSL special functions.
+    default:        False
+
 library
 
     Build-Depends:      base >= 3 && < 5,
@@ -143,6 +148,11 @@ library
     if flag(unsafe)
         cpp-options: -DUNSAFE
 
+    if flag(safe-cheap)
+        cpp-options: -DSAFE_CHEAP=safe
+    else
+        cpp-options: -DSAFE_CHEAP=unsafe
+
     if impl(ghc < 6.10.2)
         cpp-options: -DFINIT
 
diff --git a/lib/Numeric/GSL/Special/Airy.hs b/lib/Numeric/GSL/Special/Airy.hs
index 2f20c6f..8a04eed 100644
--- a/lib/Numeric/GSL/Special/Airy.hs
+++ b/lib/Numeric/GSL/Special/Airy.hs
@@ -46,96 +46,96 @@ import Numeric.GSL.Special.Internal
 
 airy_Ai_e :: Double -> Precision -> (Double,Double)
 airy_Ai_e x mode = createSFR "airy_Ai_e" $ gsl_sf_airy_Ai_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_e" gsl_sf_airy_Ai_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Ai :: Double -> Precision -> Double
 airy_Ai x mode = gsl_sf_airy_Ai x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai" gsl_sf_airy_Ai :: Double -> Gsl_mode_t -> Double
 
 airy_Bi_e :: Double -> Precision -> (Double,Double)
 airy_Bi_e x mode = createSFR "airy_Bi_e" $ gsl_sf_airy_Bi_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_e" gsl_sf_airy_Bi_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Bi :: Double -> Precision -> Double
 airy_Bi x mode = gsl_sf_airy_Bi x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi" gsl_sf_airy_Bi :: Double -> Gsl_mode_t -> Double
 
 airy_Ai_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Ai_scaled_e x mode = createSFR "airy_Ai_scaled_e" $ gsl_sf_airy_Ai_scaled_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_scaled_e" gsl_sf_airy_Ai_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Ai_scaled :: Double -> Precision -> Double
 airy_Ai_scaled x mode = gsl_sf_airy_Ai_scaled x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_scaled" gsl_sf_airy_Ai_scaled :: Double -> Gsl_mode_t -> Double
 
 airy_Bi_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Bi_scaled_e x mode = createSFR "airy_Bi_scaled_e" $ gsl_sf_airy_Bi_scaled_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_scaled_e" gsl_sf_airy_Bi_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Bi_scaled :: Double -> Precision -> Double
 airy_Bi_scaled x mode = gsl_sf_airy_Bi_scaled x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_scaled" gsl_sf_airy_Bi_scaled :: Double -> Gsl_mode_t -> Double
 
 airy_Ai_deriv_e :: Double -> Precision -> (Double,Double)
 airy_Ai_deriv_e x mode = createSFR "airy_Ai_deriv_e" $ gsl_sf_airy_Ai_deriv_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_deriv_e" gsl_sf_airy_Ai_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Ai_deriv :: Double -> Precision -> Double
 airy_Ai_deriv x mode = gsl_sf_airy_Ai_deriv x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_deriv" gsl_sf_airy_Ai_deriv :: Double -> Gsl_mode_t -> Double
 
 airy_Bi_deriv_e :: Double -> Precision -> (Double,Double)
 airy_Bi_deriv_e x mode = createSFR "airy_Bi_deriv_e" $ gsl_sf_airy_Bi_deriv_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_deriv_e" gsl_sf_airy_Bi_deriv_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Bi_deriv :: Double -> Precision -> Double
 airy_Bi_deriv x mode = gsl_sf_airy_Bi_deriv x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_deriv" gsl_sf_airy_Bi_deriv :: Double -> Gsl_mode_t -> Double
 
 airy_Ai_deriv_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Ai_deriv_scaled_e x mode = createSFR "airy_Ai_deriv_scaled_e" $ gsl_sf_airy_Ai_deriv_scaled_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_deriv_scaled_e" gsl_sf_airy_Ai_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Ai_deriv_scaled :: Double -> Precision -> Double
 airy_Ai_deriv_scaled x mode = gsl_sf_airy_Ai_deriv_scaled x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Ai_deriv_scaled" gsl_sf_airy_Ai_deriv_scaled :: Double -> Gsl_mode_t -> Double
 
 airy_Bi_deriv_scaled_e :: Double -> Precision -> (Double,Double)
 airy_Bi_deriv_scaled_e x mode = createSFR "airy_Bi_deriv_scaled_e" $ gsl_sf_airy_Bi_deriv_scaled_e x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_deriv_scaled_e" gsl_sf_airy_Bi_deriv_scaled_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 airy_Bi_deriv_scaled :: Double -> Precision -> Double
 airy_Bi_deriv_scaled x mode = gsl_sf_airy_Bi_deriv_scaled x  (precCode mode)
-foreign import ccall "gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_Bi_deriv_scaled" gsl_sf_airy_Bi_deriv_scaled :: Double -> Gsl_mode_t -> Double
 
 airy_zero_Ai_e :: CInt -> (Double,Double)
 airy_zero_Ai_e s = createSFR "airy_zero_Ai_e" $ gsl_sf_airy_zero_Ai_e s
-foreign import ccall "gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai_e" gsl_sf_airy_zero_Ai_e :: CInt -> Ptr () -> IO CInt
 
 airy_zero_Ai :: CInt -> Double
 airy_zero_Ai = gsl_sf_airy_zero_Ai
-foreign import ccall "gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai" gsl_sf_airy_zero_Ai :: CInt -> Double
 
 airy_zero_Bi_e :: CInt -> (Double,Double)
 airy_zero_Bi_e s = createSFR "airy_zero_Bi_e" $ gsl_sf_airy_zero_Bi_e s
-foreign import ccall "gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi_e" gsl_sf_airy_zero_Bi_e :: CInt -> Ptr () -> IO CInt
 
 airy_zero_Bi :: CInt -> Double
 airy_zero_Bi = gsl_sf_airy_zero_Bi
-foreign import ccall "gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi" gsl_sf_airy_zero_Bi :: CInt -> Double
 
 airy_zero_Ai_deriv_e :: CInt -> (Double,Double)
 airy_zero_Ai_deriv_e s = createSFR "airy_zero_Ai_deriv_e" $ gsl_sf_airy_zero_Ai_deriv_e s
-foreign import ccall "gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai_deriv_e" gsl_sf_airy_zero_Ai_deriv_e :: CInt -> Ptr () -> IO CInt
 
 airy_zero_Ai_deriv :: CInt -> Double
 airy_zero_Ai_deriv = gsl_sf_airy_zero_Ai_deriv
-foreign import ccall "gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Ai_deriv" gsl_sf_airy_zero_Ai_deriv :: CInt -> Double
 
 airy_zero_Bi_deriv_e :: CInt -> (Double,Double)
 airy_zero_Bi_deriv_e s = createSFR "airy_zero_Bi_deriv_e" $ gsl_sf_airy_zero_Bi_deriv_e s
-foreign import ccall "gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi_deriv_e" gsl_sf_airy_zero_Bi_deriv_e :: CInt -> Ptr () -> IO CInt
 
 airy_zero_Bi_deriv :: CInt -> Double
 airy_zero_Bi_deriv = gsl_sf_airy_zero_Bi_deriv
-foreign import ccall "gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_airy_zero_Bi_deriv" gsl_sf_airy_zero_Bi_deriv :: CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Bessel.hs b/lib/Numeric/GSL/Special/Bessel.hs
index 187da2d..66d6c5b 100644
--- a/lib/Numeric/GSL/Special/Bessel.hs
+++ b/lib/Numeric/GSL/Special/Bessel.hs
@@ -109,400 +109,400 @@ import Numeric.GSL.Special.Internal
 
 bessel_J0_e :: Double -> (Double,Double)
 bessel_J0_e x = createSFR "bessel_J0_e" $ gsl_sf_bessel_J0_e x
-foreign import ccall "gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J0_e" gsl_sf_bessel_J0_e :: Double -> Ptr () -> IO CInt
 
 bessel_J0 :: Double -> Double
 bessel_J0 = gsl_sf_bessel_J0
-foreign import ccall "gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J0" gsl_sf_bessel_J0 :: Double -> Double
 
 bessel_J1_e :: Double -> (Double,Double)
 bessel_J1_e x = createSFR "bessel_J1_e" $ gsl_sf_bessel_J1_e x
-foreign import ccall "gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J1_e" gsl_sf_bessel_J1_e :: Double -> Ptr () -> IO CInt
 
 bessel_J1 :: Double -> Double
 bessel_J1 = gsl_sf_bessel_J1
-foreign import ccall "gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_J1" gsl_sf_bessel_J1 :: Double -> Double
 
 bessel_Jn_e :: CInt -> Double -> (Double,Double)
 bessel_Jn_e n x = createSFR "bessel_Jn_e" $ gsl_sf_bessel_Jn_e n x
-foreign import ccall "gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn_e" gsl_sf_bessel_Jn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_Jn :: CInt -> Double -> Double
 bessel_Jn = gsl_sf_bessel_Jn
-foreign import ccall "gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn" gsl_sf_bessel_Jn :: CInt -> Double -> Double
 
 bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Jn_array = gsl_sf_bessel_Jn_array
-foreign import ccall "gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jn_array" gsl_sf_bessel_Jn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_Y0_e :: Double -> (Double,Double)
 bessel_Y0_e x = createSFR "bessel_Y0_e" $ gsl_sf_bessel_Y0_e x
-foreign import ccall "gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y0_e" gsl_sf_bessel_Y0_e :: Double -> Ptr () -> IO CInt
 
 bessel_Y0 :: Double -> Double
 bessel_Y0 = gsl_sf_bessel_Y0
-foreign import ccall "gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y0" gsl_sf_bessel_Y0 :: Double -> Double
 
 bessel_Y1_e :: Double -> (Double,Double)
 bessel_Y1_e x = createSFR "bessel_Y1_e" $ gsl_sf_bessel_Y1_e x
-foreign import ccall "gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y1_e" gsl_sf_bessel_Y1_e :: Double -> Ptr () -> IO CInt
 
 bessel_Y1 :: Double -> Double
 bessel_Y1 = gsl_sf_bessel_Y1
-foreign import ccall "gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Y1" gsl_sf_bessel_Y1 :: Double -> Double
 
 bessel_Yn_e :: CInt -> Double -> (Double,Double)
 bessel_Yn_e n x = createSFR "bessel_Yn_e" $ gsl_sf_bessel_Yn_e n x
-foreign import ccall "gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn_e" gsl_sf_bessel_Yn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_Yn :: CInt -> Double -> Double
 bessel_Yn = gsl_sf_bessel_Yn
-foreign import ccall "gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn" gsl_sf_bessel_Yn :: CInt -> Double -> Double
 
 bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Yn_array = gsl_sf_bessel_Yn_array
-foreign import ccall "gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Yn_array" gsl_sf_bessel_Yn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_I0_e :: Double -> (Double,Double)
 bessel_I0_e x = createSFR "bessel_I0_e" $ gsl_sf_bessel_I0_e x
-foreign import ccall "gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0_e" gsl_sf_bessel_I0_e :: Double -> Ptr () -> IO CInt
 
 bessel_I0 :: Double -> Double
 bessel_I0 = gsl_sf_bessel_I0
-foreign import ccall "gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0" gsl_sf_bessel_I0 :: Double -> Double
 
 bessel_I1_e :: Double -> (Double,Double)
 bessel_I1_e x = createSFR "bessel_I1_e" $ gsl_sf_bessel_I1_e x
-foreign import ccall "gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1_e" gsl_sf_bessel_I1_e :: Double -> Ptr () -> IO CInt
 
 bessel_I1 :: Double -> Double
 bessel_I1 = gsl_sf_bessel_I1
-foreign import ccall "gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1" gsl_sf_bessel_I1 :: Double -> Double
 
 bessel_In_e :: CInt -> Double -> (Double,Double)
 bessel_In_e n x = createSFR "bessel_In_e" $ gsl_sf_bessel_In_e n x
-foreign import ccall "gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_e" gsl_sf_bessel_In_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_In :: CInt -> Double -> Double
 bessel_In = gsl_sf_bessel_In
-foreign import ccall "gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In" gsl_sf_bessel_In :: CInt -> Double -> Double
 
 bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_In_array = gsl_sf_bessel_In_array
-foreign import ccall "gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_array" gsl_sf_bessel_In_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_I0_scaled_e :: Double -> (Double,Double)
 bessel_I0_scaled_e x = createSFR "bessel_I0_scaled_e" $ gsl_sf_bessel_I0_scaled_e x
-foreign import ccall "gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0_scaled_e" gsl_sf_bessel_I0_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_I0_scaled :: Double -> Double
 bessel_I0_scaled = gsl_sf_bessel_I0_scaled
-foreign import ccall "gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I0_scaled" gsl_sf_bessel_I0_scaled :: Double -> Double
 
 bessel_I1_scaled_e :: Double -> (Double,Double)
 bessel_I1_scaled_e x = createSFR "bessel_I1_scaled_e" $ gsl_sf_bessel_I1_scaled_e x
-foreign import ccall "gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1_scaled_e" gsl_sf_bessel_I1_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_I1_scaled :: Double -> Double
 bessel_I1_scaled = gsl_sf_bessel_I1_scaled
-foreign import ccall "gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_I1_scaled" gsl_sf_bessel_I1_scaled :: Double -> Double
 
 bessel_In_scaled_e :: CInt -> Double -> (Double,Double)
 bessel_In_scaled_e n x = createSFR "bessel_In_scaled_e" $ gsl_sf_bessel_In_scaled_e n x
-foreign import ccall "gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_scaled_e" gsl_sf_bessel_In_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_In_scaled :: CInt -> Double -> Double
 bessel_In_scaled = gsl_sf_bessel_In_scaled
-foreign import ccall "gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_scaled" gsl_sf_bessel_In_scaled :: CInt -> Double -> Double
 
 bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_In_scaled_array = gsl_sf_bessel_In_scaled_array
-foreign import ccall "gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_In_scaled_array" gsl_sf_bessel_In_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_K0_e :: Double -> (Double,Double)
 bessel_K0_e x = createSFR "bessel_K0_e" $ gsl_sf_bessel_K0_e x
-foreign import ccall "gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0_e" gsl_sf_bessel_K0_e :: Double -> Ptr () -> IO CInt
 
 bessel_K0 :: Double -> Double
 bessel_K0 = gsl_sf_bessel_K0
-foreign import ccall "gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0" gsl_sf_bessel_K0 :: Double -> Double
 
 bessel_K1_e :: Double -> (Double,Double)
 bessel_K1_e x = createSFR "bessel_K1_e" $ gsl_sf_bessel_K1_e x
-foreign import ccall "gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1_e" gsl_sf_bessel_K1_e :: Double -> Ptr () -> IO CInt
 
 bessel_K1 :: Double -> Double
 bessel_K1 = gsl_sf_bessel_K1
-foreign import ccall "gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1" gsl_sf_bessel_K1 :: Double -> Double
 
 bessel_Kn_e :: CInt -> Double -> (Double,Double)
 bessel_Kn_e n x = createSFR "bessel_Kn_e" $ gsl_sf_bessel_Kn_e n x
-foreign import ccall "gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_e" gsl_sf_bessel_Kn_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_Kn :: CInt -> Double -> Double
 bessel_Kn = gsl_sf_bessel_Kn
-foreign import ccall "gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn" gsl_sf_bessel_Kn :: CInt -> Double -> Double
 
 bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Kn_array = gsl_sf_bessel_Kn_array
-foreign import ccall "gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_array" gsl_sf_bessel_Kn_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_K0_scaled_e :: Double -> (Double,Double)
 bessel_K0_scaled_e x = createSFR "bessel_K0_scaled_e" $ gsl_sf_bessel_K0_scaled_e x
-foreign import ccall "gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0_scaled_e" gsl_sf_bessel_K0_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_K0_scaled :: Double -> Double
 bessel_K0_scaled = gsl_sf_bessel_K0_scaled
-foreign import ccall "gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K0_scaled" gsl_sf_bessel_K0_scaled :: Double -> Double
 
 bessel_K1_scaled_e :: Double -> (Double,Double)
 bessel_K1_scaled_e x = createSFR "bessel_K1_scaled_e" $ gsl_sf_bessel_K1_scaled_e x
-foreign import ccall "gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1_scaled_e" gsl_sf_bessel_K1_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_K1_scaled :: Double -> Double
 bessel_K1_scaled = gsl_sf_bessel_K1_scaled
-foreign import ccall "gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_K1_scaled" gsl_sf_bessel_K1_scaled :: Double -> Double
 
 bessel_Kn_scaled_e :: CInt -> Double -> (Double,Double)
 bessel_Kn_scaled_e n x = createSFR "bessel_Kn_scaled_e" $ gsl_sf_bessel_Kn_scaled_e n x
-foreign import ccall "gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_scaled_e" gsl_sf_bessel_Kn_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_Kn_scaled :: CInt -> Double -> Double
 bessel_Kn_scaled = gsl_sf_bessel_Kn_scaled
-foreign import ccall "gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_scaled" gsl_sf_bessel_Kn_scaled :: CInt -> Double -> Double
 
 bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 bessel_Kn_scaled_array = gsl_sf_bessel_Kn_scaled_array
-foreign import ccall "gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Kn_scaled_array" gsl_sf_bessel_Kn_scaled_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 bessel_j0_e :: Double -> (Double,Double)
 bessel_j0_e x = createSFR "bessel_j0_e" $ gsl_sf_bessel_j0_e x
-foreign import ccall "gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j0_e" gsl_sf_bessel_j0_e :: Double -> Ptr () -> IO CInt
 
 bessel_j0 :: Double -> Double
 bessel_j0 = gsl_sf_bessel_j0
-foreign import ccall "gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j0" gsl_sf_bessel_j0 :: Double -> Double
 
 bessel_j1_e :: Double -> (Double,Double)
 bessel_j1_e x = createSFR "bessel_j1_e" $ gsl_sf_bessel_j1_e x
-foreign import ccall "gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j1_e" gsl_sf_bessel_j1_e :: Double -> Ptr () -> IO CInt
 
 bessel_j1 :: Double -> Double
 bessel_j1 = gsl_sf_bessel_j1
-foreign import ccall "gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j1" gsl_sf_bessel_j1 :: Double -> Double
 
 bessel_j2_e :: Double -> (Double,Double)
 bessel_j2_e x = createSFR "bessel_j2_e" $ gsl_sf_bessel_j2_e x
-foreign import ccall "gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j2_e" gsl_sf_bessel_j2_e :: Double -> Ptr () -> IO CInt
 
 bessel_j2 :: Double -> Double
 bessel_j2 = gsl_sf_bessel_j2
-foreign import ccall "gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_j2" gsl_sf_bessel_j2 :: Double -> Double
 
 bessel_jl_e :: CInt -> Double -> (Double,Double)
 bessel_jl_e l x = createSFR "bessel_jl_e" $ gsl_sf_bessel_jl_e l x
-foreign import ccall "gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_e" gsl_sf_bessel_jl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_jl :: CInt -> Double -> Double
 bessel_jl = gsl_sf_bessel_jl
-foreign import ccall "gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl" gsl_sf_bessel_jl :: CInt -> Double -> Double
 
 bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_jl_array = gsl_sf_bessel_jl_array
-foreign import ccall "gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_array" gsl_sf_bessel_jl_array :: CInt -> Double -> Ptr Double -> CInt
 
 bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_jl_steed_array = gsl_sf_bessel_jl_steed_array
-foreign import ccall "gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_jl_steed_array" gsl_sf_bessel_jl_steed_array :: CInt -> Double -> Ptr Double -> CInt
 
 bessel_y0_e :: Double -> (Double,Double)
 bessel_y0_e x = createSFR "bessel_y0_e" $ gsl_sf_bessel_y0_e x
-foreign import ccall "gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y0_e" gsl_sf_bessel_y0_e :: Double -> Ptr () -> IO CInt
 
 bessel_y0 :: Double -> Double
 bessel_y0 = gsl_sf_bessel_y0
-foreign import ccall "gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y0" gsl_sf_bessel_y0 :: Double -> Double
 
 bessel_y1_e :: Double -> (Double,Double)
 bessel_y1_e x = createSFR "bessel_y1_e" $ gsl_sf_bessel_y1_e x
-foreign import ccall "gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y1_e" gsl_sf_bessel_y1_e :: Double -> Ptr () -> IO CInt
 
 bessel_y1 :: Double -> Double
 bessel_y1 = gsl_sf_bessel_y1
-foreign import ccall "gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y1" gsl_sf_bessel_y1 :: Double -> Double
 
 bessel_y2_e :: Double -> (Double,Double)
 bessel_y2_e x = createSFR "bessel_y2_e" $ gsl_sf_bessel_y2_e x
-foreign import ccall "gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y2_e" gsl_sf_bessel_y2_e :: Double -> Ptr () -> IO CInt
 
 bessel_y2 :: Double -> Double
 bessel_y2 = gsl_sf_bessel_y2
-foreign import ccall "gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_y2" gsl_sf_bessel_y2 :: Double -> Double
 
 bessel_yl_e :: CInt -> Double -> (Double,Double)
 bessel_yl_e l x = createSFR "bessel_yl_e" $ gsl_sf_bessel_yl_e l x
-foreign import ccall "gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl_e" gsl_sf_bessel_yl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_yl :: CInt -> Double -> Double
 bessel_yl = gsl_sf_bessel_yl
-foreign import ccall "gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl" gsl_sf_bessel_yl :: CInt -> Double -> Double
 
 bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_yl_array = gsl_sf_bessel_yl_array
-foreign import ccall "gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_yl_array" gsl_sf_bessel_yl_array :: CInt -> Double -> Ptr Double -> CInt
 
 bessel_i0_scaled_e :: Double -> (Double,Double)
 bessel_i0_scaled_e x = createSFR "bessel_i0_scaled_e" $ gsl_sf_bessel_i0_scaled_e x
-foreign import ccall "gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i0_scaled_e" gsl_sf_bessel_i0_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_i0_scaled :: Double -> Double
 bessel_i0_scaled = gsl_sf_bessel_i0_scaled
-foreign import ccall "gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i0_scaled" gsl_sf_bessel_i0_scaled :: Double -> Double
 
 bessel_i1_scaled_e :: Double -> (Double,Double)
 bessel_i1_scaled_e x = createSFR "bessel_i1_scaled_e" $ gsl_sf_bessel_i1_scaled_e x
-foreign import ccall "gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i1_scaled_e" gsl_sf_bessel_i1_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_i1_scaled :: Double -> Double
 bessel_i1_scaled = gsl_sf_bessel_i1_scaled
-foreign import ccall "gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i1_scaled" gsl_sf_bessel_i1_scaled :: Double -> Double
 
 bessel_i2_scaled_e :: Double -> (Double,Double)
 bessel_i2_scaled_e x = createSFR "bessel_i2_scaled_e" $ gsl_sf_bessel_i2_scaled_e x
-foreign import ccall "gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i2_scaled_e" gsl_sf_bessel_i2_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_i2_scaled :: Double -> Double
 bessel_i2_scaled = gsl_sf_bessel_i2_scaled
-foreign import ccall "gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_i2_scaled" gsl_sf_bessel_i2_scaled :: Double -> Double
 
 bessel_il_scaled_e :: CInt -> Double -> (Double,Double)
 bessel_il_scaled_e l x = createSFR "bessel_il_scaled_e" $ gsl_sf_bessel_il_scaled_e l x
-foreign import ccall "gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_il_scaled_e" gsl_sf_bessel_il_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_il_scaled :: CInt -> Double -> Double
 bessel_il_scaled = gsl_sf_bessel_il_scaled
-foreign import ccall "gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_il_scaled" gsl_sf_bessel_il_scaled :: CInt -> Double -> Double
 
 bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_il_scaled_array = gsl_sf_bessel_il_scaled_array
-foreign import ccall "gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_il_scaled_array" gsl_sf_bessel_il_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 
 bessel_k0_scaled_e :: Double -> (Double,Double)
 bessel_k0_scaled_e x = createSFR "bessel_k0_scaled_e" $ gsl_sf_bessel_k0_scaled_e x
-foreign import ccall "gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k0_scaled_e" gsl_sf_bessel_k0_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_k0_scaled :: Double -> Double
 bessel_k0_scaled = gsl_sf_bessel_k0_scaled
-foreign import ccall "gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k0_scaled" gsl_sf_bessel_k0_scaled :: Double -> Double
 
 bessel_k1_scaled_e :: Double -> (Double,Double)
 bessel_k1_scaled_e x = createSFR "bessel_k1_scaled_e" $ gsl_sf_bessel_k1_scaled_e x
-foreign import ccall "gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k1_scaled_e" gsl_sf_bessel_k1_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_k1_scaled :: Double -> Double
 bessel_k1_scaled = gsl_sf_bessel_k1_scaled
-foreign import ccall "gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k1_scaled" gsl_sf_bessel_k1_scaled :: Double -> Double
 
 bessel_k2_scaled_e :: Double -> (Double,Double)
 bessel_k2_scaled_e x = createSFR "bessel_k2_scaled_e" $ gsl_sf_bessel_k2_scaled_e x
-foreign import ccall "gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k2_scaled_e" gsl_sf_bessel_k2_scaled_e :: Double -> Ptr () -> IO CInt
 
 bessel_k2_scaled :: Double -> Double
 bessel_k2_scaled = gsl_sf_bessel_k2_scaled
-foreign import ccall "gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_k2_scaled" gsl_sf_bessel_k2_scaled :: Double -> Double
 
 bessel_kl_scaled_e :: CInt -> Double -> (Double,Double)
 bessel_kl_scaled_e l x = createSFR "bessel_kl_scaled_e" $ gsl_sf_bessel_kl_scaled_e l x
-foreign import ccall "gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_kl_scaled_e" gsl_sf_bessel_kl_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 bessel_kl_scaled :: CInt -> Double -> Double
 bessel_kl_scaled = gsl_sf_bessel_kl_scaled
-foreign import ccall "gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_kl_scaled" gsl_sf_bessel_kl_scaled :: CInt -> Double -> Double
 
 bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 bessel_kl_scaled_array = gsl_sf_bessel_kl_scaled_array
-foreign import ccall "gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_kl_scaled_array" gsl_sf_bessel_kl_scaled_array :: CInt -> Double -> Ptr Double -> CInt
 
 bessel_Jnu_e :: Double -> Double -> (Double,Double)
 bessel_Jnu_e nu x = createSFR "bessel_Jnu_e" $ gsl_sf_bessel_Jnu_e nu x
-foreign import ccall "gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jnu_e" gsl_sf_bessel_Jnu_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Jnu :: Double -> Double -> Double
 bessel_Jnu = gsl_sf_bessel_Jnu
-foreign import ccall "gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Jnu" gsl_sf_bessel_Jnu :: Double -> Double -> Double
 
 bessel_Ynu_e :: Double -> Double -> (Double,Double)
 bessel_Ynu_e nu x = createSFR "bessel_Ynu_e" $ gsl_sf_bessel_Ynu_e nu x
-foreign import ccall "gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Ynu_e" gsl_sf_bessel_Ynu_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Ynu :: Double -> Double -> Double
 bessel_Ynu = gsl_sf_bessel_Ynu
-foreign import ccall "gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Ynu" gsl_sf_bessel_Ynu :: Double -> Double -> Double
 
 bessel_sequence_Jnu_e :: Double -> Precision -> Size_t -> Ptr Double -> CInt
 bessel_sequence_Jnu_e nu mode size v = gsl_sf_bessel_sequence_Jnu_e nu  (precCode mode) size v
-foreign import ccall "gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_sequence_Jnu_e" gsl_sf_bessel_sequence_Jnu_e :: Double -> Gsl_mode_t -> Size_t -> Ptr Double -> CInt
 
 bessel_Inu_scaled_e :: Double -> Double -> (Double,Double)
 bessel_Inu_scaled_e nu x = createSFR "bessel_Inu_scaled_e" $ gsl_sf_bessel_Inu_scaled_e nu x
-foreign import ccall "gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu_scaled_e" gsl_sf_bessel_Inu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Inu_scaled :: Double -> Double -> Double
 bessel_Inu_scaled = gsl_sf_bessel_Inu_scaled
-foreign import ccall "gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu_scaled" gsl_sf_bessel_Inu_scaled :: Double -> Double -> Double
 
 bessel_Inu_e :: Double -> Double -> (Double,Double)
 bessel_Inu_e nu x = createSFR "bessel_Inu_e" $ gsl_sf_bessel_Inu_e nu x
-foreign import ccall "gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu_e" gsl_sf_bessel_Inu_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Inu :: Double -> Double -> Double
 bessel_Inu = gsl_sf_bessel_Inu
-foreign import ccall "gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Inu" gsl_sf_bessel_Inu :: Double -> Double -> Double
 
 bessel_Knu_scaled_e :: Double -> Double -> (Double,Double)
 bessel_Knu_scaled_e nu x = createSFR "bessel_Knu_scaled_e" $ gsl_sf_bessel_Knu_scaled_e nu x
-foreign import ccall "gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu_scaled_e" gsl_sf_bessel_Knu_scaled_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Knu_scaled :: Double -> Double -> Double
 bessel_Knu_scaled = gsl_sf_bessel_Knu_scaled
-foreign import ccall "gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu_scaled" gsl_sf_bessel_Knu_scaled :: Double -> Double -> Double
 
 bessel_Knu_e :: Double -> Double -> (Double,Double)
 bessel_Knu_e nu x = createSFR "bessel_Knu_e" $ gsl_sf_bessel_Knu_e nu x
-foreign import ccall "gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu_e" gsl_sf_bessel_Knu_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_Knu :: Double -> Double -> Double
 bessel_Knu = gsl_sf_bessel_Knu
-foreign import ccall "gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_Knu" gsl_sf_bessel_Knu :: Double -> Double -> Double
 
 bessel_lnKnu_e :: Double -> Double -> (Double,Double)
 bessel_lnKnu_e nu x = createSFR "bessel_lnKnu_e" $ gsl_sf_bessel_lnKnu_e nu x
-foreign import ccall "gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_lnKnu_e" gsl_sf_bessel_lnKnu_e :: Double -> Double -> Ptr () -> IO CInt
 
 bessel_lnKnu :: Double -> Double -> Double
 bessel_lnKnu = gsl_sf_bessel_lnKnu
-foreign import ccall "gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_lnKnu" gsl_sf_bessel_lnKnu :: Double -> Double -> Double
 
 bessel_zero_J0_e :: CInt -> (Double,Double)
 bessel_zero_J0_e s = createSFR "bessel_zero_J0_e" $ gsl_sf_bessel_zero_J0_e s
-foreign import ccall "gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J0_e" gsl_sf_bessel_zero_J0_e :: CInt -> Ptr () -> IO CInt
 
 bessel_zero_J0 :: CInt -> Double
 bessel_zero_J0 = gsl_sf_bessel_zero_J0
-foreign import ccall "gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J0" gsl_sf_bessel_zero_J0 :: CInt -> Double
 
 bessel_zero_J1_e :: CInt -> (Double,Double)
 bessel_zero_J1_e s = createSFR "bessel_zero_J1_e" $ gsl_sf_bessel_zero_J1_e s
-foreign import ccall "gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J1_e" gsl_sf_bessel_zero_J1_e :: CInt -> Ptr () -> IO CInt
 
 bessel_zero_J1 :: CInt -> Double
 bessel_zero_J1 = gsl_sf_bessel_zero_J1
-foreign import ccall "gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_J1" gsl_sf_bessel_zero_J1 :: CInt -> Double
 
 bessel_zero_Jnu_e :: Double -> CInt -> (Double,Double)
 bessel_zero_Jnu_e nu s = createSFR "bessel_zero_Jnu_e" $ gsl_sf_bessel_zero_Jnu_e nu s
-foreign import ccall "gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_Jnu_e" gsl_sf_bessel_zero_Jnu_e :: Double -> CInt -> Ptr () -> IO CInt
 
 bessel_zero_Jnu :: Double -> CInt -> Double
 bessel_zero_Jnu = gsl_sf_bessel_zero_Jnu
-foreign import ccall "gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_bessel_zero_Jnu" gsl_sf_bessel_zero_Jnu :: Double -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Clausen.hs b/lib/Numeric/GSL/Special/Clausen.hs
index 4c9f6de..70f05a7 100644
--- a/lib/Numeric/GSL/Special/Clausen.hs
+++ b/lib/Numeric/GSL/Special/Clausen.hs
@@ -23,8 +23,8 @@ import Numeric.GSL.Special.Internal
 
 clausen_e :: Double -> (Double,Double)
 clausen_e x = createSFR "clausen_e" $ gsl_sf_clausen_e x
-foreign import ccall "gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_clausen_e" gsl_sf_clausen_e :: Double -> Ptr () -> IO CInt
 
 clausen :: Double -> Double
 clausen = gsl_sf_clausen
-foreign import ccall "gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_clausen" gsl_sf_clausen :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Coulomb.hs b/lib/Numeric/GSL/Special/Coulomb.hs
index 519a43a..7253972 100644
--- a/lib/Numeric/GSL/Special/Coulomb.hs
+++ b/lib/Numeric/GSL/Special/Coulomb.hs
@@ -26,44 +26,44 @@ import Numeric.GSL.Special.Internal
 
 hydrogenicR_1_e :: Double -> Double -> (Double,Double)
 hydrogenicR_1_e zZ r = createSFR "hydrogenicR_1_e" $ gsl_sf_hydrogenicR_1_e zZ r
-foreign import ccall "gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR_1_e" gsl_sf_hydrogenicR_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 hydrogenicR_1 :: Double -> Double -> Double
 hydrogenicR_1 = gsl_sf_hydrogenicR_1
-foreign import ccall "gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR_1" gsl_sf_hydrogenicR_1 :: Double -> Double -> Double
 
 hydrogenicR_e :: CInt -> CInt -> Double -> Double -> (Double,Double)
 hydrogenicR_e n l zZ r = createSFR "hydrogenicR_e" $ gsl_sf_hydrogenicR_e n l zZ r
-foreign import ccall "gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR_e" gsl_sf_hydrogenicR_e :: CInt -> CInt -> Double -> Double -> Ptr () -> IO CInt
 
 hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
 hydrogenicR = gsl_sf_hydrogenicR
-foreign import ccall "gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hydrogenicR" gsl_sf_hydrogenicR :: CInt -> CInt -> Double -> Double -> Double
 
 coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_FG_e = gsl_sf_coulomb_wave_FG_e
-foreign import ccall "gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FG_e" gsl_sf_coulomb_wave_FG_e :: Double -> Double -> Double -> CInt -> Ptr () -> Ptr () -> Ptr () -> Ptr () -> Ptr Double -> Ptr Double -> CInt
 
 coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_F_array = gsl_sf_coulomb_wave_F_array
-foreign import ccall "gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_F_array" gsl_sf_coulomb_wave_F_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 
 coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_FG_array = gsl_sf_coulomb_wave_FG_array
-foreign import ccall "gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FG_array" gsl_sf_coulomb_wave_FG_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
 
 coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_FGp_array = gsl_sf_coulomb_wave_FGp_array
-foreign import ccall "gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_FGp_array" gsl_sf_coulomb_wave_FGp_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> CInt
 
 coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 coulomb_wave_sphF_array = gsl_sf_coulomb_wave_sphF_array
-foreign import ccall "gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_wave_sphF_array" gsl_sf_coulomb_wave_sphF_array :: Double -> CInt -> Double -> Double -> Ptr Double -> Ptr Double -> CInt
 
 coulomb_CL_e :: Double -> Double -> (Double,Double)
 coulomb_CL_e lL eta = createSFR "coulomb_CL_e" $ gsl_sf_coulomb_CL_e lL eta
-foreign import ccall "gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_CL_e" gsl_sf_coulomb_CL_e :: Double -> Double -> Ptr () -> IO CInt
 
 coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
 coulomb_CL_array = gsl_sf_coulomb_CL_array
-foreign import ccall "gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coulomb_CL_array" gsl_sf_coulomb_CL_array :: Double -> CInt -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Coupling.hs b/lib/Numeric/GSL/Special/Coupling.hs
index 33d0129..16ff9b9 100644
--- a/lib/Numeric/GSL/Special/Coupling.hs
+++ b/lib/Numeric/GSL/Special/Coupling.hs
@@ -29,40 +29,40 @@ import Numeric.GSL.Special.Internal
 
 coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)
 coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc = createSFR "coupling_3j_e" $ gsl_sf_coupling_3j_e two_ja two_jb two_jc two_ma two_mb two_mc
-foreign import ccall "gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_3j_e" gsl_sf_coupling_3j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_3j = gsl_sf_coupling_3j
-foreign import ccall "gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_3j" gsl_sf_coupling_3j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)
 coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_e" $ gsl_sf_coupling_6j_e two_ja two_jb two_jc two_jd two_je two_jf
-foreign import ccall "gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j_e" gsl_sf_coupling_6j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_6j = gsl_sf_coupling_6j
-foreign import ccall "gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j" gsl_sf_coupling_6j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)
 coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_RacahW_e" $ gsl_sf_coupling_RacahW_e two_ja two_jb two_jc two_jd two_je two_jf
-foreign import ccall "gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_RacahW_e" gsl_sf_coupling_RacahW_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_RacahW = gsl_sf_coupling_RacahW
-foreign import ccall "gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_RacahW" gsl_sf_coupling_RacahW :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)
 coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji = createSFR "coupling_9j_e" $ gsl_sf_coupling_9j_e two_ja two_jb two_jc two_jd two_je two_jf two_jg two_jh two_ji
-foreign import ccall "gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_9j_e" gsl_sf_coupling_9j_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_9j = gsl_sf_coupling_9j
-foreign import ccall "gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_9j" gsl_sf_coupling_9j :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 
 coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> (Double,Double)
 coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf = createSFR "coupling_6j_INCORRECT_e" $ gsl_sf_coupling_6j_INCORRECT_e two_ja two_jb two_jc two_jd two_je two_jf
-foreign import ccall "gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j_INCORRECT_e" gsl_sf_coupling_6j_INCORRECT_e :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr () -> IO CInt
 
 coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
 coupling_6j_INCORRECT = gsl_sf_coupling_6j_INCORRECT
-foreign import ccall "gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_coupling_6j_INCORRECT" gsl_sf_coupling_6j_INCORRECT :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Dawson.hs b/lib/Numeric/GSL/Special/Dawson.hs
index 0bddbaf..7e8d9ce 100644
--- a/lib/Numeric/GSL/Special/Dawson.hs
+++ b/lib/Numeric/GSL/Special/Dawson.hs
@@ -23,8 +23,8 @@ import Numeric.GSL.Special.Internal
 
 dawson_e :: Double -> (Double,Double)
 dawson_e x = createSFR "dawson_e" $ gsl_sf_dawson_e x
-foreign import ccall "gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_dawson_e" gsl_sf_dawson_e :: Double -> Ptr () -> IO CInt
 
 dawson :: Double -> Double
 dawson = gsl_sf_dawson
-foreign import ccall "gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_dawson" gsl_sf_dawson :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Debye.hs b/lib/Numeric/GSL/Special/Debye.hs
index 8a3e655..01976ee 100644
--- a/lib/Numeric/GSL/Special/Debye.hs
+++ b/lib/Numeric/GSL/Special/Debye.hs
@@ -33,48 +33,48 @@ import Numeric.GSL.Special.Internal
 
 debye_1_e :: Double -> (Double,Double)
 debye_1_e x = createSFR "debye_1_e" $ gsl_sf_debye_1_e x
-foreign import ccall "gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_1_e" gsl_sf_debye_1_e :: Double -> Ptr () -> IO CInt
 
 debye_1 :: Double -> Double
 debye_1 = gsl_sf_debye_1
-foreign import ccall "gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_1" gsl_sf_debye_1 :: Double -> Double
 
 debye_2_e :: Double -> (Double,Double)
 debye_2_e x = createSFR "debye_2_e" $ gsl_sf_debye_2_e x
-foreign import ccall "gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_2_e" gsl_sf_debye_2_e :: Double -> Ptr () -> IO CInt
 
 debye_2 :: Double -> Double
 debye_2 = gsl_sf_debye_2
-foreign import ccall "gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_2" gsl_sf_debye_2 :: Double -> Double
 
 debye_3_e :: Double -> (Double,Double)
 debye_3_e x = createSFR "debye_3_e" $ gsl_sf_debye_3_e x
-foreign import ccall "gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_3_e" gsl_sf_debye_3_e :: Double -> Ptr () -> IO CInt
 
 debye_3 :: Double -> Double
 debye_3 = gsl_sf_debye_3
-foreign import ccall "gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_3" gsl_sf_debye_3 :: Double -> Double
 
 debye_4_e :: Double -> (Double,Double)
 debye_4_e x = createSFR "debye_4_e" $ gsl_sf_debye_4_e x
-foreign import ccall "gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_4_e" gsl_sf_debye_4_e :: Double -> Ptr () -> IO CInt
 
 debye_4 :: Double -> Double
 debye_4 = gsl_sf_debye_4
-foreign import ccall "gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_4" gsl_sf_debye_4 :: Double -> Double
 
 debye_5_e :: Double -> (Double,Double)
 debye_5_e x = createSFR "debye_5_e" $ gsl_sf_debye_5_e x
-foreign import ccall "gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_5_e" gsl_sf_debye_5_e :: Double -> Ptr () -> IO CInt
 
 debye_5 :: Double -> Double
 debye_5 = gsl_sf_debye_5
-foreign import ccall "gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_5" gsl_sf_debye_5 :: Double -> Double
 
 debye_6_e :: Double -> (Double,Double)
 debye_6_e x = createSFR "debye_6_e" $ gsl_sf_debye_6_e x
-foreign import ccall "gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_6_e" gsl_sf_debye_6_e :: Double -> Ptr () -> IO CInt
 
 debye_6 :: Double -> Double
 debye_6 = gsl_sf_debye_6
-foreign import ccall "gsl_sf_debye_6" gsl_sf_debye_6 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_debye_6" gsl_sf_debye_6 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Dilog.hs b/lib/Numeric/GSL/Special/Dilog.hs
index 23cbf79..48b548b 100644
--- a/lib/Numeric/GSL/Special/Dilog.hs
+++ b/lib/Numeric/GSL/Special/Dilog.hs
@@ -23,20 +23,20 @@ import Numeric.GSL.Special.Internal
 
 dilog_e :: Double -> (Double,Double)
 dilog_e x = createSFR "dilog_e" $ gsl_sf_dilog_e x
-foreign import ccall "gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_dilog_e" gsl_sf_dilog_e :: Double -> Ptr () -> IO CInt
 
 dilog :: Double -> Double
 dilog = gsl_sf_dilog
-foreign import ccall "gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_dilog" gsl_sf_dilog :: Double -> Double
 
 complex_dilog_xy_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_dilog_xy_e x y result_re = createSFR "complex_dilog_xy_e" $ gsl_sf_complex_dilog_xy_e x y result_re
-foreign import ccall "gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_dilog_xy_e" gsl_sf_complex_dilog_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 complex_dilog_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_dilog_e r theta result_re = createSFR "complex_dilog_e" $ gsl_sf_complex_dilog_e r theta result_re
-foreign import ccall "gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_dilog_e" gsl_sf_complex_dilog_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 complex_spence_xy_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_spence_xy_e x y real_sp = createSFR "complex_spence_xy_e" $ gsl_sf_complex_spence_xy_e x y real_sp
-foreign import ccall "gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_spence_xy_e" gsl_sf_complex_spence_xy_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Elementary.hs b/lib/Numeric/GSL/Special/Elementary.hs
index 083a68b..7e7f8b6 100644
--- a/lib/Numeric/GSL/Special/Elementary.hs
+++ b/lib/Numeric/GSL/Special/Elementary.hs
@@ -24,12 +24,12 @@ import Numeric.GSL.Special.Internal
 
 multiply_e :: Double -> Double -> (Double,Double)
 multiply_e x y = createSFR "multiply_e" $ gsl_sf_multiply_e x y
-foreign import ccall "gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_multiply_e" gsl_sf_multiply_e :: Double -> Double -> Ptr () -> IO CInt
 
 multiply :: Double -> Double -> Double
 multiply = gsl_sf_multiply
-foreign import ccall "gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_multiply" gsl_sf_multiply :: Double -> Double -> Double
 
 multiply_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
 multiply_err_e x dx y dy = createSFR "multiply_err_e" $ gsl_sf_multiply_err_e x dx y dy
-foreign import ccall "gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_multiply_err_e" gsl_sf_multiply_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Ellint.hs b/lib/Numeric/GSL/Special/Ellint.hs
index 9a4057e..6735057 100644
--- a/lib/Numeric/GSL/Special/Ellint.hs
+++ b/lib/Numeric/GSL/Special/Ellint.hs
@@ -45,96 +45,96 @@ import Numeric.GSL.Special.Internal
 
 ellint_Kcomp_e :: Double -> Precision -> (Double,Double)
 ellint_Kcomp_e k mode = createSFR "ellint_Kcomp_e" $ gsl_sf_ellint_Kcomp_e k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Kcomp_e" gsl_sf_ellint_Kcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_Kcomp :: Double -> Precision -> Double
 ellint_Kcomp k mode = gsl_sf_ellint_Kcomp k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Kcomp" gsl_sf_ellint_Kcomp :: Double -> Gsl_mode_t -> Double
 
 ellint_Ecomp_e :: Double -> Precision -> (Double,Double)
 ellint_Ecomp_e k mode = createSFR "ellint_Ecomp_e" $ gsl_sf_ellint_Ecomp_e k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Ecomp_e" gsl_sf_ellint_Ecomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_Ecomp :: Double -> Precision -> Double
 ellint_Ecomp k mode = gsl_sf_ellint_Ecomp k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Ecomp" gsl_sf_ellint_Ecomp :: Double -> Gsl_mode_t -> Double
 
 ellint_Pcomp_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_Pcomp_e k n mode = createSFR "ellint_Pcomp_e" $ gsl_sf_ellint_Pcomp_e k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Pcomp_e" gsl_sf_ellint_Pcomp_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_Pcomp :: Double -> Double -> Precision -> Double
 ellint_Pcomp k n mode = gsl_sf_ellint_Pcomp k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Pcomp" gsl_sf_ellint_Pcomp :: Double -> Double -> Gsl_mode_t -> Double
 
 ellint_Dcomp_e :: Double -> Precision -> (Double,Double)
 ellint_Dcomp_e k mode = createSFR "ellint_Dcomp_e" $ gsl_sf_ellint_Dcomp_e k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Dcomp_e" gsl_sf_ellint_Dcomp_e :: Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_Dcomp :: Double -> Precision -> Double
 ellint_Dcomp k mode = gsl_sf_ellint_Dcomp k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_Dcomp" gsl_sf_ellint_Dcomp :: Double -> Gsl_mode_t -> Double
 
 ellint_F_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_F_e phi k mode = createSFR "ellint_F_e" $ gsl_sf_ellint_F_e phi k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_F_e" gsl_sf_ellint_F_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_F :: Double -> Double -> Precision -> Double
 ellint_F phi k mode = gsl_sf_ellint_F phi k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_F" gsl_sf_ellint_F :: Double -> Double -> Gsl_mode_t -> Double
 
 ellint_E_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_E_e phi k mode = createSFR "ellint_E_e" $ gsl_sf_ellint_E_e phi k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_E_e" gsl_sf_ellint_E_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_E :: Double -> Double -> Precision -> Double
 ellint_E phi k mode = gsl_sf_ellint_E phi k  (precCode mode)
-foreign import ccall "gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_E" gsl_sf_ellint_E :: Double -> Double -> Gsl_mode_t -> Double
 
 ellint_P_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_P_e phi k n mode = createSFR "ellint_P_e" $ gsl_sf_ellint_P_e phi k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_P_e" gsl_sf_ellint_P_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_P :: Double -> Double -> Double -> Precision -> Double
 ellint_P phi k n mode = gsl_sf_ellint_P phi k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_P" gsl_sf_ellint_P :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 ellint_D_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_D_e phi k n mode = createSFR "ellint_D_e" $ gsl_sf_ellint_D_e phi k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_D_e" gsl_sf_ellint_D_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_D :: Double -> Double -> Double -> Precision -> Double
 ellint_D phi k n mode = gsl_sf_ellint_D phi k n  (precCode mode)
-foreign import ccall "gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_D" gsl_sf_ellint_D :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 ellint_RC_e :: Double -> Double -> Precision -> (Double,Double)
 ellint_RC_e x y mode = createSFR "ellint_RC_e" $ gsl_sf_ellint_RC_e x y  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RC_e" gsl_sf_ellint_RC_e :: Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_RC :: Double -> Double -> Precision -> Double
 ellint_RC x y mode = gsl_sf_ellint_RC x y  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RC" gsl_sf_ellint_RC :: Double -> Double -> Gsl_mode_t -> Double
 
 ellint_RD_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RD_e x y z mode = createSFR "ellint_RD_e" $ gsl_sf_ellint_RD_e x y z  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RD_e" gsl_sf_ellint_RD_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_RD :: Double -> Double -> Double -> Precision -> Double
 ellint_RD x y z mode = gsl_sf_ellint_RD x y z  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RD" gsl_sf_ellint_RD :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 ellint_RF_e :: Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RF_e x y z mode = createSFR "ellint_RF_e" $ gsl_sf_ellint_RF_e x y z  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RF_e" gsl_sf_ellint_RF_e :: Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_RF :: Double -> Double -> Double -> Precision -> Double
 ellint_RF x y z mode = gsl_sf_ellint_RF x y z  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RF" gsl_sf_ellint_RF :: Double -> Double -> Double -> Gsl_mode_t -> Double
 
 ellint_RJ_e :: Double -> Double -> Double -> Double -> Precision -> (Double,Double)
 ellint_RJ_e x y z p mode = createSFR "ellint_RJ_e" $ gsl_sf_ellint_RJ_e x y z p  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RJ_e" gsl_sf_ellint_RJ_e :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Ptr () -> IO CInt
 
 ellint_RJ :: Double -> Double -> Double -> Double -> Precision -> Double
 ellint_RJ x y z p mode = gsl_sf_ellint_RJ x y z p  (precCode mode)
-foreign import ccall "gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_ellint_RJ" gsl_sf_ellint_RJ :: Double -> Double -> Double -> Double -> Gsl_mode_t -> Double
diff --git a/lib/Numeric/GSL/Special/Erf.hs b/lib/Numeric/GSL/Special/Erf.hs
index 34ade6f..258afd3 100644
--- a/lib/Numeric/GSL/Special/Erf.hs
+++ b/lib/Numeric/GSL/Special/Erf.hs
@@ -33,48 +33,48 @@ import Numeric.GSL.Special.Internal
 
 erfc_e :: Double -> (Double,Double)
 erfc_e x = createSFR "erfc_e" $ gsl_sf_erfc_e x
-foreign import ccall "gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_erfc_e" gsl_sf_erfc_e :: Double -> Ptr () -> IO CInt
 
 erfc :: Double -> Double
 erfc = gsl_sf_erfc
-foreign import ccall "gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_erfc" gsl_sf_erfc :: Double -> Double
 
 log_erfc_e :: Double -> (Double,Double)
 log_erfc_e x = createSFR "log_erfc_e" $ gsl_sf_log_erfc_e x
-foreign import ccall "gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_log_erfc_e" gsl_sf_log_erfc_e :: Double -> Ptr () -> IO CInt
 
 log_erfc :: Double -> Double
 log_erfc = gsl_sf_log_erfc
-foreign import ccall "gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_log_erfc" gsl_sf_log_erfc :: Double -> Double
 
 erf_e :: Double -> (Double,Double)
 erf_e x = createSFR "erf_e" $ gsl_sf_erf_e x
-foreign import ccall "gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_e" gsl_sf_erf_e :: Double -> Ptr () -> IO CInt
 
 erf :: Double -> Double
 erf = gsl_sf_erf
-foreign import ccall "gsl_sf_erf" gsl_sf_erf :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_erf" gsl_sf_erf :: Double -> Double
 
 erf_Z_e :: Double -> (Double,Double)
 erf_Z_e x = createSFR "erf_Z_e" $ gsl_sf_erf_Z_e x
-foreign import ccall "gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Z_e" gsl_sf_erf_Z_e :: Double -> Ptr () -> IO CInt
 
 erf_Q_e :: Double -> (Double,Double)
 erf_Q_e x = createSFR "erf_Q_e" $ gsl_sf_erf_Q_e x
-foreign import ccall "gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Q_e" gsl_sf_erf_Q_e :: Double -> Ptr () -> IO CInt
 
 erf_Z :: Double -> Double
 erf_Z = gsl_sf_erf_Z
-foreign import ccall "gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Z" gsl_sf_erf_Z :: Double -> Double
 
 erf_Q :: Double -> Double
 erf_Q = gsl_sf_erf_Q
-foreign import ccall "gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_erf_Q" gsl_sf_erf_Q :: Double -> Double
 
 hazard_e :: Double -> (Double,Double)
 hazard_e x = createSFR "hazard_e" $ gsl_sf_hazard_e x
-foreign import ccall "gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hazard_e" gsl_sf_hazard_e :: Double -> Ptr () -> IO CInt
 
 hazard :: Double -> Double
 hazard = gsl_sf_hazard
-foreign import ccall "gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hazard" gsl_sf_hazard :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Exp.hs b/lib/Numeric/GSL/Special/Exp.hs
index 1380590..4f15964 100644
--- a/lib/Numeric/GSL/Special/Exp.hs
+++ b/lib/Numeric/GSL/Special/Exp.hs
@@ -40,76 +40,76 @@ import Numeric.GSL.Special.Internal
 
 exp_e :: Double -> (Double,Double)
 exp_e x = createSFR "exp_e" $ gsl_sf_exp_e x
-foreign import ccall "gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_e" gsl_sf_exp_e :: Double -> Ptr () -> IO CInt
 
 exp :: Double -> Double
 exp = gsl_sf_exp
-foreign import ccall "gsl_sf_exp" gsl_sf_exp :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_exp" gsl_sf_exp :: Double -> Double
 
 exp_e10_e :: Double -> (Double,Int,Double)
 exp_e10_e x = createSFR_E10 "exp_e10_e" $ gsl_sf_exp_e10_e x
-foreign import ccall "gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_e10_e" gsl_sf_exp_e10_e :: Double -> Ptr () -> IO CInt
 
 exp_mult_e :: Double -> Double -> (Double,Double)
 exp_mult_e x y = createSFR "exp_mult_e" $ gsl_sf_exp_mult_e x y
-foreign import ccall "gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult_e" gsl_sf_exp_mult_e :: Double -> Double -> Ptr () -> IO CInt
 
 exp_mult :: Double -> Double -> Double
 exp_mult = gsl_sf_exp_mult
-foreign import ccall "gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult" gsl_sf_exp_mult :: Double -> Double -> Double
 
 exp_mult_e10_e :: Double -> Double -> (Double,Int,Double)
 exp_mult_e10_e x y = createSFR_E10 "exp_mult_e10_e" $ gsl_sf_exp_mult_e10_e x y
-foreign import ccall "gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult_e10_e" gsl_sf_exp_mult_e10_e :: Double -> Double -> Ptr () -> IO CInt
 
 expm1_e :: Double -> (Double,Double)
 expm1_e x = createSFR "expm1_e" $ gsl_sf_expm1_e x
-foreign import ccall "gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expm1_e" gsl_sf_expm1_e :: Double -> Ptr () -> IO CInt
 
 expm1 :: Double -> Double
 expm1 = gsl_sf_expm1
-foreign import ccall "gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expm1" gsl_sf_expm1 :: Double -> Double
 
 exprel_e :: Double -> (Double,Double)
 exprel_e x = createSFR "exprel_e" $ gsl_sf_exprel_e x
-foreign import ccall "gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_e" gsl_sf_exprel_e :: Double -> Ptr () -> IO CInt
 
 exprel :: Double -> Double
 exprel = gsl_sf_exprel
-foreign import ccall "gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel" gsl_sf_exprel :: Double -> Double
 
 exprel_2_e :: Double -> (Double,Double)
 exprel_2_e x = createSFR "exprel_2_e" $ gsl_sf_exprel_2_e x
-foreign import ccall "gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_2_e" gsl_sf_exprel_2_e :: Double -> Ptr () -> IO CInt
 
 exprel_2 :: Double -> Double
 exprel_2 = gsl_sf_exprel_2
-foreign import ccall "gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_2" gsl_sf_exprel_2 :: Double -> Double
 
 exprel_n_e :: CInt -> Double -> (Double,Double)
 exprel_n_e n x = createSFR "exprel_n_e" $ gsl_sf_exprel_n_e n x
-foreign import ccall "gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n_e" gsl_sf_exprel_n_e :: CInt -> Double -> Ptr () -> IO CInt
 
 exprel_n :: CInt -> Double -> Double
 exprel_n = gsl_sf_exprel_n
-foreign import ccall "gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n" gsl_sf_exprel_n :: CInt -> Double -> Double
 
 exprel_n_CF_e :: Double -> Double -> (Double,Double)
 exprel_n_CF_e n x = createSFR "exprel_n_CF_e" $ gsl_sf_exprel_n_CF_e n x
-foreign import ccall "gsl_sf_exprel_n_CF_e" gsl_sf_exprel_n_CF_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exprel_n_CF_e" gsl_sf_exprel_n_CF_e :: Double -> Double -> Ptr () -> IO CInt
 
 exp_err_e :: Double -> Double -> (Double,Double)
 exp_err_e x dx = createSFR "exp_err_e" $ gsl_sf_exp_err_e x dx
-foreign import ccall "gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_err_e" gsl_sf_exp_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 exp_err_e10_e :: Double -> Double -> (Double,Int,Double)
 exp_err_e10_e x dx = createSFR_E10 "exp_err_e10_e" $ gsl_sf_exp_err_e10_e x dx
-foreign import ccall "gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_err_e10_e" gsl_sf_exp_err_e10_e :: Double -> Double -> Ptr () -> IO CInt
 
 exp_mult_err_e :: Double -> Double -> Double -> Double -> (Double,Double)
 exp_mult_err_e x dx y dy = createSFR "exp_mult_err_e" $ gsl_sf_exp_mult_err_e x dx y dy
-foreign import ccall "gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult_err_e" gsl_sf_exp_mult_err_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> (Double,Int,Double)
 exp_mult_err_e10_e x dx y dy = createSFR_E10 "exp_mult_err_e10_e" $ gsl_sf_exp_mult_err_e10_e x dx y dy
-foreign import ccall "gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_exp_mult_err_e10_e" gsl_sf_exp_mult_err_e10_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Expint.hs b/lib/Numeric/GSL/Special/Expint.hs
index 32f2b1a..f1102c4 100644
--- a/lib/Numeric/GSL/Special/Expint.hs
+++ b/lib/Numeric/GSL/Special/Expint.hs
@@ -49,112 +49,112 @@ import Numeric.GSL.Special.Internal
 
 expint_E1_e :: Double -> (Double,Double)
 expint_E1_e x = createSFR "expint_E1_e" $ gsl_sf_expint_E1_e x
-foreign import ccall "gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1_e" gsl_sf_expint_E1_e :: Double -> Ptr () -> IO CInt
 
 expint_E1 :: Double -> Double
 expint_E1 = gsl_sf_expint_E1
-foreign import ccall "gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1" gsl_sf_expint_E1 :: Double -> Double
 
 expint_E2_e :: Double -> (Double,Double)
 expint_E2_e x = createSFR "expint_E2_e" $ gsl_sf_expint_E2_e x
-foreign import ccall "gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2_e" gsl_sf_expint_E2_e :: Double -> Ptr () -> IO CInt
 
 expint_E2 :: Double -> Double
 expint_E2 = gsl_sf_expint_E2
-foreign import ccall "gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2" gsl_sf_expint_E2 :: Double -> Double
 
 expint_En_e :: CInt -> Double -> (Double,Double)
 expint_En_e n x = createSFR "expint_En_e" $ gsl_sf_expint_En_e n x
-foreign import ccall "gsl_sf_expint_En_e" gsl_sf_expint_En_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_e" gsl_sf_expint_En_e :: CInt -> Double -> Ptr () -> IO CInt
 
 expint_En :: CInt -> Double -> Double
 expint_En = gsl_sf_expint_En
-foreign import ccall "gsl_sf_expint_En" gsl_sf_expint_En :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En" gsl_sf_expint_En :: CInt -> Double -> Double
 
 expint_E1_scaled_e :: Double -> (Double,Double)
 expint_E1_scaled_e x = createSFR "expint_E1_scaled_e" $ gsl_sf_expint_E1_scaled_e x
-foreign import ccall "gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1_scaled_e" gsl_sf_expint_E1_scaled_e :: Double -> Ptr () -> IO CInt
 
 expint_E1_scaled :: Double -> Double
 expint_E1_scaled = gsl_sf_expint_E1_scaled
-foreign import ccall "gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E1_scaled" gsl_sf_expint_E1_scaled :: Double -> Double
 
 expint_E2_scaled_e :: Double -> (Double,Double)
 expint_E2_scaled_e x = createSFR "expint_E2_scaled_e" $ gsl_sf_expint_E2_scaled_e x
-foreign import ccall "gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2_scaled_e" gsl_sf_expint_E2_scaled_e :: Double -> Ptr () -> IO CInt
 
 expint_E2_scaled :: Double -> Double
 expint_E2_scaled = gsl_sf_expint_E2_scaled
-foreign import ccall "gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_E2_scaled" gsl_sf_expint_E2_scaled :: Double -> Double
 
 expint_En_scaled_e :: CInt -> Double -> (Double,Double)
 expint_En_scaled_e n x = createSFR "expint_En_scaled_e" $ gsl_sf_expint_En_scaled_e n x
-foreign import ccall "gsl_sf_expint_En_scaled_e" gsl_sf_expint_En_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_scaled_e" gsl_sf_expint_En_scaled_e :: CInt -> Double -> Ptr () -> IO CInt
 
 expint_En_scaled :: CInt -> Double -> Double
 expint_En_scaled = gsl_sf_expint_En_scaled
-foreign import ccall "gsl_sf_expint_En_scaled" gsl_sf_expint_En_scaled :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_En_scaled" gsl_sf_expint_En_scaled :: CInt -> Double -> Double
 
 expint_Ei_e :: Double -> (Double,Double)
 expint_Ei_e x = createSFR "expint_Ei_e" $ gsl_sf_expint_Ei_e x
-foreign import ccall "gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei_e" gsl_sf_expint_Ei_e :: Double -> Ptr () -> IO CInt
 
 expint_Ei :: Double -> Double
 expint_Ei = gsl_sf_expint_Ei
-foreign import ccall "gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei" gsl_sf_expint_Ei :: Double -> Double
 
 expint_Ei_scaled_e :: Double -> (Double,Double)
 expint_Ei_scaled_e x = createSFR "expint_Ei_scaled_e" $ gsl_sf_expint_Ei_scaled_e x
-foreign import ccall "gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei_scaled_e" gsl_sf_expint_Ei_scaled_e :: Double -> Ptr () -> IO CInt
 
 expint_Ei_scaled :: Double -> Double
 expint_Ei_scaled = gsl_sf_expint_Ei_scaled
-foreign import ccall "gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_Ei_scaled" gsl_sf_expint_Ei_scaled :: Double -> Double
 
 shi_e :: Double -> (Double,Double)
 shi_e x = createSFR "shi_e" $ gsl_sf_Shi_e x
-foreign import ccall "gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_Shi_e" gsl_sf_Shi_e :: Double -> Ptr () -> IO CInt
 
 shi :: Double -> Double
 shi = gsl_sf_Shi
-foreign import ccall "gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_Shi" gsl_sf_Shi :: Double -> Double
 
 chi_e :: Double -> (Double,Double)
 chi_e x = createSFR "chi_e" $ gsl_sf_Chi_e x
-foreign import ccall "gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_Chi_e" gsl_sf_Chi_e :: Double -> Ptr () -> IO CInt
 
 chi :: Double -> Double
 chi = gsl_sf_Chi
-foreign import ccall "gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_Chi" gsl_sf_Chi :: Double -> Double
 
 expint_3_e :: Double -> (Double,Double)
 expint_3_e x = createSFR "expint_3_e" $ gsl_sf_expint_3_e x
-foreign import ccall "gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_3_e" gsl_sf_expint_3_e :: Double -> Ptr () -> IO CInt
 
 expint_3 :: Double -> Double
 expint_3 = gsl_sf_expint_3
-foreign import ccall "gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_expint_3" gsl_sf_expint_3 :: Double -> Double
 
 si_e :: Double -> (Double,Double)
 si_e x = createSFR "si_e" $ gsl_sf_Si_e x
-foreign import ccall "gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_Si_e" gsl_sf_Si_e :: Double -> Ptr () -> IO CInt
 
 si :: Double -> Double
 si = gsl_sf_Si
-foreign import ccall "gsl_sf_Si" gsl_sf_Si :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_Si" gsl_sf_Si :: Double -> Double
 
 ci_e :: Double -> (Double,Double)
 ci_e x = createSFR "ci_e" $ gsl_sf_Ci_e x
-foreign import ccall "gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_Ci_e" gsl_sf_Ci_e :: Double -> Ptr () -> IO CInt
 
 ci :: Double -> Double
 ci = gsl_sf_Ci
-foreign import ccall "gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_Ci" gsl_sf_Ci :: Double -> Double
 
 atanint_e :: Double -> (Double,Double)
 atanint_e x = createSFR "atanint_e" $ gsl_sf_atanint_e x
-foreign import ccall "gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_atanint_e" gsl_sf_atanint_e :: Double -> Ptr () -> IO CInt
 
 atanint :: Double -> Double
 atanint = gsl_sf_atanint
-foreign import ccall "gsl_sf_atanint" gsl_sf_atanint :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_atanint" gsl_sf_atanint :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Fermi_dirac.hs b/lib/Numeric/GSL/Special/Fermi_dirac.hs
index f6deabe..362c7ba 100644
--- a/lib/Numeric/GSL/Special/Fermi_dirac.hs
+++ b/lib/Numeric/GSL/Special/Fermi_dirac.hs
@@ -39,72 +39,72 @@ import Numeric.GSL.Special.Internal
 
 fermi_dirac_m1_e :: Double -> (Double,Double)
 fermi_dirac_m1_e x = createSFR "fermi_dirac_m1_e" $ gsl_sf_fermi_dirac_m1_e x
-foreign import ccall "gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_m1_e" gsl_sf_fermi_dirac_m1_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_m1 :: Double -> Double
 fermi_dirac_m1 = gsl_sf_fermi_dirac_m1
-foreign import ccall "gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_m1" gsl_sf_fermi_dirac_m1 :: Double -> Double
 
 fermi_dirac_0_e :: Double -> (Double,Double)
 fermi_dirac_0_e x = createSFR "fermi_dirac_0_e" $ gsl_sf_fermi_dirac_0_e x
-foreign import ccall "gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_0_e" gsl_sf_fermi_dirac_0_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_0 :: Double -> Double
 fermi_dirac_0 = gsl_sf_fermi_dirac_0
-foreign import ccall "gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_0" gsl_sf_fermi_dirac_0 :: Double -> Double
 
 fermi_dirac_1_e :: Double -> (Double,Double)
 fermi_dirac_1_e x = createSFR "fermi_dirac_1_e" $ gsl_sf_fermi_dirac_1_e x
-foreign import ccall "gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_1_e" gsl_sf_fermi_dirac_1_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_1 :: Double -> Double
 fermi_dirac_1 = gsl_sf_fermi_dirac_1
-foreign import ccall "gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_1" gsl_sf_fermi_dirac_1 :: Double -> Double
 
 fermi_dirac_2_e :: Double -> (Double,Double)
 fermi_dirac_2_e x = createSFR "fermi_dirac_2_e" $ gsl_sf_fermi_dirac_2_e x
-foreign import ccall "gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_2_e" gsl_sf_fermi_dirac_2_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_2 :: Double -> Double
 fermi_dirac_2 = gsl_sf_fermi_dirac_2
-foreign import ccall "gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_2" gsl_sf_fermi_dirac_2 :: Double -> Double
 
 fermi_dirac_int_e :: CInt -> Double -> (Double,Double)
 fermi_dirac_int_e j x = createSFR "fermi_dirac_int_e" $ gsl_sf_fermi_dirac_int_e j x
-foreign import ccall "gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_int_e" gsl_sf_fermi_dirac_int_e :: CInt -> Double -> Ptr () -> IO CInt
 
 fermi_dirac_int :: CInt -> Double -> Double
 fermi_dirac_int = gsl_sf_fermi_dirac_int
-foreign import ccall "gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_int" gsl_sf_fermi_dirac_int :: CInt -> Double -> Double
 
 fermi_dirac_mhalf_e :: Double -> (Double,Double)
 fermi_dirac_mhalf_e x = createSFR "fermi_dirac_mhalf_e" $ gsl_sf_fermi_dirac_mhalf_e x
-foreign import ccall "gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_mhalf_e" gsl_sf_fermi_dirac_mhalf_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_mhalf :: Double -> Double
 fermi_dirac_mhalf = gsl_sf_fermi_dirac_mhalf
-foreign import ccall "gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_mhalf" gsl_sf_fermi_dirac_mhalf :: Double -> Double
 
 fermi_dirac_half_e :: Double -> (Double,Double)
 fermi_dirac_half_e x = createSFR "fermi_dirac_half_e" $ gsl_sf_fermi_dirac_half_e x
-foreign import ccall "gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_half_e" gsl_sf_fermi_dirac_half_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_half :: Double -> Double
 fermi_dirac_half = gsl_sf_fermi_dirac_half
-foreign import ccall "gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_half" gsl_sf_fermi_dirac_half :: Double -> Double
 
 fermi_dirac_3half_e :: Double -> (Double,Double)
 fermi_dirac_3half_e x = createSFR "fermi_dirac_3half_e" $ gsl_sf_fermi_dirac_3half_e x
-foreign import ccall "gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_3half_e" gsl_sf_fermi_dirac_3half_e :: Double -> Ptr () -> IO CInt
 
 fermi_dirac_3half :: Double -> Double
 fermi_dirac_3half = gsl_sf_fermi_dirac_3half
-foreign import ccall "gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_3half" gsl_sf_fermi_dirac_3half :: Double -> Double
 
 fermi_dirac_inc_0_e :: Double -> Double -> (Double,Double)
 fermi_dirac_inc_0_e x b = createSFR "fermi_dirac_inc_0_e" $ gsl_sf_fermi_dirac_inc_0_e x b
-foreign import ccall "gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_inc_0_e" gsl_sf_fermi_dirac_inc_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 fermi_dirac_inc_0 :: Double -> Double -> Double
 fermi_dirac_inc_0 = gsl_sf_fermi_dirac_inc_0
-foreign import ccall "gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fermi_dirac_inc_0" gsl_sf_fermi_dirac_inc_0 :: Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Gamma.hs b/lib/Numeric/GSL/Special/Gamma.hs
index 1a395ff..03b39c4 100644
--- a/lib/Numeric/GSL/Special/Gamma.hs
+++ b/lib/Numeric/GSL/Special/Gamma.hs
@@ -61,176 +61,176 @@ import Numeric.GSL.Special.Internal
 
 lngamma_e :: Double -> (Double,Double)
 lngamma_e x = createSFR "lngamma_e" $ gsl_sf_lngamma_e x
-foreign import ccall "gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_e" gsl_sf_lngamma_e :: Double -> Ptr () -> IO CInt
 
 lngamma :: Double -> Double
 lngamma = gsl_sf_lngamma
-foreign import ccall "gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma" gsl_sf_lngamma :: Double -> Double
 
 lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
 lngamma_sgn_e = gsl_sf_lngamma_sgn_e
-foreign import ccall "gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_sgn_e" gsl_sf_lngamma_sgn_e :: Double -> Ptr () -> Ptr Double -> CInt
 
 gamma_e :: Double -> (Double,Double)
 gamma_e x = createSFR "gamma_e" $ gsl_sf_gamma_e x
-foreign import ccall "gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_e" gsl_sf_gamma_e :: Double -> Ptr () -> IO CInt
 
 gamma :: Double -> Double
 gamma = gsl_sf_gamma
-foreign import ccall "gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma" gsl_sf_gamma :: Double -> Double
 
 gammastar_e :: Double -> (Double,Double)
 gammastar_e x = createSFR "gammastar_e" $ gsl_sf_gammastar_e x
-foreign import ccall "gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gammastar_e" gsl_sf_gammastar_e :: Double -> Ptr () -> IO CInt
 
 gammastar :: Double -> Double
 gammastar = gsl_sf_gammastar
-foreign import ccall "gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gammastar" gsl_sf_gammastar :: Double -> Double
 
 gammainv_e :: Double -> (Double,Double)
 gammainv_e x = createSFR "gammainv_e" $ gsl_sf_gammainv_e x
-foreign import ccall "gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gammainv_e" gsl_sf_gammainv_e :: Double -> Ptr () -> IO CInt
 
 gammainv :: Double -> Double
 gammainv = gsl_sf_gammainv
-foreign import ccall "gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gammainv" gsl_sf_gammainv :: Double -> Double
 
 lngamma_complex_e :: Double -> Double -> Ptr () -> (Double,Double)
 lngamma_complex_e zr zi lnr = createSFR "lngamma_complex_e" $ gsl_sf_lngamma_complex_e zr zi lnr
-foreign import ccall "gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lngamma_complex_e" gsl_sf_lngamma_complex_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 taylorcoeff_e :: CInt -> Double -> (Double,Double)
 taylorcoeff_e n x = createSFR "taylorcoeff_e" $ gsl_sf_taylorcoeff_e n x
-foreign import ccall "gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_taylorcoeff_e" gsl_sf_taylorcoeff_e :: CInt -> Double -> Ptr () -> IO CInt
 
 taylorcoeff :: CInt -> Double -> Double
 taylorcoeff = gsl_sf_taylorcoeff
-foreign import ccall "gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_taylorcoeff" gsl_sf_taylorcoeff :: CInt -> Double -> Double
 
 fact_e :: CInt -> (Double,Double)
 fact_e n = createSFR "fact_e" $ gsl_sf_fact_e n
-foreign import ccall "gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_fact_e" gsl_sf_fact_e :: CInt -> Ptr () -> IO CInt
 
 fact :: CInt -> Double
 fact = gsl_sf_fact
-foreign import ccall "gsl_sf_fact" gsl_sf_fact :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_fact" gsl_sf_fact :: CInt -> Double
 
 doublefact_e :: CInt -> (Double,Double)
 doublefact_e n = createSFR "doublefact_e" $ gsl_sf_doublefact_e n
-foreign import ccall "gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_doublefact_e" gsl_sf_doublefact_e :: CInt -> Ptr () -> IO CInt
 
 doublefact :: CInt -> Double
 doublefact = gsl_sf_doublefact
-foreign import ccall "gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_doublefact" gsl_sf_doublefact :: CInt -> Double
 
 lnfact_e :: CInt -> (Double,Double)
 lnfact_e n = createSFR "lnfact_e" $ gsl_sf_lnfact_e n
-foreign import ccall "gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnfact_e" gsl_sf_lnfact_e :: CInt -> Ptr () -> IO CInt
 
 lnfact :: CInt -> Double
 lnfact = gsl_sf_lnfact
-foreign import ccall "gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lnfact" gsl_sf_lnfact :: CInt -> Double
 
 lndoublefact_e :: CInt -> (Double,Double)
 lndoublefact_e n = createSFR "lndoublefact_e" $ gsl_sf_lndoublefact_e n
-foreign import ccall "gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lndoublefact_e" gsl_sf_lndoublefact_e :: CInt -> Ptr () -> IO CInt
 
 lndoublefact :: CInt -> Double
 lndoublefact = gsl_sf_lndoublefact
-foreign import ccall "gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lndoublefact" gsl_sf_lndoublefact :: CInt -> Double
 
 lnchoose_e :: CInt -> CInt -> (Double,Double)
 lnchoose_e n m = createSFR "lnchoose_e" $ gsl_sf_lnchoose_e n m
-foreign import ccall "gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnchoose_e" gsl_sf_lnchoose_e :: CInt -> CInt -> Ptr () -> IO CInt
 
 lnchoose :: CInt -> CInt -> Double
 lnchoose = gsl_sf_lnchoose
-foreign import ccall "gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lnchoose" gsl_sf_lnchoose :: CInt -> CInt -> Double
 
 choose_e :: CInt -> CInt -> (Double,Double)
 choose_e n m = createSFR "choose_e" $ gsl_sf_choose_e n m
-foreign import ccall "gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_choose_e" gsl_sf_choose_e :: CInt -> CInt -> Ptr () -> IO CInt
 
 choose :: CInt -> CInt -> Double
 choose = gsl_sf_choose
-foreign import ccall "gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_choose" gsl_sf_choose :: CInt -> CInt -> Double
 
 lnpoch_e :: Double -> Double -> (Double,Double)
 lnpoch_e a x = createSFR "lnpoch_e" $ gsl_sf_lnpoch_e a x
-foreign import ccall "gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch_e" gsl_sf_lnpoch_e :: Double -> Double -> Ptr () -> IO CInt
 
 lnpoch :: Double -> Double -> Double
 lnpoch = gsl_sf_lnpoch
-foreign import ccall "gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch" gsl_sf_lnpoch :: Double -> Double -> Double
 
 lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 lnpoch_sgn_e = gsl_sf_lnpoch_sgn_e
-foreign import ccall "gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnpoch_sgn_e" gsl_sf_lnpoch_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 
 poch_e :: Double -> Double -> (Double,Double)
 poch_e a x = createSFR "poch_e" $ gsl_sf_poch_e a x
-foreign import ccall "gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_poch_e" gsl_sf_poch_e :: Double -> Double -> Ptr () -> IO CInt
 
 poch :: Double -> Double -> Double
 poch = gsl_sf_poch
-foreign import ccall "gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_poch" gsl_sf_poch :: Double -> Double -> Double
 
 pochrel_e :: Double -> Double -> (Double,Double)
 pochrel_e a x = createSFR "pochrel_e" $ gsl_sf_pochrel_e a x
-foreign import ccall "gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_pochrel_e" gsl_sf_pochrel_e :: Double -> Double -> Ptr () -> IO CInt
 
 pochrel :: Double -> Double -> Double
 pochrel = gsl_sf_pochrel
-foreign import ccall "gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_pochrel" gsl_sf_pochrel :: Double -> Double -> Double
 
 gamma_inc_Q_e :: Double -> Double -> (Double,Double)
 gamma_inc_Q_e a x = createSFR "gamma_inc_Q_e" $ gsl_sf_gamma_inc_Q_e a x
-foreign import ccall "gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_Q_e" gsl_sf_gamma_inc_Q_e :: Double -> Double -> Ptr () -> IO CInt
 
 gamma_inc_Q :: Double -> Double -> Double
 gamma_inc_Q = gsl_sf_gamma_inc_Q
-foreign import ccall "gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_Q" gsl_sf_gamma_inc_Q :: Double -> Double -> Double
 
 gamma_inc_P_e :: Double -> Double -> (Double,Double)
 gamma_inc_P_e a x = createSFR "gamma_inc_P_e" $ gsl_sf_gamma_inc_P_e a x
-foreign import ccall "gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_P_e" gsl_sf_gamma_inc_P_e :: Double -> Double -> Ptr () -> IO CInt
 
 gamma_inc_P :: Double -> Double -> Double
 gamma_inc_P = gsl_sf_gamma_inc_P
-foreign import ccall "gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_P" gsl_sf_gamma_inc_P :: Double -> Double -> Double
 
 gamma_inc_e :: Double -> Double -> (Double,Double)
 gamma_inc_e a x = createSFR "gamma_inc_e" $ gsl_sf_gamma_inc_e a x
-foreign import ccall "gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc_e" gsl_sf_gamma_inc_e :: Double -> Double -> Ptr () -> IO CInt
 
 gamma_inc :: Double -> Double -> Double
 gamma_inc = gsl_sf_gamma_inc
-foreign import ccall "gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gamma_inc" gsl_sf_gamma_inc :: Double -> Double -> Double
 
 lnbeta_e :: Double -> Double -> (Double,Double)
 lnbeta_e a b = createSFR "lnbeta_e" $ gsl_sf_lnbeta_e a b
-foreign import ccall "gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta_e" gsl_sf_lnbeta_e :: Double -> Double -> Ptr () -> IO CInt
 
 lnbeta :: Double -> Double -> Double
 lnbeta = gsl_sf_lnbeta
-foreign import ccall "gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta" gsl_sf_lnbeta :: Double -> Double -> Double
 
 lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 lnbeta_sgn_e = gsl_sf_lnbeta_sgn_e
-foreign import ccall "gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnbeta_sgn_e" gsl_sf_lnbeta_sgn_e :: Double -> Double -> Ptr () -> Ptr Double -> CInt
 
 beta_e :: Double -> Double -> (Double,Double)
 beta_e a b = createSFR "beta_e" $ gsl_sf_beta_e a b
-foreign import ccall "gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_beta_e" gsl_sf_beta_e :: Double -> Double -> Ptr () -> IO CInt
 
 beta :: Double -> Double -> Double
 beta = gsl_sf_beta
-foreign import ccall "gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_beta" gsl_sf_beta :: Double -> Double -> Double
 
 beta_inc_e :: Double -> Double -> Double -> (Double,Double)
 beta_inc_e a b x = createSFR "beta_inc_e" $ gsl_sf_beta_inc_e a b x
-foreign import ccall "gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_beta_inc_e" gsl_sf_beta_inc_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 beta_inc :: Double -> Double -> Double -> Double
 beta_inc = gsl_sf_beta_inc
-foreign import ccall "gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_beta_inc" gsl_sf_beta_inc :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Gegenbauer.hs b/lib/Numeric/GSL/Special/Gegenbauer.hs
index 29822b2..31568f3 100644
--- a/lib/Numeric/GSL/Special/Gegenbauer.hs
+++ b/lib/Numeric/GSL/Special/Gegenbauer.hs
@@ -29,36 +29,36 @@ import Numeric.GSL.Special.Internal
 
 gegenpoly_1_e :: Double -> Double -> (Double,Double)
 gegenpoly_1_e lambda x = createSFR "gegenpoly_1_e" $ gsl_sf_gegenpoly_1_e lambda x
-foreign import ccall "gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_1_e" gsl_sf_gegenpoly_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 gegenpoly_2_e :: Double -> Double -> (Double,Double)
 gegenpoly_2_e lambda x = createSFR "gegenpoly_2_e" $ gsl_sf_gegenpoly_2_e lambda x
-foreign import ccall "gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_2_e" gsl_sf_gegenpoly_2_e :: Double -> Double -> Ptr () -> IO CInt
 
 gegenpoly_3_e :: Double -> Double -> (Double,Double)
 gegenpoly_3_e lambda x = createSFR "gegenpoly_3_e" $ gsl_sf_gegenpoly_3_e lambda x
-foreign import ccall "gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_3_e" gsl_sf_gegenpoly_3_e :: Double -> Double -> Ptr () -> IO CInt
 
 gegenpoly_1 :: Double -> Double -> Double
 gegenpoly_1 = gsl_sf_gegenpoly_1
-foreign import ccall "gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_1" gsl_sf_gegenpoly_1 :: Double -> Double -> Double
 
 gegenpoly_2 :: Double -> Double -> Double
 gegenpoly_2 = gsl_sf_gegenpoly_2
-foreign import ccall "gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_2" gsl_sf_gegenpoly_2 :: Double -> Double -> Double
 
 gegenpoly_3 :: Double -> Double -> Double
 gegenpoly_3 = gsl_sf_gegenpoly_3
-foreign import ccall "gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_3" gsl_sf_gegenpoly_3 :: Double -> Double -> Double
 
 gegenpoly_n_e :: CInt -> Double -> Double -> (Double,Double)
 gegenpoly_n_e n lambda x = createSFR "gegenpoly_n_e" $ gsl_sf_gegenpoly_n_e n lambda x
-foreign import ccall "gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_n_e" gsl_sf_gegenpoly_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 gegenpoly_n :: CInt -> Double -> Double -> Double
 gegenpoly_n = gsl_sf_gegenpoly_n
-foreign import ccall "gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_n" gsl_sf_gegenpoly_n :: CInt -> Double -> Double -> Double
 
 gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
 gegenpoly_array = gsl_sf_gegenpoly_array
-foreign import ccall "gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_gegenpoly_array" gsl_sf_gegenpoly_array :: CInt -> Double -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Hyperg.hs b/lib/Numeric/GSL/Special/Hyperg.hs
index 492632b..b5425f1 100644
--- a/lib/Numeric/GSL/Special/Hyperg.hs
+++ b/lib/Numeric/GSL/Special/Hyperg.hs
@@ -43,88 +43,88 @@ import Numeric.GSL.Special.Internal
 
 hyperg_0F1_e :: Double -> Double -> (Double,Double)
 hyperg_0F1_e c x = createSFR "hyperg_0F1_e" $ gsl_sf_hyperg_0F1_e c x
-foreign import ccall "gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_0F1_e" gsl_sf_hyperg_0F1_e :: Double -> Double -> Ptr () -> IO CInt
 
 hyperg_0F1 :: Double -> Double -> Double
 hyperg_0F1 = gsl_sf_hyperg_0F1
-foreign import ccall "gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_0F1" gsl_sf_hyperg_0F1 :: Double -> Double -> Double
 
 hyperg_1F1_int_e :: CInt -> CInt -> Double -> (Double,Double)
 hyperg_1F1_int_e m n x = createSFR "hyperg_1F1_int_e" $ gsl_sf_hyperg_1F1_int_e m n x
-foreign import ccall "gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1_int_e" gsl_sf_hyperg_1F1_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 hyperg_1F1_int :: CInt -> CInt -> Double -> Double
 hyperg_1F1_int = gsl_sf_hyperg_1F1_int
-foreign import ccall "gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1_int" gsl_sf_hyperg_1F1_int :: CInt -> CInt -> Double -> Double
 
 hyperg_1F1_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_1F1_e a b x = createSFR "hyperg_1F1_e" $ gsl_sf_hyperg_1F1_e a b x
-foreign import ccall "gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1_e" gsl_sf_hyperg_1F1_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_1F1 :: Double -> Double -> Double -> Double
 hyperg_1F1 = gsl_sf_hyperg_1F1
-foreign import ccall "gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_1F1" gsl_sf_hyperg_1F1 :: Double -> Double -> Double -> Double
 
 hyperg_U_int_e :: CInt -> CInt -> Double -> (Double,Double)
 hyperg_U_int_e m n x = createSFR "hyperg_U_int_e" $ gsl_sf_hyperg_U_int_e m n x
-foreign import ccall "gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_int_e" gsl_sf_hyperg_U_int_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 hyperg_U_int :: CInt -> CInt -> Double -> Double
 hyperg_U_int = gsl_sf_hyperg_U_int
-foreign import ccall "gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_int" gsl_sf_hyperg_U_int :: CInt -> CInt -> Double -> Double
 
 hyperg_U_int_e10_e :: CInt -> CInt -> Double -> (Double,Int,Double)
 hyperg_U_int_e10_e m n x = createSFR_E10 "hyperg_U_int_e10_e" $ gsl_sf_hyperg_U_int_e10_e m n x
-foreign import ccall "gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_int_e10_e" gsl_sf_hyperg_U_int_e10_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 hyperg_U_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_U_e a b x = createSFR "hyperg_U_e" $ gsl_sf_hyperg_U_e a b x
-foreign import ccall "gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_e" gsl_sf_hyperg_U_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_U :: Double -> Double -> Double -> Double
 hyperg_U = gsl_sf_hyperg_U
-foreign import ccall "gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U" gsl_sf_hyperg_U :: Double -> Double -> Double -> Double
 
 hyperg_U_e10_e :: Double -> Double -> Double -> (Double,Int,Double)
 hyperg_U_e10_e a b x = createSFR_E10 "hyperg_U_e10_e" $ gsl_sf_hyperg_U_e10_e a b x
-foreign import ccall "gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_U_e10_e" gsl_sf_hyperg_U_e10_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F1_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_e a b c x = createSFR "hyperg_2F1_e" $ gsl_sf_hyperg_2F1_e a b c x
-foreign import ccall "gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_e" gsl_sf_hyperg_2F1_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1 = gsl_sf_hyperg_2F1
-foreign import ccall "gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1" gsl_sf_hyperg_2F1 :: Double -> Double -> Double -> Double -> Double
 
 hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_conj_e aR aI c x = createSFR "hyperg_2F1_conj_e" $ gsl_sf_hyperg_2F1_conj_e aR aI c x
-foreign import ccall "gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_e" gsl_sf_hyperg_2F1_conj_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_conj = gsl_sf_hyperg_2F1_conj
-foreign import ccall "gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj" gsl_sf_hyperg_2F1_conj :: Double -> Double -> Double -> Double -> Double
 
 hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_renorm_e a b c x = createSFR "hyperg_2F1_renorm_e" $ gsl_sf_hyperg_2F1_renorm_e a b c x
-foreign import ccall "gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_renorm_e" gsl_sf_hyperg_2F1_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_renorm = gsl_sf_hyperg_2F1_renorm
-foreign import ccall "gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_renorm" gsl_sf_hyperg_2F1_renorm :: Double -> Double -> Double -> Double -> Double
 
 hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> (Double,Double)
 hyperg_2F1_conj_renorm_e aR aI c x = createSFR "hyperg_2F1_conj_renorm_e" $ gsl_sf_hyperg_2F1_conj_renorm_e aR aI c x
-foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_renorm_e" gsl_sf_hyperg_2F1_conj_renorm_e :: Double -> Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
 hyperg_2F1_conj_renorm = gsl_sf_hyperg_2F1_conj_renorm
-foreign import ccall "gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F1_conj_renorm" gsl_sf_hyperg_2F1_conj_renorm :: Double -> Double -> Double -> Double -> Double
 
 hyperg_2F0_e :: Double -> Double -> Double -> (Double,Double)
 hyperg_2F0_e a b x = createSFR "hyperg_2F0_e" $ gsl_sf_hyperg_2F0_e a b x
-foreign import ccall "gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F0_e" gsl_sf_hyperg_2F0_e :: Double -> Double -> Double -> Ptr () -> IO CInt
 
 hyperg_2F0 :: Double -> Double -> Double -> Double
 hyperg_2F0 = gsl_sf_hyperg_2F0
-foreign import ccall "gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hyperg_2F0" gsl_sf_hyperg_2F0 :: Double -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Laguerre.hs b/lib/Numeric/GSL/Special/Laguerre.hs
index b763441..8db6a6c 100644
--- a/lib/Numeric/GSL/Special/Laguerre.hs
+++ b/lib/Numeric/GSL/Special/Laguerre.hs
@@ -29,32 +29,32 @@ import Numeric.GSL.Special.Internal
 
 laguerre_1_e :: Double -> Double -> (Double,Double)
 laguerre_1_e a x = createSFR "laguerre_1_e" $ gsl_sf_laguerre_1_e a x
-foreign import ccall "gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_1_e" gsl_sf_laguerre_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 laguerre_2_e :: Double -> Double -> (Double,Double)
 laguerre_2_e a x = createSFR "laguerre_2_e" $ gsl_sf_laguerre_2_e a x
-foreign import ccall "gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_2_e" gsl_sf_laguerre_2_e :: Double -> Double -> Ptr () -> IO CInt
 
 laguerre_3_e :: Double -> Double -> (Double,Double)
 laguerre_3_e a x = createSFR "laguerre_3_e" $ gsl_sf_laguerre_3_e a x
-foreign import ccall "gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_3_e" gsl_sf_laguerre_3_e :: Double -> Double -> Ptr () -> IO CInt
 
 laguerre_1 :: Double -> Double -> Double
 laguerre_1 = gsl_sf_laguerre_1
-foreign import ccall "gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_1" gsl_sf_laguerre_1 :: Double -> Double -> Double
 
 laguerre_2 :: Double -> Double -> Double
 laguerre_2 = gsl_sf_laguerre_2
-foreign import ccall "gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_2" gsl_sf_laguerre_2 :: Double -> Double -> Double
 
 laguerre_3 :: Double -> Double -> Double
 laguerre_3 = gsl_sf_laguerre_3
-foreign import ccall "gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_3" gsl_sf_laguerre_3 :: Double -> Double -> Double
 
 laguerre_n_e :: CInt -> Double -> Double -> (Double,Double)
 laguerre_n_e n a x = createSFR "laguerre_n_e" $ gsl_sf_laguerre_n_e n a x
-foreign import ccall "gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_n_e" gsl_sf_laguerre_n_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 laguerre_n :: CInt -> Double -> Double -> Double
 laguerre_n = gsl_sf_laguerre_n
-foreign import ccall "gsl_sf_laguerre_n" gsl_sf_laguerre_n :: CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_laguerre_n" gsl_sf_laguerre_n :: CInt -> Double -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Lambert.hs b/lib/Numeric/GSL/Special/Lambert.hs
index 06af09c..b229bf6 100644
--- a/lib/Numeric/GSL/Special/Lambert.hs
+++ b/lib/Numeric/GSL/Special/Lambert.hs
@@ -25,16 +25,16 @@ import Numeric.GSL.Special.Internal
 
 lambert_W0_e :: Double -> (Double,Double)
 lambert_W0_e x = createSFR "lambert_W0_e" $ gsl_sf_lambert_W0_e x
-foreign import ccall "gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_W0_e" gsl_sf_lambert_W0_e :: Double -> Ptr () -> IO CInt
 
 lambert_W0 :: Double -> Double
 lambert_W0 = gsl_sf_lambert_W0
-foreign import ccall "gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_W0" gsl_sf_lambert_W0 :: Double -> Double
 
 lambert_Wm1_e :: Double -> (Double,Double)
 lambert_Wm1_e x = createSFR "lambert_Wm1_e" $ gsl_sf_lambert_Wm1_e x
-foreign import ccall "gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_Wm1_e" gsl_sf_lambert_Wm1_e :: Double -> Ptr () -> IO CInt
 
 lambert_Wm1 :: Double -> Double
 lambert_Wm1 = gsl_sf_lambert_Wm1
-foreign import ccall "gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lambert_Wm1" gsl_sf_lambert_Wm1 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Legendre.hs b/lib/Numeric/GSL/Special/Legendre.hs
index 5a74773..e329457 100644
--- a/lib/Numeric/GSL/Special/Legendre.hs
+++ b/lib/Numeric/GSL/Special/Legendre.hs
@@ -58,176 +58,176 @@ import Numeric.GSL.Special.Internal
 
 legendre_Pl_e :: CInt -> Double -> (Double,Double)
 legendre_Pl_e l x = createSFR "legendre_Pl_e" $ gsl_sf_legendre_Pl_e l x
-foreign import ccall "gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_e" gsl_sf_legendre_Pl_e :: CInt -> Double -> Ptr () -> IO CInt
 
 legendre_Pl :: CInt -> Double -> Double
 legendre_Pl = gsl_sf_legendre_Pl
-foreign import ccall "gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl" gsl_sf_legendre_Pl :: CInt -> Double -> Double
 
 legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
 legendre_Pl_array = gsl_sf_legendre_Pl_array
-foreign import ccall "gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_array" gsl_sf_legendre_Pl_array :: CInt -> Double -> Ptr Double -> CInt
 
 legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 legendre_Pl_deriv_array = gsl_sf_legendre_Pl_deriv_array
-foreign import ccall "gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Pl_deriv_array" gsl_sf_legendre_Pl_deriv_array :: CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 legendre_P1_e :: Double -> (Double,Double)
 legendre_P1_e x = createSFR "legendre_P1_e" $ gsl_sf_legendre_P1_e x
-foreign import ccall "gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P1_e" gsl_sf_legendre_P1_e :: Double -> Ptr () -> IO CInt
 
 legendre_P2_e :: Double -> (Double,Double)
 legendre_P2_e x = createSFR "legendre_P2_e" $ gsl_sf_legendre_P2_e x
-foreign import ccall "gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P2_e" gsl_sf_legendre_P2_e :: Double -> Ptr () -> IO CInt
 
 legendre_P3_e :: Double -> (Double,Double)
 legendre_P3_e x = createSFR "legendre_P3_e" $ gsl_sf_legendre_P3_e x
-foreign import ccall "gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P3_e" gsl_sf_legendre_P3_e :: Double -> Ptr () -> IO CInt
 
 legendre_P1 :: Double -> Double
 legendre_P1 = gsl_sf_legendre_P1
-foreign import ccall "gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P1" gsl_sf_legendre_P1 :: Double -> Double
 
 legendre_P2 :: Double -> Double
 legendre_P2 = gsl_sf_legendre_P2
-foreign import ccall "gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P2" gsl_sf_legendre_P2 :: Double -> Double
 
 legendre_P3 :: Double -> Double
 legendre_P3 = gsl_sf_legendre_P3
-foreign import ccall "gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_P3" gsl_sf_legendre_P3 :: Double -> Double
 
 legendre_Q0_e :: Double -> (Double,Double)
 legendre_Q0_e x = createSFR "legendre_Q0_e" $ gsl_sf_legendre_Q0_e x
-foreign import ccall "gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q0_e" gsl_sf_legendre_Q0_e :: Double -> Ptr () -> IO CInt
 
 legendre_Q0 :: Double -> Double
 legendre_Q0 = gsl_sf_legendre_Q0
-foreign import ccall "gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q0" gsl_sf_legendre_Q0 :: Double -> Double
 
 legendre_Q1_e :: Double -> (Double,Double)
 legendre_Q1_e x = createSFR "legendre_Q1_e" $ gsl_sf_legendre_Q1_e x
-foreign import ccall "gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q1_e" gsl_sf_legendre_Q1_e :: Double -> Ptr () -> IO CInt
 
 legendre_Q1 :: Double -> Double
 legendre_Q1 = gsl_sf_legendre_Q1
-foreign import ccall "gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Q1" gsl_sf_legendre_Q1 :: Double -> Double
 
 legendre_Ql_e :: CInt -> Double -> (Double,Double)
 legendre_Ql_e l x = createSFR "legendre_Ql_e" $ gsl_sf_legendre_Ql_e l x
-foreign import ccall "gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Ql_e" gsl_sf_legendre_Ql_e :: CInt -> Double -> Ptr () -> IO CInt
 
 legendre_Ql :: CInt -> Double -> Double
 legendre_Ql = gsl_sf_legendre_Ql
-foreign import ccall "gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Ql" gsl_sf_legendre_Ql :: CInt -> Double -> Double
 
 legendre_Plm_e :: CInt -> CInt -> Double -> (Double,Double)
 legendre_Plm_e l m x = createSFR "legendre_Plm_e" $ gsl_sf_legendre_Plm_e l m x
-foreign import ccall "gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_e" gsl_sf_legendre_Plm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 legendre_Plm :: CInt -> CInt -> Double -> Double
 legendre_Plm = gsl_sf_legendre_Plm
-foreign import ccall "gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm" gsl_sf_legendre_Plm :: CInt -> CInt -> Double -> Double
 
 legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 legendre_Plm_array = gsl_sf_legendre_Plm_array
-foreign import ccall "gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_array" gsl_sf_legendre_Plm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 legendre_Plm_deriv_array = gsl_sf_legendre_Plm_deriv_array
-foreign import ccall "gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_Plm_deriv_array" gsl_sf_legendre_Plm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 legendre_sphPlm_e :: CInt -> CInt -> Double -> (Double,Double)
 legendre_sphPlm_e l m x = createSFR "legendre_sphPlm_e" $ gsl_sf_legendre_sphPlm_e l m x
-foreign import ccall "gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_e" gsl_sf_legendre_sphPlm_e :: CInt -> CInt -> Double -> Ptr () -> IO CInt
 
 legendre_sphPlm :: CInt -> CInt -> Double -> Double
 legendre_sphPlm = gsl_sf_legendre_sphPlm
-foreign import ccall "gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm" gsl_sf_legendre_sphPlm :: CInt -> CInt -> Double -> Double
 
 legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 legendre_sphPlm_array = gsl_sf_legendre_sphPlm_array
-foreign import ccall "gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_array" gsl_sf_legendre_sphPlm_array :: CInt -> CInt -> Double -> Ptr Double -> CInt
 
 legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 legendre_sphPlm_deriv_array = gsl_sf_legendre_sphPlm_deriv_array
-foreign import ccall "gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_sphPlm_deriv_array" gsl_sf_legendre_sphPlm_deriv_array :: CInt -> CInt -> Double -> Ptr Double -> Ptr Double -> CInt
 
 legendre_array_size :: CInt -> CInt -> CInt
 legendre_array_size = gsl_sf_legendre_array_size
-foreign import ccall "gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_array_size" gsl_sf_legendre_array_size :: CInt -> CInt -> CInt
 
 conicalP_half_e :: Double -> Double -> (Double,Double)
 conicalP_half_e lambda x = createSFR "conicalP_half_e" $ gsl_sf_conicalP_half_e lambda x
-foreign import ccall "gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_half_e" gsl_sf_conicalP_half_e :: Double -> Double -> Ptr () -> IO CInt
 
 conicalP_half :: Double -> Double -> Double
 conicalP_half = gsl_sf_conicalP_half
-foreign import ccall "gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_half" gsl_sf_conicalP_half :: Double -> Double -> Double
 
 conicalP_mhalf_e :: Double -> Double -> (Double,Double)
 conicalP_mhalf_e lambda x = createSFR "conicalP_mhalf_e" $ gsl_sf_conicalP_mhalf_e lambda x
-foreign import ccall "gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_mhalf_e" gsl_sf_conicalP_mhalf_e :: Double -> Double -> Ptr () -> IO CInt
 
 conicalP_mhalf :: Double -> Double -> Double
 conicalP_mhalf = gsl_sf_conicalP_mhalf
-foreign import ccall "gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_mhalf" gsl_sf_conicalP_mhalf :: Double -> Double -> Double
 
 conicalP_0_e :: Double -> Double -> (Double,Double)
 conicalP_0_e lambda x = createSFR "conicalP_0_e" $ gsl_sf_conicalP_0_e lambda x
-foreign import ccall "gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_0_e" gsl_sf_conicalP_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 conicalP_0 :: Double -> Double -> Double
 conicalP_0 = gsl_sf_conicalP_0
-foreign import ccall "gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_0" gsl_sf_conicalP_0 :: Double -> Double -> Double
 
 conicalP_1_e :: Double -> Double -> (Double,Double)
 conicalP_1_e lambda x = createSFR "conicalP_1_e" $ gsl_sf_conicalP_1_e lambda x
-foreign import ccall "gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_1_e" gsl_sf_conicalP_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 conicalP_1 :: Double -> Double -> Double
 conicalP_1 = gsl_sf_conicalP_1
-foreign import ccall "gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_1" gsl_sf_conicalP_1 :: Double -> Double -> Double
 
 conicalP_sph_reg_e :: CInt -> Double -> Double -> (Double,Double)
 conicalP_sph_reg_e l lambda x = createSFR "conicalP_sph_reg_e" $ gsl_sf_conicalP_sph_reg_e l lambda x
-foreign import ccall "gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_sph_reg_e" gsl_sf_conicalP_sph_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 conicalP_sph_reg :: CInt -> Double -> Double -> Double
 conicalP_sph_reg = gsl_sf_conicalP_sph_reg
-foreign import ccall "gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_sph_reg" gsl_sf_conicalP_sph_reg :: CInt -> Double -> Double -> Double
 
 conicalP_cyl_reg_e :: CInt -> Double -> Double -> (Double,Double)
 conicalP_cyl_reg_e m lambda x = createSFR "conicalP_cyl_reg_e" $ gsl_sf_conicalP_cyl_reg_e m lambda x
-foreign import ccall "gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_cyl_reg_e" gsl_sf_conicalP_cyl_reg_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 conicalP_cyl_reg :: CInt -> Double -> Double -> Double
 conicalP_cyl_reg = gsl_sf_conicalP_cyl_reg
-foreign import ccall "gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_conicalP_cyl_reg" gsl_sf_conicalP_cyl_reg :: CInt -> Double -> Double -> Double
 
 legendre_H3d_0_e :: Double -> Double -> (Double,Double)
 legendre_H3d_0_e lambda eta = createSFR "legendre_H3d_0_e" $ gsl_sf_legendre_H3d_0_e lambda eta
-foreign import ccall "gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_0_e" gsl_sf_legendre_H3d_0_e :: Double -> Double -> Ptr () -> IO CInt
 
 legendre_H3d_0 :: Double -> Double -> Double
 legendre_H3d_0 = gsl_sf_legendre_H3d_0
-foreign import ccall "gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_0" gsl_sf_legendre_H3d_0 :: Double -> Double -> Double
 
 legendre_H3d_1_e :: Double -> Double -> (Double,Double)
 legendre_H3d_1_e lambda eta = createSFR "legendre_H3d_1_e" $ gsl_sf_legendre_H3d_1_e lambda eta
-foreign import ccall "gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_1_e" gsl_sf_legendre_H3d_1_e :: Double -> Double -> Ptr () -> IO CInt
 
 legendre_H3d_1 :: Double -> Double -> Double
 legendre_H3d_1 = gsl_sf_legendre_H3d_1
-foreign import ccall "gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_1" gsl_sf_legendre_H3d_1 :: Double -> Double -> Double
 
 legendre_H3d_e :: CInt -> Double -> Double -> (Double,Double)
 legendre_H3d_e l lambda eta = createSFR "legendre_H3d_e" $ gsl_sf_legendre_H3d_e l lambda eta
-foreign import ccall "gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_e" gsl_sf_legendre_H3d_e :: CInt -> Double -> Double -> Ptr () -> IO CInt
 
 legendre_H3d :: CInt -> Double -> Double -> Double
 legendre_H3d = gsl_sf_legendre_H3d
-foreign import ccall "gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d" gsl_sf_legendre_H3d :: CInt -> Double -> Double -> Double
 
 legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
 legendre_H3d_array = gsl_sf_legendre_H3d_array
-foreign import ccall "gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_legendre_H3d_array" gsl_sf_legendre_H3d_array :: CInt -> Double -> Double -> Ptr Double -> CInt
diff --git a/lib/Numeric/GSL/Special/Log.hs b/lib/Numeric/GSL/Special/Log.hs
index ad8adaf..a57b67a 100644
--- a/lib/Numeric/GSL/Special/Log.hs
+++ b/lib/Numeric/GSL/Special/Log.hs
@@ -29,36 +29,36 @@ import Numeric.GSL.Special.Internal
 
 log_e :: Double -> (Double,Double)
 log_e x = createSFR "log_e" $ gsl_sf_log_e x
-foreign import ccall "gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_log_e" gsl_sf_log_e :: Double -> Ptr () -> IO CInt
 
 log :: Double -> Double
 log = gsl_sf_log
-foreign import ccall "gsl_sf_log" gsl_sf_log :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_log" gsl_sf_log :: Double -> Double
 
 log_abs_e :: Double -> (Double,Double)
 log_abs_e x = createSFR "log_abs_e" $ gsl_sf_log_abs_e x
-foreign import ccall "gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_log_abs_e" gsl_sf_log_abs_e :: Double -> Ptr () -> IO CInt
 
 log_abs :: Double -> Double
 log_abs = gsl_sf_log_abs
-foreign import ccall "gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_log_abs" gsl_sf_log_abs :: Double -> Double
 
 complex_log_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_log_e zr zi lnr = createSFR "complex_log_e" $ gsl_sf_complex_log_e zr zi lnr
-foreign import ccall "gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_log_e" gsl_sf_complex_log_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 log_1plusx_e :: Double -> (Double,Double)
 log_1plusx_e x = createSFR "log_1plusx_e" $ gsl_sf_log_1plusx_e x
-foreign import ccall "gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx_e" gsl_sf_log_1plusx_e :: Double -> Ptr () -> IO CInt
 
 log_1plusx :: Double -> Double
 log_1plusx = gsl_sf_log_1plusx
-foreign import ccall "gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx" gsl_sf_log_1plusx :: Double -> Double
 
 log_1plusx_mx_e :: Double -> (Double,Double)
 log_1plusx_mx_e x = createSFR "log_1plusx_mx_e" $ gsl_sf_log_1plusx_mx_e x
-foreign import ccall "gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx_mx_e" gsl_sf_log_1plusx_mx_e :: Double -> Ptr () -> IO CInt
 
 log_1plusx_mx :: Double -> Double
 log_1plusx_mx = gsl_sf_log_1plusx_mx
-foreign import ccall "gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_log_1plusx_mx" gsl_sf_log_1plusx_mx :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Pow_int.hs b/lib/Numeric/GSL/Special/Pow_int.hs
index d98bd57..fd232ab 100644
--- a/lib/Numeric/GSL/Special/Pow_int.hs
+++ b/lib/Numeric/GSL/Special/Pow_int.hs
@@ -23,8 +23,8 @@ import Numeric.GSL.Special.Internal
 
 pow_int_e :: Double -> CInt -> (Double,Double)
 pow_int_e x n = createSFR "pow_int_e" $ gsl_sf_pow_int_e x n
-foreign import ccall "gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_pow_int_e" gsl_sf_pow_int_e :: Double -> CInt -> Ptr () -> IO CInt
 
 pow_int :: Double -> CInt -> Double
 pow_int = gsl_sf_pow_int
-foreign import ccall "gsl_sf_pow_int" gsl_sf_pow_int :: Double -> CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_pow_int" gsl_sf_pow_int :: Double -> CInt -> Double
diff --git a/lib/Numeric/GSL/Special/Psi.hs b/lib/Numeric/GSL/Special/Psi.hs
index 06c1da0..4655b8c 100644
--- a/lib/Numeric/GSL/Special/Psi.hs
+++ b/lib/Numeric/GSL/Special/Psi.hs
@@ -33,52 +33,52 @@ import Numeric.GSL.Special.Internal
 
 psi_int_e :: CInt -> (Double,Double)
 psi_int_e n = createSFR "psi_int_e" $ gsl_sf_psi_int_e n
-foreign import ccall "gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_int_e" gsl_sf_psi_int_e :: CInt -> Ptr () -> IO CInt
 
 psi_int :: CInt -> Double
 psi_int = gsl_sf_psi_int
-foreign import ccall "gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_int" gsl_sf_psi_int :: CInt -> Double
 
 psi_e :: Double -> (Double,Double)
 psi_e x = createSFR "psi_e" $ gsl_sf_psi_e x
-foreign import ccall "gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_e" gsl_sf_psi_e :: Double -> Ptr () -> IO CInt
 
 psi :: Double -> Double
 psi = gsl_sf_psi
-foreign import ccall "gsl_sf_psi" gsl_sf_psi :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi" gsl_sf_psi :: Double -> Double
 
 psi_1piy_e :: Double -> (Double,Double)
 psi_1piy_e y = createSFR "psi_1piy_e" $ gsl_sf_psi_1piy_e y
-foreign import ccall "gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1piy_e" gsl_sf_psi_1piy_e :: Double -> Ptr () -> IO CInt
 
 psi_1piy :: Double -> Double
 psi_1piy = gsl_sf_psi_1piy
-foreign import ccall "gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1piy" gsl_sf_psi_1piy :: Double -> Double
 
 complex_psi_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_psi_e x y result_re = createSFR "complex_psi_e" $ gsl_sf_complex_psi_e x y result_re
-foreign import ccall "gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_psi_e" gsl_sf_complex_psi_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 psi_1_int_e :: CInt -> (Double,Double)
 psi_1_int_e n = createSFR "psi_1_int_e" $ gsl_sf_psi_1_int_e n
-foreign import ccall "gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_int_e" gsl_sf_psi_1_int_e :: CInt -> Ptr () -> IO CInt
 
 psi_1_int :: CInt -> Double
 psi_1_int = gsl_sf_psi_1_int
-foreign import ccall "gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_int" gsl_sf_psi_1_int :: CInt -> Double
 
 psi_1_e :: Double -> (Double,Double)
 psi_1_e x = createSFR "psi_1_e" $ gsl_sf_psi_1_e x
-foreign import ccall "gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1_e" gsl_sf_psi_1_e :: Double -> Ptr () -> IO CInt
 
 psi_1 :: Double -> Double
 psi_1 = gsl_sf_psi_1
-foreign import ccall "gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_1" gsl_sf_psi_1 :: Double -> Double
 
 psi_n_e :: CInt -> Double -> (Double,Double)
 psi_n_e n x = createSFR "psi_n_e" $ gsl_sf_psi_n_e n x
-foreign import ccall "gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_n_e" gsl_sf_psi_n_e :: CInt -> Double -> Ptr () -> IO CInt
 
 psi_n :: CInt -> Double -> Double
 psi_n = gsl_sf_psi_n
-foreign import ccall "gsl_sf_psi_n" gsl_sf_psi_n :: CInt -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_psi_n" gsl_sf_psi_n :: CInt -> Double -> Double
diff --git a/lib/Numeric/GSL/Special/Synchrotron.hs b/lib/Numeric/GSL/Special/Synchrotron.hs
index 48381e4..59d6c76 100644
--- a/lib/Numeric/GSL/Special/Synchrotron.hs
+++ b/lib/Numeric/GSL/Special/Synchrotron.hs
@@ -25,16 +25,16 @@ import Numeric.GSL.Special.Internal
 
 synchrotron_1_e :: Double -> (Double,Double)
 synchrotron_1_e x = createSFR "synchrotron_1_e" $ gsl_sf_synchrotron_1_e x
-foreign import ccall "gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_1_e" gsl_sf_synchrotron_1_e :: Double -> Ptr () -> IO CInt
 
 synchrotron_1 :: Double -> Double
 synchrotron_1 = gsl_sf_synchrotron_1
-foreign import ccall "gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_1" gsl_sf_synchrotron_1 :: Double -> Double
 
 synchrotron_2_e :: Double -> (Double,Double)
 synchrotron_2_e x = createSFR "synchrotron_2_e" $ gsl_sf_synchrotron_2_e x
-foreign import ccall "gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_2_e" gsl_sf_synchrotron_2_e :: Double -> Ptr () -> IO CInt
 
 synchrotron_2 :: Double -> Double
 synchrotron_2 = gsl_sf_synchrotron_2
-foreign import ccall "gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_synchrotron_2" gsl_sf_synchrotron_2 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Transport.hs b/lib/Numeric/GSL/Special/Transport.hs
index e8076d0..e95a67a 100644
--- a/lib/Numeric/GSL/Special/Transport.hs
+++ b/lib/Numeric/GSL/Special/Transport.hs
@@ -29,32 +29,32 @@ import Numeric.GSL.Special.Internal
 
 transport_2_e :: Double -> (Double,Double)
 transport_2_e x = createSFR "transport_2_e" $ gsl_sf_transport_2_e x
-foreign import ccall "gsl_sf_transport_2_e" gsl_sf_transport_2_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_2_e" gsl_sf_transport_2_e :: Double -> Ptr () -> IO CInt
 
 transport_2 :: Double -> Double
 transport_2 = gsl_sf_transport_2
-foreign import ccall "gsl_sf_transport_2" gsl_sf_transport_2 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_2" gsl_sf_transport_2 :: Double -> Double
 
 transport_3_e :: Double -> (Double,Double)
 transport_3_e x = createSFR "transport_3_e" $ gsl_sf_transport_3_e x
-foreign import ccall "gsl_sf_transport_3_e" gsl_sf_transport_3_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_3_e" gsl_sf_transport_3_e :: Double -> Ptr () -> IO CInt
 
 transport_3 :: Double -> Double
 transport_3 = gsl_sf_transport_3
-foreign import ccall "gsl_sf_transport_3" gsl_sf_transport_3 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_3" gsl_sf_transport_3 :: Double -> Double
 
 transport_4_e :: Double -> (Double,Double)
 transport_4_e x = createSFR "transport_4_e" $ gsl_sf_transport_4_e x
-foreign import ccall "gsl_sf_transport_4_e" gsl_sf_transport_4_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_4_e" gsl_sf_transport_4_e :: Double -> Ptr () -> IO CInt
 
 transport_4 :: Double -> Double
 transport_4 = gsl_sf_transport_4
-foreign import ccall "gsl_sf_transport_4" gsl_sf_transport_4 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_4" gsl_sf_transport_4 :: Double -> Double
 
 transport_5_e :: Double -> (Double,Double)
 transport_5_e x = createSFR "transport_5_e" $ gsl_sf_transport_5_e x
-foreign import ccall "gsl_sf_transport_5_e" gsl_sf_transport_5_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_5_e" gsl_sf_transport_5_e :: Double -> Ptr () -> IO CInt
 
 transport_5 :: Double -> Double
 transport_5 = gsl_sf_transport_5
-foreign import ccall "gsl_sf_transport_5" gsl_sf_transport_5 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_transport_5" gsl_sf_transport_5 :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/Trig.hs b/lib/Numeric/GSL/Special/Trig.hs
index 33e598c..4b7ae67 100644
--- a/lib/Numeric/GSL/Special/Trig.hs
+++ b/lib/Numeric/GSL/Special/Trig.hs
@@ -39,100 +39,100 @@ import Numeric.GSL.Special.Internal
 
 sin_e :: Double -> (Double,Double)
 sin_e x = createSFR "sin_e" $ gsl_sf_sin_e x
-foreign import ccall "gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_sin_e" gsl_sf_sin_e :: Double -> Ptr () -> IO CInt
 
 sin :: Double -> Double
 sin = gsl_sf_sin
-foreign import ccall "gsl_sf_sin" gsl_sf_sin :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_sin" gsl_sf_sin :: Double -> Double
 
 cos_e :: Double -> (Double,Double)
 cos_e x = createSFR "cos_e" $ gsl_sf_cos_e x
-foreign import ccall "gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_cos_e" gsl_sf_cos_e :: Double -> Ptr () -> IO CInt
 
 cos :: Double -> Double
 cos = gsl_sf_cos
-foreign import ccall "gsl_sf_cos" gsl_sf_cos :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_cos" gsl_sf_cos :: Double -> Double
 
 hypot_e :: Double -> Double -> (Double,Double)
 hypot_e x y = createSFR "hypot_e" $ gsl_sf_hypot_e x y
-foreign import ccall "gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hypot_e" gsl_sf_hypot_e :: Double -> Double -> Ptr () -> IO CInt
 
 hypot :: Double -> Double -> Double
 hypot = gsl_sf_hypot
-foreign import ccall "gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hypot" gsl_sf_hypot :: Double -> Double -> Double
 
 complex_sin_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_sin_e zr zi szr = createSFR "complex_sin_e" $ gsl_sf_complex_sin_e zr zi szr
-foreign import ccall "gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_sin_e" gsl_sf_complex_sin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 complex_cos_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_cos_e zr zi czr = createSFR "complex_cos_e" $ gsl_sf_complex_cos_e zr zi czr
-foreign import ccall "gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_cos_e" gsl_sf_complex_cos_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 complex_logsin_e :: Double -> Double -> Ptr () -> (Double,Double)
 complex_logsin_e zr zi lszr = createSFR "complex_logsin_e" $ gsl_sf_complex_logsin_e zr zi lszr
-foreign import ccall "gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_complex_logsin_e" gsl_sf_complex_logsin_e :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 sinc_e :: Double -> (Double,Double)
 sinc_e x = createSFR "sinc_e" $ gsl_sf_sinc_e x
-foreign import ccall "gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_sinc_e" gsl_sf_sinc_e :: Double -> Ptr () -> IO CInt
 
 sinc :: Double -> Double
 sinc = gsl_sf_sinc
-foreign import ccall "gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_sinc" gsl_sf_sinc :: Double -> Double
 
 lnsinh_e :: Double -> (Double,Double)
 lnsinh_e x = createSFR "lnsinh_e" $ gsl_sf_lnsinh_e x
-foreign import ccall "gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lnsinh_e" gsl_sf_lnsinh_e :: Double -> Ptr () -> IO CInt
 
 lnsinh :: Double -> Double
 lnsinh = gsl_sf_lnsinh
-foreign import ccall "gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lnsinh" gsl_sf_lnsinh :: Double -> Double
 
 lncosh_e :: Double -> (Double,Double)
 lncosh_e x = createSFR "lncosh_e" $ gsl_sf_lncosh_e x
-foreign import ccall "gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_lncosh_e" gsl_sf_lncosh_e :: Double -> Ptr () -> IO CInt
 
 lncosh :: Double -> Double
 lncosh = gsl_sf_lncosh
-foreign import ccall "gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_lncosh" gsl_sf_lncosh :: Double -> Double
 
 polar_to_rect :: Double -> Double -> Ptr () -> (Double,Double)
 polar_to_rect r theta x = createSFR "polar_to_rect" $ gsl_sf_polar_to_rect r theta x
-foreign import ccall "gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_polar_to_rect" gsl_sf_polar_to_rect :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 rect_to_polar :: Double -> Double -> Ptr () -> (Double,Double)
 rect_to_polar x y r = createSFR "rect_to_polar" $ gsl_sf_rect_to_polar x y r
-foreign import ccall "gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_rect_to_polar" gsl_sf_rect_to_polar :: Double -> Double -> Ptr () -> Ptr () -> IO CInt
 
 sin_err_e :: Double -> Double -> (Double,Double)
 sin_err_e x dx = createSFR "sin_err_e" $ gsl_sf_sin_err_e x dx
-foreign import ccall "gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_sin_err_e" gsl_sf_sin_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 cos_err_e :: Double -> Double -> (Double,Double)
 cos_err_e x dx = createSFR "cos_err_e" $ gsl_sf_cos_err_e x dx
-foreign import ccall "gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_cos_err_e" gsl_sf_cos_err_e :: Double -> Double -> Ptr () -> IO CInt
 
 angle_restrict_symm_e :: Ptr Double -> CInt
 angle_restrict_symm_e = gsl_sf_angle_restrict_symm_e
-foreign import ccall "gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_symm_e" gsl_sf_angle_restrict_symm_e :: Ptr Double -> CInt
 
 angle_restrict_symm :: Double -> Double
 angle_restrict_symm = gsl_sf_angle_restrict_symm
-foreign import ccall "gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_symm" gsl_sf_angle_restrict_symm :: Double -> Double
 
 angle_restrict_pos_e :: Ptr Double -> CInt
 angle_restrict_pos_e = gsl_sf_angle_restrict_pos_e
-foreign import ccall "gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_pos_e" gsl_sf_angle_restrict_pos_e :: Ptr Double -> CInt
 
 angle_restrict_pos :: Double -> Double
 angle_restrict_pos = gsl_sf_angle_restrict_pos
-foreign import ccall "gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_pos" gsl_sf_angle_restrict_pos :: Double -> Double
 
 angle_restrict_symm_err_e :: Double -> (Double,Double)
 angle_restrict_symm_err_e theta = createSFR "angle_restrict_symm_err_e" $ gsl_sf_angle_restrict_symm_err_e theta
-foreign import ccall "gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_symm_err_e" gsl_sf_angle_restrict_symm_err_e :: Double -> Ptr () -> IO CInt
 
 angle_restrict_pos_err_e :: Double -> (Double,Double)
 angle_restrict_pos_err_e theta = createSFR "angle_restrict_pos_err_e" $ gsl_sf_angle_restrict_pos_err_e theta
-foreign import ccall "gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_angle_restrict_pos_err_e" gsl_sf_angle_restrict_pos_err_e :: Double -> Ptr () -> IO CInt
diff --git a/lib/Numeric/GSL/Special/Zeta.hs b/lib/Numeric/GSL/Special/Zeta.hs
index 96b8170..930efc0 100644
--- a/lib/Numeric/GSL/Special/Zeta.hs
+++ b/lib/Numeric/GSL/Special/Zeta.hs
@@ -35,56 +35,56 @@ import Numeric.GSL.Special.Internal
 
 zeta_int_e :: CInt -> (Double,Double)
 zeta_int_e n = createSFR "zeta_int_e" $ gsl_sf_zeta_int_e n
-foreign import ccall "gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_int_e" gsl_sf_zeta_int_e :: CInt -> Ptr () -> IO CInt
 
 zeta_int :: CInt -> Double
 zeta_int = gsl_sf_zeta_int
-foreign import ccall "gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_int" gsl_sf_zeta_int :: CInt -> Double
 
 zeta_e :: Double -> (Double,Double)
 zeta_e s = createSFR "zeta_e" $ gsl_sf_zeta_e s
-foreign import ccall "gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta_e" gsl_sf_zeta_e :: Double -> Ptr () -> IO CInt
 
 zeta :: Double -> Double
 zeta = gsl_sf_zeta
-foreign import ccall "gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_zeta" gsl_sf_zeta :: Double -> Double
 
 zetam1_e :: Double -> (Double,Double)
 zetam1_e s = createSFR "zetam1_e" $ gsl_sf_zetam1_e s
-foreign import ccall "gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_e" gsl_sf_zetam1_e :: Double -> Ptr () -> IO CInt
 
 zetam1 :: Double -> Double
 zetam1 = gsl_sf_zetam1
-foreign import ccall "gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1" gsl_sf_zetam1 :: Double -> Double
 
 zetam1_int_e :: CInt -> (Double,Double)
 zetam1_int_e s = createSFR "zetam1_int_e" $ gsl_sf_zetam1_int_e s
-foreign import ccall "gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_int_e" gsl_sf_zetam1_int_e :: CInt -> Ptr () -> IO CInt
 
 zetam1_int :: CInt -> Double
 zetam1_int = gsl_sf_zetam1_int
-foreign import ccall "gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_zetam1_int" gsl_sf_zetam1_int :: CInt -> Double
 
 hzeta_e :: Double -> Double -> (Double,Double)
 hzeta_e s q = createSFR "hzeta_e" $ gsl_sf_hzeta_e s q
-foreign import ccall "gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_hzeta_e" gsl_sf_hzeta_e :: Double -> Double -> Ptr () -> IO CInt
 
 hzeta :: Double -> Double -> Double
 hzeta = gsl_sf_hzeta
-foreign import ccall "gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_hzeta" gsl_sf_hzeta :: Double -> Double -> Double
 
 eta_int_e :: CInt -> (Double,Double)
 eta_int_e n = createSFR "eta_int_e" $ gsl_sf_eta_int_e n
-foreign import ccall "gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_int_e" gsl_sf_eta_int_e :: CInt -> Ptr () -> IO CInt
 
 eta_int :: CInt -> Double
 eta_int = gsl_sf_eta_int
-foreign import ccall "gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_int" gsl_sf_eta_int :: CInt -> Double
 
 eta_e :: Double -> (Double,Double)
 eta_e s = createSFR "eta_e" $ gsl_sf_eta_e s
-foreign import ccall "gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt
+foreign import ccall SAFE_CHEAP "gsl_sf_eta_e" gsl_sf_eta_e :: Double -> Ptr () -> IO CInt
 
 eta :: Double -> Double
 eta = gsl_sf_eta
-foreign import ccall "gsl_sf_eta" gsl_sf_eta :: Double -> Double
+foreign import ccall SAFE_CHEAP "gsl_sf_eta" gsl_sf_eta :: Double -> Double
diff --git a/lib/Numeric/GSL/Special/auto.hs b/lib/Numeric/GSL/Special/auto.hs
index 011272c..b46e6c6 100644
--- a/lib/Numeric/GSL/Special/auto.hs
+++ b/lib/Numeric/GSL/Special/auto.hs
@@ -183,7 +183,7 @@ showCt (Pointer s) = s ++ "*"
 
 showCa (t, a) = showCt t ++" "++ a
 
-showH hc h@(Header t n args) = "foreign import ccall \""++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
+showH hc h@(Header t n args) = "foreign import ccall SAFE_CHEAP \""++n++"\" "++n++" :: "++ (concat$intersperse" -> "$map showHa args) ++" -> " ++ t'
     where t' | pure h = showHt t
              | otherwise = "IO "++showHt t