    {-# LANGUAGE CPP #-}
    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.GLU.Functions
    -- Copyright   :  (c) Sven Panne 2018
    -- License     :  BSD3
    --
    -- Maintainer  :  Sven Panne <svenpanne@gmail.com>
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- All functions from GLU 1.3, see <http://www.opengl.org/>.
    --
    --------------------------------------------------------------------------------

    module Graphics.GLU.Functions (
       gluBeginCurve,
       gluBeginPolygon,
       gluBeginSurface,
       gluBeginTrim,
       gluBuild1DMipmapLevels,
       gluBuild1DMipmaps,
       gluBuild2DMipmapLevels,
       gluBuild2DMipmaps,
       gluBuild3DMipmapLevels,
       gluBuild3DMipmaps,
       gluCheckExtension,
       gluCylinder,
       gluDeleteNurbsRenderer,
       gluDeleteQuadric,
       gluDeleteTess,
       gluDisk,
       gluEndCurve,
       gluEndPolygon,
       gluEndSurface,
       gluEndTrim,
       gluErrorString,
       gluGetNurbsProperty,
       gluGetString,
       gluGetTessProperty,
       gluLoadSamplingMatrices,
       gluLookAt,
       gluNewNurbsRenderer,
       gluNewQuadric,
       gluNewTess,
       gluNextContour,
       gluNurbsCallback,
       gluNurbsCallbackData,
       gluNurbsCallbackDataEXT,
       gluNurbsCurve,
       gluNurbsProperty,
       gluNurbsSurface,
       gluOrtho2D,
       gluPartialDisk,
       gluPerspective,
       gluPickMatrix,
       gluProject,
       gluPwlCurve,
       gluQuadricCallback,
       gluQuadricDrawStyle,
       gluQuadricNormals,
       gluQuadricOrientation,
       gluQuadricTexture,
       gluScaleImage,
       gluSphere,
       gluTessBeginContour,
       gluTessBeginPolygon,
       gluTessCallback,
       gluTessEndContour,
       gluTessEndPolygon,
       gluTessNormal,
       gluTessProperty,
       gluTessVertex,
       gluUnProject,
       gluUnProject4,
    ) where

    import Control.Monad.IO.Class ( MonadIO(..) )
    import Foreign.C.String ( withCString, CString )
    import Foreign.Marshal.Error ( throwIf )
    import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr )
    import System.IO.Unsafe ( unsafePerformIO )

    import Graphics.GLU.Types
    import Graphics.GL.Types

    --------------------------------------------------------------------------------

    -- | Retrieve a GLU API entry by name. Throws a userError when no entry with the
    -- given name was found.
    getAPIEntry :: String -> IO (FunPtr a)
    getAPIEntry :: forall a. String -> IO (FunPtr a)
    getAPIEntry String
    extensionEntry =
       String -> IO (FunPtr a) -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a) -> IO (FunPtr a)
    throwIfNullFunPtr (String
    "unknown GLU entry " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    extensionEntry) (IO (FunPtr a) -> IO (FunPtr a)) -> IO (FunPtr a) -> IO (FunPtr a)
    forall a b. (a -> b) -> a -> b
    $
          String -> (CString -> IO (FunPtr a)) -> IO (FunPtr a)
    forall a. String -> (CString -> IO a) -> IO a
    withCString String
    extensionEntry CString -> IO (FunPtr a)
    forall a. CString -> IO (FunPtr a)
    hs_GLU_getProcAddress

    throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)
    throwIfNullFunPtr :: forall a. String -> IO (FunPtr a) -> IO (FunPtr a)
    throwIfNullFunPtr = (FunPtr a -> Bool)
    -> (FunPtr a -> String) -> IO (FunPtr a) -> IO (FunPtr a)
    forall a. (a -> Bool) -> (a -> String) -> IO a -> IO a
    throwIf (FunPtr a -> FunPtr a -> Bool
    forall a. Eq a => a -> a -> Bool
    == FunPtr a
    forall a. FunPtr a
    nullFunPtr) ((FunPtr a -> String) -> IO (FunPtr a) -> IO (FunPtr a))
    -> (String -> FunPtr a -> String)
    -> String
    -> IO (FunPtr a)
    -> IO (FunPtr a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> FunPtr a -> String
    forall a b. a -> b -> a
    const

    foreign import ccall unsafe "hs_GLU_getProcAddress"
       hs_GLU_getProcAddress :: CString -> IO (FunPtr a)

    -- gluBeginCurve ----------------------------------------------------------------------

    gluBeginCurve :: MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginCurve :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginCurve Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluBeginCurve FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluBeginCurve Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluBeginCurve
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluBeginCurve #-}
    ptr_gluBeginCurve :: FunPtr a
    ptr_gluBeginCurve :: forall a. FunPtr a
    ptr_gluBeginCurve = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBeginCurve"

    -- gluBeginPolygon ----------------------------------------------------------------------

    gluBeginPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
    gluBeginPolygon :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluBeginPolygon Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluBeginPolygon FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluBeginPolygon Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluBeginPolygon
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluBeginPolygon #-}
    ptr_gluBeginPolygon :: FunPtr a
    ptr_gluBeginPolygon :: forall a. FunPtr a
    ptr_gluBeginPolygon = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBeginPolygon"

    -- gluBeginSurface ----------------------------------------------------------------------

    gluBeginSurface :: MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginSurface :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginSurface Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluBeginSurface FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluBeginSurface Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluBeginSurface
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluBeginSurface #-}
    ptr_gluBeginSurface :: FunPtr a
    ptr_gluBeginSurface :: forall a. FunPtr a
    ptr_gluBeginSurface = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBeginSurface"

    -- gluBeginTrim ----------------------------------------------------------------------

    gluBeginTrim :: MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginTrim :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluBeginTrim Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluBeginTrim FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluBeginTrim Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluBeginTrim
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluBeginTrim #-}
    ptr_gluBeginTrim :: FunPtr a
    ptr_gluBeginTrim :: forall a. FunPtr a
    ptr_gluBeginTrim = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBeginTrim"

    -- gluBuild1DMipmapLevels ----------------------------------------------------------------------

    gluBuild1DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
    gluBuild1DMipmapLevels :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> m GLint
    gluBuild1DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 GLenum
    v5 GLint
    v6 GLint
    v7 GLint
    v8 Ptr a
    v9 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    dyn_gluBuild1DMipmapLevels FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild1DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 GLenum
    v5 GLint
    v6 GLint
    v7 GLint
    v8 Ptr a
    v9

    foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmapLevels
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild1DMipmapLevels #-}
    ptr_gluBuild1DMipmapLevels :: FunPtr a
    ptr_gluBuild1DMipmapLevels :: forall a. FunPtr a
    ptr_gluBuild1DMipmapLevels = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild1DMipmapLevels"

    -- gluBuild1DMipmaps ----------------------------------------------------------------------

    gluBuild1DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
    gluBuild1DMipmaps :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> m GLint
    gluBuild1DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 GLenum
    v5 Ptr a
    v6 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    dyn_gluBuild1DMipmaps FunPtr
      (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild1DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 GLenum
    v5 Ptr a
    v6

    foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmaps
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild1DMipmaps #-}
    ptr_gluBuild1DMipmaps :: FunPtr a
    ptr_gluBuild1DMipmaps :: forall a. FunPtr a
    ptr_gluBuild1DMipmaps = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild1DMipmaps"

    -- gluBuild2DMipmapLevels ----------------------------------------------------------------------

    gluBuild2DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
    gluBuild2DMipmapLevels :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> m GLint
    gluBuild2DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLenum
    v5 GLenum
    v6 GLint
    v7 GLint
    v8 GLint
    v9 Ptr a
    v10 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    dyn_gluBuild2DMipmapLevels FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild2DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLenum
    v5 GLenum
    v6 GLint
    v7 GLint
    v8 GLint
    v9 Ptr a
    v10

    foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmapLevels
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild2DMipmapLevels #-}
    ptr_gluBuild2DMipmapLevels :: FunPtr a
    ptr_gluBuild2DMipmapLevels :: forall a. FunPtr a
    ptr_gluBuild2DMipmapLevels = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild2DMipmapLevels"

    -- gluBuild2DMipmaps ----------------------------------------------------------------------

    gluBuild2DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
    gluBuild2DMipmaps :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum
    -> GLint -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> m GLint
    gluBuild2DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLenum
    v5 GLenum
    v6 Ptr a
    v7 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    dyn_gluBuild2DMipmaps FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild2DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLenum
    v5 GLenum
    v6 Ptr a
    v7

    foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmaps
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild2DMipmaps #-}
    ptr_gluBuild2DMipmaps :: FunPtr a
    ptr_gluBuild2DMipmaps :: forall a. FunPtr a
    ptr_gluBuild2DMipmaps = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild2DMipmaps"

    -- gluBuild3DMipmapLevels ----------------------------------------------------------------------

    gluBuild3DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
    gluBuild3DMipmapLevels :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> m GLint
    gluBuild3DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLenum
    v6 GLenum
    v7 GLint
    v8 GLint
    v9 GLint
    v10 Ptr a
    v11= IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> Ptr a
    -> IO GLint
    dyn_gluBuild3DMipmapLevels FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> GLint
       -> GLint
       -> GLint
       -> Ptr a
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild3DMipmapLevels GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLenum
    v6 GLenum
    v7 GLint
    v8 GLint
    v9 GLint
    v10 Ptr a
    v11

    foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmapLevels
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild3DMipmapLevels #-}
    ptr_gluBuild3DMipmapLevels :: FunPtr a
    ptr_gluBuild3DMipmapLevels :: forall a. FunPtr a
    ptr_gluBuild3DMipmapLevels = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild3DMipmapLevels"

    -- gluBuild3DMipmaps ----------------------------------------------------------------------

    gluBuild3DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
    gluBuild3DMipmaps :: forall (m :: * -> *) a.
    MonadIO m =>
    GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> m GLint
    gluBuild3DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLenum
    v6 GLenum
    v7 Ptr a
    v8 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    forall a.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLenum
    -> GLenum
    -> Ptr a
    -> IO GLint
    dyn_gluBuild3DMipmaps FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLenum
       -> GLenum
       -> Ptr a
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluBuild3DMipmaps GLenum
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLenum
    v6 GLenum
    v7 Ptr a
    v8

    foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmaps
      :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)
      ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint

    {-# NOINLINE ptr_gluBuild3DMipmaps #-}
    ptr_gluBuild3DMipmaps :: FunPtr a
    ptr_gluBuild3DMipmaps :: forall a. FunPtr a
    ptr_gluBuild3DMipmaps = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluBuild3DMipmaps"

    -- gluCheckExtension ----------------------------------------------------------------------

    gluCheckExtension :: MonadIO m => Ptr GLubyte -> Ptr GLubyte -> m GLboolean
    gluCheckExtension :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLubyte -> Ptr GLubyte -> m GLubyte
    gluCheckExtension Ptr GLubyte
    v1 Ptr GLubyte
    v2 = IO GLubyte -> m GLubyte
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLubyte -> m GLubyte) -> IO GLubyte -> m GLubyte
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLubyte)
    -> Ptr GLubyte -> Ptr GLubyte -> IO GLubyte
    dyn_gluCheckExtension FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLubyte)
    forall a. FunPtr a
    ptr_gluCheckExtension Ptr GLubyte
    v1 Ptr GLubyte
    v2

    foreign import CALLCONV "dynamic" dyn_gluCheckExtension
      :: FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLboolean)
      ->         Ptr GLubyte -> Ptr GLubyte -> IO GLboolean

    {-# NOINLINE ptr_gluCheckExtension #-}
    ptr_gluCheckExtension :: FunPtr a
    ptr_gluCheckExtension :: forall a. FunPtr a
    ptr_gluCheckExtension = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluCheckExtension"

    -- gluCylinder ----------------------------------------------------------------------

    gluCylinder :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
    gluCylinder :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUquadric
    -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
    gluCylinder Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLint
    v5 GLint
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUquadric
       -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> Ptr GLUquadric
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLint
    -> GLint
    -> IO ()
    dyn_gluCylinder FunPtr
      (Ptr GLUquadric
       -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_gluCylinder Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLint
    v5 GLint
    v6

    foreign import CALLCONV "dynamic" dyn_gluCylinder
      :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
      ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()

    {-# NOINLINE ptr_gluCylinder #-}
    ptr_gluCylinder :: FunPtr a
    ptr_gluCylinder :: forall a. FunPtr a
    ptr_gluCylinder = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluCylinder"

    -- gluDeleteNurbsRenderer ----------------------------------------------------------------------

    gluDeleteNurbsRenderer :: MonadIO m => Ptr GLUnurbs -> m ()
    gluDeleteNurbsRenderer :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluDeleteNurbsRenderer Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluDeleteNurbsRenderer FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluDeleteNurbsRenderer Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluDeleteNurbsRenderer
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluDeleteNurbsRenderer #-}
    ptr_gluDeleteNurbsRenderer :: FunPtr a
    ptr_gluDeleteNurbsRenderer :: forall a. FunPtr a
    ptr_gluDeleteNurbsRenderer = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluDeleteNurbsRenderer"

    -- gluDeleteQuadric ----------------------------------------------------------------------

    gluDeleteQuadric :: MonadIO m => Ptr GLUquadric -> m ()
    gluDeleteQuadric :: forall (m :: * -> *). MonadIO m => Ptr GLUquadric -> m ()
    gluDeleteQuadric Ptr GLUquadric
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> IO ()) -> Ptr GLUquadric -> IO ()
    dyn_gluDeleteQuadric FunPtr (Ptr GLUquadric -> IO ())
    forall a. FunPtr a
    ptr_gluDeleteQuadric Ptr GLUquadric
    v1

    foreign import CALLCONV "dynamic" dyn_gluDeleteQuadric
      :: FunPtr (Ptr GLUquadric -> IO ())
      ->         Ptr GLUquadric -> IO ()

    {-# NOINLINE ptr_gluDeleteQuadric #-}
    ptr_gluDeleteQuadric :: FunPtr a
    ptr_gluDeleteQuadric :: forall a. FunPtr a
    ptr_gluDeleteQuadric = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluDeleteQuadric"

    -- gluDeleteTess ----------------------------------------------------------------------

    gluDeleteTess :: MonadIO m => Ptr GLUtesselator -> m ()
    gluDeleteTess :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluDeleteTess Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluDeleteTess FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluDeleteTess Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluDeleteTess
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluDeleteTess #-}
    ptr_gluDeleteTess :: FunPtr a
    ptr_gluDeleteTess :: forall a. FunPtr a
    ptr_gluDeleteTess = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluDeleteTess"

    -- gluDisk ----------------------------------------------------------------------

    gluDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
    gluDisk :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
    gluDisk Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLint
    v4 GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> Ptr GLUquadric
    -> GLdouble
    -> GLdouble
    -> GLint
    -> GLint
    -> IO ()
    dyn_gluDisk FunPtr
      (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_gluDisk Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLint
    v4 GLint
    v5

    foreign import CALLCONV "dynamic" dyn_gluDisk
      :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
      ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()

    {-# NOINLINE ptr_gluDisk #-}
    ptr_gluDisk :: FunPtr a
    ptr_gluDisk :: forall a. FunPtr a
    ptr_gluDisk = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluDisk"

    -- gluEndCurve ----------------------------------------------------------------------

    gluEndCurve :: MonadIO m => Ptr GLUnurbs -> m ()
    gluEndCurve :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluEndCurve Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluEndCurve FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluEndCurve Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluEndCurve
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluEndCurve #-}
    ptr_gluEndCurve :: FunPtr a
    ptr_gluEndCurve :: forall a. FunPtr a
    ptr_gluEndCurve = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluEndCurve"

    -- gluEndPolygon ----------------------------------------------------------------------

    gluEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
    gluEndPolygon :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluEndPolygon Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluEndPolygon FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluEndPolygon Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluEndPolygon
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluEndPolygon #-}
    ptr_gluEndPolygon :: FunPtr a
    ptr_gluEndPolygon :: forall a. FunPtr a
    ptr_gluEndPolygon = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluEndPolygon"

    -- gluEndSurface ----------------------------------------------------------------------

    gluEndSurface :: MonadIO m => Ptr GLUnurbs -> m ()
    gluEndSurface :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluEndSurface Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluEndSurface FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluEndSurface Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluEndSurface
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluEndSurface #-}
    ptr_gluEndSurface :: FunPtr a
    ptr_gluEndSurface :: forall a. FunPtr a
    ptr_gluEndSurface = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluEndSurface"

    -- gluEndTrim ----------------------------------------------------------------------

    gluEndTrim :: MonadIO m => Ptr GLUnurbs -> m ()
    gluEndTrim :: forall (m :: * -> *). MonadIO m => Ptr GLUnurbs -> m ()
    gluEndTrim Ptr GLUnurbs
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
    dyn_gluEndTrim FunPtr (Ptr GLUnurbs -> IO ())
    forall a. FunPtr a
    ptr_gluEndTrim Ptr GLUnurbs
    v1

    foreign import CALLCONV "dynamic" dyn_gluEndTrim
      :: FunPtr (Ptr GLUnurbs -> IO ())
      ->         Ptr GLUnurbs -> IO ()

    {-# NOINLINE ptr_gluEndTrim #-}
    ptr_gluEndTrim :: FunPtr a
    ptr_gluEndTrim :: forall a. FunPtr a
    ptr_gluEndTrim = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluEndTrim"

    -- gluErrorString ----------------------------------------------------------------------

    gluErrorString :: MonadIO m => GLenum -> m (Ptr GLubyte)
    gluErrorString :: forall (m :: * -> *). MonadIO m => GLenum -> m (Ptr GLubyte)
    gluErrorString GLenum
    v1 = IO (Ptr GLubyte) -> m (Ptr GLubyte)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr GLubyte) -> m (Ptr GLubyte))
    -> IO (Ptr GLubyte) -> m (Ptr GLubyte)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO (Ptr GLubyte)) -> GLenum -> IO (Ptr GLubyte)
    dyn_gluErrorString FunPtr (GLenum -> IO (Ptr GLubyte))
    forall a. FunPtr a
    ptr_gluErrorString GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_gluErrorString
      :: FunPtr (GLenum -> IO (Ptr GLubyte))
      ->         GLenum -> IO (Ptr GLubyte)

    {-# NOINLINE ptr_gluErrorString #-}
    ptr_gluErrorString :: FunPtr a
    ptr_gluErrorString :: forall a. FunPtr a
    ptr_gluErrorString = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluErrorString"

    -- gluGetNurbsProperty ----------------------------------------------------------------------

    gluGetNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m ()
    gluGetNurbsProperty :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m ()
    gluGetNurbsProperty Ptr GLUnurbs
    v1 GLenum
    v2 Ptr GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())
    -> Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()
    dyn_gluGetNurbsProperty FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())
    forall a. FunPtr a
    ptr_gluGetNurbsProperty Ptr GLUnurbs
    v1 GLenum
    v2 Ptr GLfloat
    v3

    foreign import CALLCONV "dynamic" dyn_gluGetNurbsProperty
      :: FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())
      ->         Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()

    {-# NOINLINE ptr_gluGetNurbsProperty #-}
    ptr_gluGetNurbsProperty :: FunPtr a
    ptr_gluGetNurbsProperty :: forall a. FunPtr a
    ptr_gluGetNurbsProperty = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluGetNurbsProperty"

    -- gluGetString ----------------------------------------------------------------------

    gluGetString :: MonadIO m => GLenum -> m (Ptr GLubyte)
    gluGetString :: forall (m :: * -> *). MonadIO m => GLenum -> m (Ptr GLubyte)
    gluGetString GLenum
    v1 = IO (Ptr GLubyte) -> m (Ptr GLubyte)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr GLubyte) -> m (Ptr GLubyte))
    -> IO (Ptr GLubyte) -> m (Ptr GLubyte)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO (Ptr GLubyte)) -> GLenum -> IO (Ptr GLubyte)
    dyn_gluGetString FunPtr (GLenum -> IO (Ptr GLubyte))
    forall a. FunPtr a
    ptr_gluGetString GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_gluGetString
      :: FunPtr (GLenum -> IO (Ptr GLubyte))
      ->         GLenum -> IO (Ptr GLubyte)

    {-# NOINLINE ptr_gluGetString #-}
    ptr_gluGetString :: FunPtr a
    ptr_gluGetString :: forall a. FunPtr a
    ptr_gluGetString = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluGetString"

    -- gluGetTessProperty ----------------------------------------------------------------------

    gluGetTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m ()
    gluGetTessProperty :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m ()
    gluGetTessProperty Ptr GLUtesselator
    v1 GLenum
    v2 Ptr GLdouble
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())
    -> Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()
    dyn_gluGetTessProperty FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())
    forall a. FunPtr a
    ptr_gluGetTessProperty Ptr GLUtesselator
    v1 GLenum
    v2 Ptr GLdouble
    v3

    foreign import CALLCONV "dynamic" dyn_gluGetTessProperty
      :: FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())
      ->         Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()

    {-# NOINLINE ptr_gluGetTessProperty #-}
    ptr_gluGetTessProperty :: FunPtr a
    ptr_gluGetTessProperty :: forall a. FunPtr a
    ptr_gluGetTessProperty = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluGetTessProperty"

    -- gluLoadSamplingMatrices ----------------------------------------------------------------------

    gluLoadSamplingMatrices :: MonadIO m => Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m ()
    gluLoadSamplingMatrices :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m ()
    gluLoadSamplingMatrices Ptr GLUnurbs
    v1 Ptr GLfloat
    v2 Ptr GLfloat
    v3 Ptr GLint
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())
    -> Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()
    dyn_gluLoadSamplingMatrices FunPtr
      (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())
    forall a. FunPtr a
    ptr_gluLoadSamplingMatrices Ptr GLUnurbs
    v1 Ptr GLfloat
    v2 Ptr GLfloat
    v3 Ptr GLint
    v4

    foreign import CALLCONV "dynamic" dyn_gluLoadSamplingMatrices
      :: FunPtr (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())
      ->         Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()

    {-# NOINLINE ptr_gluLoadSamplingMatrices #-}
    ptr_gluLoadSamplingMatrices :: FunPtr a
    ptr_gluLoadSamplingMatrices :: forall a. FunPtr a
    ptr_gluLoadSamplingMatrices = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluLoadSamplingMatrices"

    -- gluLookAt ----------------------------------------------------------------------

    gluLookAt :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluLookAt :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> m ()
    gluLookAt GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5 GLdouble
    v6 GLdouble
    v7 GLdouble
    v8 GLdouble
    v9 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> IO ())
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> IO ()
    dyn_gluLookAt FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> IO ())
    forall a. FunPtr a
    ptr_gluLookAt GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5 GLdouble
    v6 GLdouble
    v7 GLdouble
    v8 GLdouble
    v9

    foreign import CALLCONV "dynamic" dyn_gluLookAt
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
      ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluLookAt #-}
    ptr_gluLookAt :: FunPtr a
    ptr_gluLookAt :: forall a. FunPtr a
    ptr_gluLookAt = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluLookAt"

    -- gluNewNurbsRenderer ----------------------------------------------------------------------

    gluNewNurbsRenderer :: MonadIO m => m (Ptr GLUnurbs)
    gluNewNurbsRenderer :: forall (m :: * -> *). MonadIO m => m (Ptr GLUnurbs)
    gluNewNurbsRenderer = IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs))
    -> IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO (Ptr GLUnurbs)) -> IO (Ptr GLUnurbs)
    dyn_gluNewNurbsRenderer FunPtr (IO (Ptr GLUnurbs))
    forall a. FunPtr a
    ptr_gluNewNurbsRenderer

    foreign import CALLCONV "dynamic" dyn_gluNewNurbsRenderer
      :: FunPtr (IO (Ptr GLUnurbs))
      ->         IO (Ptr GLUnurbs)

    {-# NOINLINE ptr_gluNewNurbsRenderer #-}
    ptr_gluNewNurbsRenderer :: FunPtr a
    ptr_gluNewNurbsRenderer :: forall a. FunPtr a
    ptr_gluNewNurbsRenderer = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNewNurbsRenderer"

    -- gluNewQuadric ----------------------------------------------------------------------

    gluNewQuadric :: MonadIO m => m (Ptr GLUquadric)
    gluNewQuadric :: forall (m :: * -> *). MonadIO m => m (Ptr GLUquadric)
    gluNewQuadric = IO (Ptr GLUquadric) -> m (Ptr GLUquadric)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr GLUquadric) -> m (Ptr GLUquadric))
    -> IO (Ptr GLUquadric) -> m (Ptr GLUquadric)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO (Ptr GLUquadric)) -> IO (Ptr GLUquadric)
    dyn_gluNewQuadric FunPtr (IO (Ptr GLUquadric))
    forall a. FunPtr a
    ptr_gluNewQuadric

    foreign import CALLCONV "dynamic" dyn_gluNewQuadric
      :: FunPtr (IO (Ptr GLUquadric))
      ->         IO (Ptr GLUquadric)

    {-# NOINLINE ptr_gluNewQuadric #-}
    ptr_gluNewQuadric :: FunPtr a
    ptr_gluNewQuadric :: forall a. FunPtr a
    ptr_gluNewQuadric = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNewQuadric"

    -- gluNewTess ----------------------------------------------------------------------

    gluNewTess :: MonadIO m => m (Ptr GLUtesselator)
    gluNewTess :: forall (m :: * -> *). MonadIO m => m (Ptr GLUtesselator)
    gluNewTess = IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator))
    -> IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO (Ptr GLUtesselator)) -> IO (Ptr GLUtesselator)
    dyn_gluNewTess FunPtr (IO (Ptr GLUtesselator))
    forall a. FunPtr a
    ptr_gluNewTess

    foreign import CALLCONV "dynamic" dyn_gluNewTess
      :: FunPtr (IO (Ptr GLUtesselator))
      ->         IO (Ptr GLUtesselator)

    {-# NOINLINE ptr_gluNewTess #-}
    ptr_gluNewTess :: FunPtr a
    ptr_gluNewTess :: forall a. FunPtr a
    ptr_gluNewTess = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNewTess"

    -- gluNextContour ----------------------------------------------------------------------

    gluNextContour :: MonadIO m => Ptr GLUtesselator -> GLenum -> m ()
    gluNextContour :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUtesselator -> GLenum -> m ()
    gluNextContour Ptr GLUtesselator
    v1 GLenum
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> GLenum -> IO ())
    -> Ptr GLUtesselator -> GLenum -> IO ()
    dyn_gluNextContour FunPtr (Ptr GLUtesselator -> GLenum -> IO ())
    forall a. FunPtr a
    ptr_gluNextContour Ptr GLUtesselator
    v1 GLenum
    v2

    foreign import CALLCONV "dynamic" dyn_gluNextContour
      :: FunPtr (Ptr GLUtesselator -> GLenum -> IO ())
      ->         Ptr GLUtesselator -> GLenum -> IO ()

    {-# NOINLINE ptr_gluNextContour #-}
    ptr_gluNextContour :: FunPtr a
    ptr_gluNextContour :: forall a. FunPtr a
    ptr_gluNextContour = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNextContour"

    -- gluNurbsCallback ----------------------------------------------------------------------

    gluNurbsCallback :: MonadIO m => Ptr GLUnurbs -> GLenum -> FunPtr a -> m ()
    gluNurbsCallback :: forall (m :: * -> *) a.
    MonadIO m =>
    Ptr GLUnurbs -> GLenum -> FunPtr a -> m ()
    gluNurbsCallback Ptr GLUnurbs
    v1 GLenum
    v2 FunPtr a
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()
    forall a.
    FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()
    dyn_gluNurbsCallback FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsCallback Ptr GLUnurbs
    v1 GLenum
    v2 FunPtr a
    v3

    foreign import CALLCONV "dynamic" dyn_gluNurbsCallback
      :: FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
      ->         Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()

    {-# NOINLINE ptr_gluNurbsCallback #-}
    ptr_gluNurbsCallback :: FunPtr a
    ptr_gluNurbsCallback :: forall a. FunPtr a
    ptr_gluNurbsCallback = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsCallback"

    -- gluNurbsCallbackData ----------------------------------------------------------------------

    gluNurbsCallbackData :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
    gluNurbsCallbackData :: forall (m :: * -> *) a. MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
    gluNurbsCallbackData Ptr GLUnurbs
    v1 Ptr a
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    -> Ptr GLUnurbs -> Ptr a -> IO ()
    forall a.
    FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    -> Ptr GLUnurbs -> Ptr a -> IO ()
    dyn_gluNurbsCallbackData FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsCallbackData Ptr GLUnurbs
    v1 Ptr a
    v2

    foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackData
      :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
      ->         Ptr GLUnurbs -> Ptr a -> IO ()

    {-# NOINLINE ptr_gluNurbsCallbackData #-}
    ptr_gluNurbsCallbackData :: FunPtr a
    ptr_gluNurbsCallbackData :: forall a. FunPtr a
    ptr_gluNurbsCallbackData = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsCallbackData"

    -- gluNurbsCallbackDataEXT ----------------------------------------------------------------------

    gluNurbsCallbackDataEXT :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
    gluNurbsCallbackDataEXT :: forall (m :: * -> *) a. MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
    gluNurbsCallbackDataEXT Ptr GLUnurbs
    v1 Ptr a
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    -> Ptr GLUnurbs -> Ptr a -> IO ()
    forall a.
    FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    -> Ptr GLUnurbs -> Ptr a -> IO ()
    dyn_gluNurbsCallbackDataEXT FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsCallbackDataEXT Ptr GLUnurbs
    v1 Ptr a
    v2

    foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackDataEXT
      :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
      ->         Ptr GLUnurbs -> Ptr a -> IO ()

    {-# NOINLINE ptr_gluNurbsCallbackDataEXT #-}
    ptr_gluNurbsCallbackDataEXT :: FunPtr a
    ptr_gluNurbsCallbackDataEXT :: forall a. FunPtr a
    ptr_gluNurbsCallbackDataEXT = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsCallbackDataEXT"

    -- gluNurbsCurve ----------------------------------------------------------------------

    gluNurbsCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
    gluNurbsCurve :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLenum
    -> m ()
    gluNurbsCurve Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 Ptr GLfloat
    v5 GLint
    v6 GLenum
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUnurbs
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLenum
       -> IO ())
    -> Ptr GLUnurbs
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLenum
    -> IO ()
    dyn_gluNurbsCurve FunPtr
      (Ptr GLUnurbs
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLenum
       -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsCurve Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 Ptr GLfloat
    v5 GLint
    v6 GLenum
    v7

    foreign import CALLCONV "dynamic" dyn_gluNurbsCurve
      :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
      ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()

    {-# NOINLINE ptr_gluNurbsCurve #-}
    ptr_gluNurbsCurve :: FunPtr a
    ptr_gluNurbsCurve :: forall a. FunPtr a
    ptr_gluNurbsCurve = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsCurve"

    -- gluNurbsProperty ----------------------------------------------------------------------

    gluNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> GLfloat -> m ()
    gluNurbsProperty :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs -> GLenum -> GLfloat -> m ()
    gluNurbsProperty Ptr GLUnurbs
    v1 GLenum
    v2 GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())
    -> Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()
    dyn_gluNurbsProperty FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsProperty Ptr GLUnurbs
    v1 GLenum
    v2 GLfloat
    v3

    foreign import CALLCONV "dynamic" dyn_gluNurbsProperty
      :: FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())
      ->         Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()

    {-# NOINLINE ptr_gluNurbsProperty #-}
    ptr_gluNurbsProperty :: FunPtr a
    ptr_gluNurbsProperty :: forall a. FunPtr a
    ptr_gluNurbsProperty = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsProperty"

    -- gluNurbsSurface ----------------------------------------------------------------------

    gluNurbsSurface :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> m ()
    gluNurbsSurface :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLint
    -> GLenum
    -> m ()
    gluNurbsSurface Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 Ptr GLfloat
    v5 GLint
    v6 GLint
    v7 Ptr GLfloat
    v8 GLint
    v9 GLint
    v10 GLenum
    v11 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUnurbs
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLint
       -> GLenum
       -> IO ())
    -> Ptr GLUnurbs
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLint
    -> Ptr GLfloat
    -> GLint
    -> GLint
    -> GLenum
    -> IO ()
    dyn_gluNurbsSurface FunPtr
      (Ptr GLUnurbs
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLint
       -> Ptr GLfloat
       -> GLint
       -> GLint
       -> GLenum
       -> IO ())
    forall a. FunPtr a
    ptr_gluNurbsSurface Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 Ptr GLfloat
    v5 GLint
    v6 GLint
    v7 Ptr GLfloat
    v8 GLint
    v9 GLint
    v10 GLenum
    v11

    foreign import CALLCONV "dynamic" dyn_gluNurbsSurface
      :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ())
      ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ()

    {-# NOINLINE ptr_gluNurbsSurface #-}
    ptr_gluNurbsSurface :: FunPtr a
    ptr_gluNurbsSurface :: forall a. FunPtr a
    ptr_gluNurbsSurface = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluNurbsSurface"

    -- gluOrtho2D ----------------------------------------------------------------------

    gluOrtho2D :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluOrtho2D :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluOrtho2D GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn_gluOrtho2D FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_gluOrtho2D GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

    foreign import CALLCONV "dynamic" dyn_gluOrtho2D
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
      ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluOrtho2D #-}
    ptr_gluOrtho2D :: FunPtr a
    ptr_gluOrtho2D :: forall a. FunPtr a
    ptr_gluOrtho2D = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluOrtho2D"

    -- gluPartialDisk ----------------------------------------------------------------------

    gluPartialDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> m ()
    gluPartialDisk :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUquadric
    -> GLdouble
    -> GLdouble
    -> GLint
    -> GLint
    -> GLdouble
    -> GLdouble
    -> m ()
    gluPartialDisk Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLint
    v4 GLint
    v5 GLdouble
    v6 GLdouble
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUquadric
       -> GLdouble
       -> GLdouble
       -> GLint
       -> GLint
       -> GLdouble
       -> GLdouble
       -> IO ())
    -> Ptr GLUquadric
    -> GLdouble
    -> GLdouble
    -> GLint
    -> GLint
    -> GLdouble
    -> GLdouble
    -> IO ()
    dyn_gluPartialDisk FunPtr
      (Ptr GLUquadric
       -> GLdouble
       -> GLdouble
       -> GLint
       -> GLint
       -> GLdouble
       -> GLdouble
       -> IO ())
    forall a. FunPtr a
    ptr_gluPartialDisk Ptr GLUquadric
    v1 GLdouble
    v2 GLdouble
    v3 GLint
    v4 GLint
    v5 GLdouble
    v6 GLdouble
    v7

    foreign import CALLCONV "dynamic" dyn_gluPartialDisk
      :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ())
      ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluPartialDisk #-}
    ptr_gluPartialDisk :: FunPtr a
    ptr_gluPartialDisk :: forall a. FunPtr a
    ptr_gluPartialDisk = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluPartialDisk"

    -- gluPerspective ----------------------------------------------------------------------

    gluPerspective :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluPerspective :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluPerspective GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn_gluPerspective FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_gluPerspective GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

    foreign import CALLCONV "dynamic" dyn_gluPerspective
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
      ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluPerspective #-}
    ptr_gluPerspective :: FunPtr a
    ptr_gluPerspective :: forall a. FunPtr a
    ptr_gluPerspective = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluPerspective"

    -- gluPickMatrix ----------------------------------------------------------------------

    gluPickMatrix :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m ()
    gluPickMatrix :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m ()
    gluPickMatrix GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 Ptr GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLdouble
       -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLint
    -> IO ()
    dyn_gluPickMatrix FunPtr
      (GLdouble
       -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())
    forall a. FunPtr a
    ptr_gluPickMatrix GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 Ptr GLint
    v5

    foreign import CALLCONV "dynamic" dyn_gluPickMatrix
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())
      ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ()

    {-# NOINLINE ptr_gluPickMatrix #-}
    ptr_gluPickMatrix :: FunPtr a
    ptr_gluPickMatrix :: forall a. FunPtr a
    ptr_gluPickMatrix = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluPickMatrix"

    -- gluProject ----------------------------------------------------------------------

    gluProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint
    gluProject :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> m GLint
    gluProject GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 Ptr GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLint
    v6 Ptr GLdouble
    v7 Ptr GLdouble
    v8 Ptr GLdouble
    v9 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> IO GLint
    dyn_gluProject FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluProject GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 Ptr GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLint
    v6 Ptr GLdouble
    v7 Ptr GLdouble
    v8 Ptr GLdouble
    v9

    foreign import CALLCONV "dynamic" dyn_gluProject
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)
      ->         GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint

    {-# NOINLINE ptr_gluProject #-}
    ptr_gluProject :: FunPtr a
    ptr_gluProject :: forall a. FunPtr a
    ptr_gluProject = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluProject"

    -- gluPwlCurve ----------------------------------------------------------------------

    gluPwlCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
    gluPwlCurve :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
    gluPwlCurve Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 GLenum
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
    -> Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()
    dyn_gluPwlCurve FunPtr
      (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
    forall a. FunPtr a
    ptr_gluPwlCurve Ptr GLUnurbs
    v1 GLint
    v2 Ptr GLfloat
    v3 GLint
    v4 GLenum
    v5

    foreign import CALLCONV "dynamic" dyn_gluPwlCurve
      :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
      ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()

    {-# NOINLINE ptr_gluPwlCurve #-}
    ptr_gluPwlCurve :: FunPtr a
    ptr_gluPwlCurve :: forall a. FunPtr a
    ptr_gluPwlCurve = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluPwlCurve"

    -- gluQuadricCallback ----------------------------------------------------------------------

    gluQuadricCallback :: MonadIO m => Ptr GLUquadric -> GLenum -> FunPtr a -> m ()
    gluQuadricCallback :: forall (m :: * -> *) a.
    MonadIO m =>
    Ptr GLUquadric -> GLenum -> FunPtr a -> m ()
    gluQuadricCallback Ptr GLUquadric
    v1 GLenum
    v2 FunPtr a
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()
    forall a.
    FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()
    dyn_gluQuadricCallback FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
    forall a. FunPtr a
    ptr_gluQuadricCallback Ptr GLUquadric
    v1 GLenum
    v2 FunPtr a
    v3

    foreign import CALLCONV "dynamic" dyn_gluQuadricCallback
      :: FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
      ->         Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()

    {-# NOINLINE ptr_gluQuadricCallback #-}
    ptr_gluQuadricCallback :: FunPtr a
    ptr_gluQuadricCallback :: forall a. FunPtr a
    ptr_gluQuadricCallback = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluQuadricCallback"

    -- gluQuadricDrawStyle ----------------------------------------------------------------------

    gluQuadricDrawStyle :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricDrawStyle :: forall (m :: * -> *). MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricDrawStyle Ptr GLUquadric
    v1 GLenum
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    -> Ptr GLUquadric -> GLenum -> IO ()
    dyn_gluQuadricDrawStyle FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    forall a. FunPtr a
    ptr_gluQuadricDrawStyle Ptr GLUquadric
    v1 GLenum
    v2

    foreign import CALLCONV "dynamic" dyn_gluQuadricDrawStyle
      :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())
      ->         Ptr GLUquadric -> GLenum -> IO ()

    {-# NOINLINE ptr_gluQuadricDrawStyle #-}
    ptr_gluQuadricDrawStyle :: FunPtr a
    ptr_gluQuadricDrawStyle :: forall a. FunPtr a
    ptr_gluQuadricDrawStyle = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluQuadricDrawStyle"

    -- gluQuadricNormals ----------------------------------------------------------------------

    gluQuadricNormals :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricNormals :: forall (m :: * -> *). MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricNormals Ptr GLUquadric
    v1 GLenum
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    -> Ptr GLUquadric -> GLenum -> IO ()
    dyn_gluQuadricNormals FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    forall a. FunPtr a
    ptr_gluQuadricNormals Ptr GLUquadric
    v1 GLenum
    v2

    foreign import CALLCONV "dynamic" dyn_gluQuadricNormals
      :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())
      ->         Ptr GLUquadric -> GLenum -> IO ()

    {-# NOINLINE ptr_gluQuadricNormals #-}
    ptr_gluQuadricNormals :: FunPtr a
    ptr_gluQuadricNormals :: forall a. FunPtr a
    ptr_gluQuadricNormals = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluQuadricNormals"

    -- gluQuadricOrientation ----------------------------------------------------------------------

    gluQuadricOrientation :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricOrientation :: forall (m :: * -> *). MonadIO m => Ptr GLUquadric -> GLenum -> m ()
    gluQuadricOrientation Ptr GLUquadric
    v1 GLenum
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    -> Ptr GLUquadric -> GLenum -> IO ()
    dyn_gluQuadricOrientation FunPtr (Ptr GLUquadric -> GLenum -> IO ())
    forall a. FunPtr a
    ptr_gluQuadricOrientation Ptr GLUquadric
    v1 GLenum
    v2

    foreign import CALLCONV "dynamic" dyn_gluQuadricOrientation
      :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())
      ->         Ptr GLUquadric -> GLenum -> IO ()

    {-# NOINLINE ptr_gluQuadricOrientation #-}
    ptr_gluQuadricOrientation :: FunPtr a
    ptr_gluQuadricOrientation :: forall a. FunPtr a
    ptr_gluQuadricOrientation = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluQuadricOrientation"

    -- gluQuadricTexture ----------------------------------------------------------------------

    gluQuadricTexture :: MonadIO m => Ptr GLUquadric -> GLboolean -> m ()
    gluQuadricTexture :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUquadric -> GLubyte -> m ()
    gluQuadricTexture Ptr GLUquadric
    v1 GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLubyte -> IO ())
    -> Ptr GLUquadric -> GLubyte -> IO ()
    dyn_gluQuadricTexture FunPtr (Ptr GLUquadric -> GLubyte -> IO ())
    forall a. FunPtr a
    ptr_gluQuadricTexture Ptr GLUquadric
    v1 GLubyte
    v2

    foreign import CALLCONV "dynamic" dyn_gluQuadricTexture
      :: FunPtr (Ptr GLUquadric -> GLboolean -> IO ())
      ->         Ptr GLUquadric -> GLboolean -> IO ()

    {-# NOINLINE ptr_gluQuadricTexture #-}
    ptr_gluQuadricTexture :: FunPtr a
    ptr_gluQuadricTexture :: forall a. FunPtr a
    ptr_gluQuadricTexture = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluQuadricTexture"

    -- gluScaleImage ----------------------------------------------------------------------

    gluScaleImage :: MonadIO m => GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> m GLint
    gluScaleImage :: forall (m :: * -> *) a b.
    MonadIO m =>
    GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr a
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr b
    -> m GLint
    gluScaleImage GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 Ptr a
    v5 GLint
    v6 GLint
    v7 GLenum
    v8 Ptr b
    v9 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr a
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr b
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr a
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr b
    -> IO GLint
    forall a b.
    FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr a
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr b
       -> IO GLint)
    -> GLenum
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr a
    -> GLint
    -> GLint
    -> GLenum
    -> Ptr b
    -> IO GLint
    dyn_gluScaleImage FunPtr
      (GLenum
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr a
       -> GLint
       -> GLint
       -> GLenum
       -> Ptr b
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluScaleImage GLenum
    v1 GLint
    v2 GLint
    v3 GLenum
    v4 Ptr a
    v5 GLint
    v6 GLint
    v7 GLenum
    v8 Ptr b
    v9

    foreign import CALLCONV "dynamic" dyn_gluScaleImage
      :: FunPtr (GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint)
      ->         GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint

    {-# NOINLINE ptr_gluScaleImage #-}
    ptr_gluScaleImage :: FunPtr a
    ptr_gluScaleImage :: forall a. FunPtr a
    ptr_gluScaleImage = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluScaleImage"

    -- gluSphere ----------------------------------------------------------------------

    gluSphere :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m ()
    gluSphere :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m ()
    gluSphere Ptr GLUquadric
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())
    -> Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()
    dyn_gluSphere FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_gluSphere Ptr GLUquadric
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

    foreign import CALLCONV "dynamic" dyn_gluSphere
      :: FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())
      ->         Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()

    {-# NOINLINE ptr_gluSphere #-}
    ptr_gluSphere :: FunPtr a
    ptr_gluSphere :: forall a. FunPtr a
    ptr_gluSphere = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluSphere"

    -- gluTessBeginContour ----------------------------------------------------------------------

    gluTessBeginContour :: MonadIO m => Ptr GLUtesselator -> m ()
    gluTessBeginContour :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluTessBeginContour Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluTessBeginContour FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluTessBeginContour Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluTessBeginContour
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluTessBeginContour #-}
    ptr_gluTessBeginContour :: FunPtr a
    ptr_gluTessBeginContour :: forall a. FunPtr a
    ptr_gluTessBeginContour = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessBeginContour"

    -- gluTessBeginPolygon ----------------------------------------------------------------------

    gluTessBeginPolygon :: MonadIO m => Ptr GLUtesselator -> Ptr a -> m ()
    gluTessBeginPolygon :: forall (m :: * -> *) a.
    MonadIO m =>
    Ptr GLUtesselator -> Ptr a -> m ()
    gluTessBeginPolygon Ptr GLUtesselator
    v1 Ptr a
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
    -> Ptr GLUtesselator -> Ptr a -> IO ()
    forall a.
    FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
    -> Ptr GLUtesselator -> Ptr a -> IO ()
    dyn_gluTessBeginPolygon FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
    forall a. FunPtr a
    ptr_gluTessBeginPolygon Ptr GLUtesselator
    v1 Ptr a
    v2

    foreign import CALLCONV "dynamic" dyn_gluTessBeginPolygon
      :: FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
      ->         Ptr GLUtesselator -> Ptr a -> IO ()

    {-# NOINLINE ptr_gluTessBeginPolygon #-}
    ptr_gluTessBeginPolygon :: FunPtr a
    ptr_gluTessBeginPolygon :: forall a. FunPtr a
    ptr_gluTessBeginPolygon = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessBeginPolygon"

    -- gluTessCallback ----------------------------------------------------------------------

    gluTessCallback :: MonadIO m => Ptr GLUtesselator -> GLenum -> FunPtr a -> m ()
    gluTessCallback :: forall (m :: * -> *) a.
    MonadIO m =>
    Ptr GLUtesselator -> GLenum -> FunPtr a -> m ()
    gluTessCallback Ptr GLUtesselator
    v1 GLenum
    v2 FunPtr a
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()
    forall a.
    FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
    -> Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()
    dyn_gluTessCallback FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
    forall a. FunPtr a
    ptr_gluTessCallback Ptr GLUtesselator
    v1 GLenum
    v2 FunPtr a
    v3

    foreign import CALLCONV "dynamic" dyn_gluTessCallback
      :: FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
      ->         Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()

    {-# NOINLINE ptr_gluTessCallback #-}
    ptr_gluTessCallback :: FunPtr a
    ptr_gluTessCallback :: forall a. FunPtr a
    ptr_gluTessCallback = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessCallback"

    -- gluTessEndContour ----------------------------------------------------------------------

    gluTessEndContour :: MonadIO m => Ptr GLUtesselator -> m ()
    gluTessEndContour :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluTessEndContour Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluTessEndContour FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluTessEndContour Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluTessEndContour
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluTessEndContour #-}
    ptr_gluTessEndContour :: FunPtr a
    ptr_gluTessEndContour :: forall a. FunPtr a
    ptr_gluTessEndContour = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessEndContour"

    -- gluTessEndPolygon ----------------------------------------------------------------------

    gluTessEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
    gluTessEndPolygon :: forall (m :: * -> *). MonadIO m => Ptr GLUtesselator -> m ()
    gluTessEndPolygon Ptr GLUtesselator
    v1 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
    dyn_gluTessEndPolygon FunPtr (Ptr GLUtesselator -> IO ())
    forall a. FunPtr a
    ptr_gluTessEndPolygon Ptr GLUtesselator
    v1

    foreign import CALLCONV "dynamic" dyn_gluTessEndPolygon
      :: FunPtr (Ptr GLUtesselator -> IO ())
      ->         Ptr GLUtesselator -> IO ()

    {-# NOINLINE ptr_gluTessEndPolygon #-}
    ptr_gluTessEndPolygon :: FunPtr a
    ptr_gluTessEndPolygon :: forall a. FunPtr a
    ptr_gluTessEndPolygon = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessEndPolygon"

    -- gluTessNormal ----------------------------------------------------------------------

    gluTessNormal :: MonadIO m => Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluTessNormal :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m ()
    gluTessNormal Ptr GLUtesselator
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn_gluTessNormal FunPtr
      (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_gluTessNormal Ptr GLUtesselator
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

    foreign import CALLCONV "dynamic" dyn_gluTessNormal
      :: FunPtr (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())
      ->         Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluTessNormal #-}
    ptr_gluTessNormal :: FunPtr a
    ptr_gluTessNormal :: forall a. FunPtr a
    ptr_gluTessNormal = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessNormal"

    -- gluTessProperty ----------------------------------------------------------------------

    gluTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> GLdouble -> m ()
    gluTessProperty :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLUtesselator -> GLenum -> GLdouble -> m ()
    gluTessProperty Ptr GLUtesselator
    v1 GLenum
    v2 GLdouble
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())
    -> Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()
    dyn_gluTessProperty FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_gluTessProperty Ptr GLUtesselator
    v1 GLenum
    v2 GLdouble
    v3

    foreign import CALLCONV "dynamic" dyn_gluTessProperty
      :: FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())
      ->         Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()

    {-# NOINLINE ptr_gluTessProperty #-}
    ptr_gluTessProperty :: FunPtr a
    ptr_gluTessProperty :: forall a. FunPtr a
    ptr_gluTessProperty = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessProperty"

    -- gluTessVertex ----------------------------------------------------------------------

    gluTessVertex :: MonadIO m => Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m ()
    gluTessVertex :: forall (m :: * -> *) a.
    MonadIO m =>
    Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m ()
    gluTessVertex Ptr GLUtesselator
    v1 Ptr GLdouble
    v2 Ptr a
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
    -> Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()
    forall a.
    FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
    -> Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()
    dyn_gluTessVertex FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
    forall a. FunPtr a
    ptr_gluTessVertex Ptr GLUtesselator
    v1 Ptr GLdouble
    v2 Ptr a
    v3

    foreign import CALLCONV "dynamic" dyn_gluTessVertex
      :: FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
      ->         Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()

    {-# NOINLINE ptr_gluTessVertex #-}
    ptr_gluTessVertex :: FunPtr a
    ptr_gluTessVertex :: forall a. FunPtr a
    ptr_gluTessVertex = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluTessVertex"

    -- gluUnProject ----------------------------------------------------------------------

    gluUnProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint
    gluUnProject :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> m GLint
    gluUnProject GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 Ptr GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLint
    v6 Ptr GLdouble
    v7 Ptr GLdouble
    v8 Ptr GLdouble
    v9 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> IO GLint
    dyn_gluUnProject FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluUnProject GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 Ptr GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLint
    v6 Ptr GLdouble
    v7 Ptr GLdouble
    v8 Ptr GLdouble
    v9

    foreign import CALLCONV "dynamic" dyn_gluUnProject
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)
      ->         GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint

    {-# NOINLINE ptr_gluUnProject #-}
    ptr_gluUnProject :: FunPtr a
    ptr_gluUnProject :: forall a. FunPtr a
    ptr_gluUnProject = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluUnProject"

    -- gluUnProject4 ----------------------------------------------------------------------

    gluUnProject4 :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint
    gluUnProject4 :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> m GLint
    gluUnProject4 GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLdouble
    v6 Ptr GLint
    v7 GLdouble
    v8 GLdouble
    v9 Ptr GLdouble
    v10 Ptr GLdouble
    v11 Ptr GLdouble
    v12 Ptr GLdouble
    v13 = IO GLint -> m GLint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLint
    -> GLdouble
    -> GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> Ptr GLdouble
    -> IO GLint
    dyn_gluUnProject4 FunPtr
      (GLdouble
       -> GLdouble
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLint
       -> GLdouble
       -> GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> Ptr GLdouble
       -> IO GLint)
    forall a. FunPtr a
    ptr_gluUnProject4 GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 Ptr GLdouble
    v5 Ptr GLdouble
    v6 Ptr GLint
    v7 GLdouble
    v8 GLdouble
    v9 Ptr GLdouble
    v10 Ptr GLdouble
    v11 Ptr GLdouble
    v12 Ptr GLdouble
    v13

    foreign import CALLCONV "dynamic" dyn_gluUnProject4
      :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)
      ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint

    {-# NOINLINE ptr_gluUnProject4 #-}
    ptr_gluUnProject4 :: FunPtr a
    ptr_gluUnProject4 :: forall a. FunPtr a
    ptr_gluUnProject4 = IO (FunPtr a) -> FunPtr a
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntry String
    "gluUnProject4"