    {-# LANGUAGE CPP #-}
    {-# OPTIONS_HADDOCK hide #-}
    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.UI.GLUT.Raw.Functions
    -- Copyright   :  (c) Sven Panne 2018
    -- License     :  BSD3
    --
    -- Maintainer  :  Sven Panne <svenpanne@gmail.com>
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- All raw functions from GLUT and freeglut.
    --
    --------------------------------------------------------------------------------

    module Graphics.UI.GLUT.Raw.Functions (
       isKnown,

       glutAddMenuEntry,
       glutAddSubMenu,
       glutAppStatusFunc,
       glutAttachMenu,
       glutBitmapCharacter,
       glutBitmapHeight,
       glutBitmapLength,
       glutBitmapString,
       glutBitmapWidth,
       glutButtonBoxFunc,
       glutChangeToMenuEntry,
       glutChangeToSubMenu,
       glutCloseFunc,
       glutCopyColormap,
       glutCreateMenu,
       glutCreateSubWindow,
       glutCreateWindow,
       glutDestroyMenu,
       glutDestroyWindow,
       glutDetachMenu,
       glutDeviceGet,
       glutDialsFunc,
       glutDisplayFunc,
       glutEnterGameMode,
       glutEntryFunc,
       glutEstablishOverlay,
       glutExit,
       glutExtensionSupported,
       glutForceJoystickFunc,
       glutFullScreen,
       glutFullScreenToggle,
       glutGameModeGet,
       glutGameModeString,
       glutGet,
       glutGetColor,
       glutGetMenu,
       glutGetMenuData,
       glutGetModeValues,
       glutGetModifiers,
       glutGetProcAddress,
       glutGetWindow,
       glutGetWindowData,
       glutHideOverlay,
       glutHideWindow,
       glutIconifyWindow,
       glutIdleFunc,
       glutIgnoreKeyRepeat,
       glutInit,
       glutInitContextFlags,
       glutInitContextFunc,
       glutInitContextProfile,
       glutInitContextVersion,
       glutInitDisplayMode,
       glutInitDisplayString,
       glutInitWindowPosition,
       glutInitWindowSize,
       glutJoystickFunc,
       glutKeyboardFunc,
       glutKeyboardUpFunc,
       glutLayerGet,
       glutLeaveFullScreen,
       glutLeaveGameMode,
       glutLeaveMainLoop,
       glutMainLoop,
       glutMainLoopEvent,
       glutMenuDestroyFunc,
       glutMenuStateFunc,
       glutMenuStatusFunc,
       glutMotionFunc,
       glutMouseFunc,
       glutMouseWheelFunc,
       glutMultiButtonFunc,
       glutMultiEntryFunc,
       glutMultiMotionFunc,
       glutMultiPassiveFunc,
       glutOverlayDisplayFunc,
       glutPassiveMotionFunc,
       glutPopWindow,
       glutPositionFunc,
       glutPositionWindow,
       glutPostOverlayRedisplay,
       glutPostRedisplay,
       glutPostWindowOverlayRedisplay,
       glutPostWindowRedisplay,
       glutPushWindow,
       glutRemoveMenuItem,
       glutRemoveOverlay,
       glutReportErrors,
       glutReshapeFunc,
       glutReshapeWindow,
       glutSetColor,
       glutSetCursor,
       glutSetIconTitle,
       glutSetKeyRepeat,
       glutSetMenu,
       glutSetMenuData,
       glutSetMenuFont,
       glutSetOption,
       glutSetVertexAttribCoord3,
       glutSetVertexAttribNormal,
       glutSetVertexAttribTexCoord2,
       glutSetWindow,
       glutSetWindowData,
       glutSetWindowTitle,
       glutSetupVideoResizing,
       glutShowOverlay,
       glutShowWindow,
       glutSolidCone,
       glutSolidCube,
       glutSolidCylinder,
       glutSolidDodecahedron,
       glutSolidIcosahedron,
       glutSolidOctahedron,
       glutSolidRhombicDodecahedron,
       glutSolidSierpinskiSponge,
       glutSolidSphere,
       glutSolidTeacup,
       glutSolidTeapot,
       glutSolidTeaspoon,
       glutSolidTetrahedron,
       glutSolidTorus,
       glutSpaceballButtonFunc,
       glutSpaceballMotionFunc,
       glutSpaceballRotateFunc,
       glutSpecialFunc,
       glutSpecialUpFunc,
       glutStopVideoResizing,
       glutStrokeCharacter,
       glutStrokeHeight,
       glutStrokeLength,
       glutStrokeString,
       glutStrokeWidth,
       glutSwapBuffers,
       glutTabletButtonFunc,
       glutTabletMotionFunc,
       glutTimerFunc,
       glutUseLayer,
       glutVideoPan,
       glutVideoResize,
       glutVideoResizeGet,
       glutVisibilityFunc,
       glutWMCloseFunc,
       glutWarpPointer,
       glutWindowStatusFunc,
       glutWireCone,
       glutWireCube,
       glutWireCylinder,
       glutWireDodecahedron,
       glutWireIcosahedron,
       glutWireOctahedron,
       glutWireRhombicDodecahedron,
       glutWireSierpinskiSponge,
       glutWireSphere,
       glutWireTeacup,
       glutWireTeapot,
       glutWireTeaspoon,
       glutWireTetrahedron,
       glutWireTorus
    ) where

    -- Make the foreign imports happy.
    import Foreign.C.Types

    import Control.Monad.IO.Class ( MonadIO(..) )
    import Foreign.C.String ( withCString, CString )
    import Foreign.Marshal.Error ( throwIf )
    import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr )
    import Graphics.Rendering.OpenGL ( GLdouble, GLenum, GLfloat, GLint )
    import System.IO.Unsafe ( unsafePerformIO )

    import Graphics.UI.GLUT.Raw.Callbacks

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

    -- | Retrieve a GLUT 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 GLUT 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 -> IO (FunPtr a)
    forall a. String -> IO (FunPtr a)
    getAPIEntryInternal String
    extensionEntry

    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

    getAPIEntryInternal :: String -> IO (FunPtr a)
    getAPIEntryInternal :: forall a. String -> IO (FunPtr a)
    getAPIEntryInternal String
    extensionEntry =
       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_GLUT_getProcAddress

    isKnown :: MonadIO m => String -> m Bool
    isKnown :: forall (m :: * -> *). MonadIO m => String -> m Bool
    isKnown = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> (String -> IO Bool) -> String -> m Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (FunPtr (ZonkAny 0) -> Bool) -> IO (FunPtr (ZonkAny 0)) -> IO Bool
    forall a b. (a -> b) -> IO a -> IO b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (FunPtr (ZonkAny 0) -> FunPtr (ZonkAny 0) -> Bool
    forall a. Eq a => a -> a -> Bool
    /= FunPtr (ZonkAny 0)
    forall a. FunPtr a
    nullFunPtr) (IO (FunPtr (ZonkAny 0)) -> IO Bool)
    -> (String -> IO (FunPtr (ZonkAny 0))) -> String -> IO Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> IO (FunPtr (ZonkAny 0))
    forall a. String -> IO (FunPtr a)
    getAPIEntryInternal

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

    -- glutAddMenuEntry ------------------------------------------------------------

    glutAddMenuEntry :: MonadIO m => Ptr CChar -> CInt -> m ()
    glutAddMenuEntry :: forall (m :: * -> *). MonadIO m => CString -> CInt -> m ()
    glutAddMenuEntry CString
    v1 CInt
    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 (CString -> CInt -> IO ()) -> CString -> CInt -> IO ()
    dyn_glutAddMenuEntry FunPtr (CString -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutAddMenuEntry CString
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutAddMenuEntry
      :: FunPtr (Ptr CChar -> CInt -> IO ())
      ->         Ptr CChar -> CInt -> IO ()

    {-# NOINLINE ptr_glutAddMenuEntry #-}
    ptr_glutAddMenuEntry :: FunPtr a
    ptr_glutAddMenuEntry :: forall a. FunPtr a
    ptr_glutAddMenuEntry = 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
    "glutAddMenuEntry"

    -- glutAddSubMenu --------------------------------------------------------------

    glutAddSubMenu :: MonadIO m => Ptr CChar -> CInt -> m ()
    glutAddSubMenu :: forall (m :: * -> *). MonadIO m => CString -> CInt -> m ()
    glutAddSubMenu CString
    v1 CInt
    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 (CString -> CInt -> IO ()) -> CString -> CInt -> IO ()
    dyn_glutAddSubMenu FunPtr (CString -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutAddSubMenu CString
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutAddSubMenu
      :: FunPtr (Ptr CChar -> CInt -> IO ())
      ->         Ptr CChar -> CInt -> IO ()

    {-# NOINLINE ptr_glutAddSubMenu #-}
    ptr_glutAddSubMenu :: FunPtr a
    ptr_glutAddSubMenu :: forall a. FunPtr a
    ptr_glutAddSubMenu = 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
    "glutAddSubMenu"

    -- glutAppStatusFunc -----------------------------------------------------------

    glutAppStatusFunc :: MonadIO m => FunPtr AppStatusFunc -> m ()
    glutAppStatusFunc :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m ()
    glutAppStatusFunc FunPtr (CInt -> IO ())
    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 (FunPtr (CInt -> IO ()) -> IO ())
    -> FunPtr (CInt -> IO ()) -> IO ()
    dyn_glutAppStatusFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutAppStatusFunc FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutAppStatusFunc
      :: FunPtr (FunPtr AppStatusFunc -> IO ())
      ->         FunPtr AppStatusFunc -> IO ()

    {-# NOINLINE ptr_glutAppStatusFunc #-}
    ptr_glutAppStatusFunc :: FunPtr a
    ptr_glutAppStatusFunc :: forall a. FunPtr a
    ptr_glutAppStatusFunc = 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
    "glutAppStatusFunc"

    -- glutAttachMenu --------------------------------------------------------------

    glutAttachMenu :: MonadIO m => CInt -> m ()
    glutAttachMenu :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutAttachMenu CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutAttachMenu FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutAttachMenu CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutAttachMenu
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutAttachMenu #-}
    ptr_glutAttachMenu :: FunPtr a
    ptr_glutAttachMenu :: forall a. FunPtr a
    ptr_glutAttachMenu = 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
    "glutAttachMenu"

    -- glutBitmapCharacter ---------------------------------------------------------

    glutBitmapCharacter :: MonadIO m => Ptr a -> CInt -> m ()
    glutBitmapCharacter :: forall (m :: * -> *) a. MonadIO m => Ptr a -> CInt -> m ()
    glutBitmapCharacter Ptr a
    v1 CInt
    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 a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
    forall a. FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
    dyn_glutBitmapCharacter FunPtr (Ptr a -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutBitmapCharacter Ptr a
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutBitmapCharacter
      :: FunPtr (Ptr a -> CInt -> IO ())
      ->         Ptr a -> CInt -> IO ()

    {-# NOINLINE ptr_glutBitmapCharacter #-}
    ptr_glutBitmapCharacter :: FunPtr a
    ptr_glutBitmapCharacter :: forall a. FunPtr a
    ptr_glutBitmapCharacter = 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
    "glutBitmapCharacter"

    -- glutBitmapHeight ------------------------------------------------------------

    glutBitmapHeight :: MonadIO m => Ptr a -> m CInt
    glutBitmapHeight :: forall (m :: * -> *) a. MonadIO m => Ptr a -> m CInt
    glutBitmapHeight Ptr a
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> IO CInt) -> Ptr a -> IO CInt
    forall a. FunPtr (Ptr a -> IO CInt) -> Ptr a -> IO CInt
    dyn_glutBitmapHeight FunPtr (Ptr a -> IO CInt)
    forall a. FunPtr a
    ptr_glutBitmapHeight Ptr a
    v1

    foreign import CALLCONV "dynamic" dyn_glutBitmapHeight
      :: FunPtr (Ptr a -> IO CInt)
      ->         Ptr a -> IO CInt

    {-# NOINLINE ptr_glutBitmapHeight #-}
    ptr_glutBitmapHeight :: FunPtr a
    ptr_glutBitmapHeight :: forall a. FunPtr a
    ptr_glutBitmapHeight = 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
    "glutBitmapHeight"

    -- glutBitmapLength ------------------------------------------------------------

    glutBitmapLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
    glutBitmapLength :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Ptr CUChar -> m CInt
    glutBitmapLength Ptr a
    v1 Ptr CUChar
    v2 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    -> Ptr a -> Ptr CUChar -> IO CInt
    forall a.
    FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    -> Ptr a -> Ptr CUChar -> IO CInt
    dyn_glutBitmapLength FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    forall a. FunPtr a
    ptr_glutBitmapLength Ptr a
    v1 Ptr CUChar
    v2

    foreign import CALLCONV "dynamic" dyn_glutBitmapLength
      :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
      ->         Ptr a -> Ptr CUChar -> IO CInt

    {-# NOINLINE ptr_glutBitmapLength #-}
    ptr_glutBitmapLength :: FunPtr a
    ptr_glutBitmapLength :: forall a. FunPtr a
    ptr_glutBitmapLength = 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
    "glutBitmapLength"

    -- glutBitmapString ------------------------------------------------------------

    glutBitmapString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
    glutBitmapString :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Ptr CUChar -> m ()
    glutBitmapString Ptr a
    v1 Ptr CUChar
    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 a -> Ptr CUChar -> IO ())
    -> Ptr a -> Ptr CUChar -> IO ()
    forall a.
    FunPtr (Ptr a -> Ptr CUChar -> IO ())
    -> Ptr a -> Ptr CUChar -> IO ()
    dyn_glutBitmapString FunPtr (Ptr a -> Ptr CUChar -> IO ())
    forall a. FunPtr a
    ptr_glutBitmapString Ptr a
    v1 Ptr CUChar
    v2

    foreign import CALLCONV "dynamic" dyn_glutBitmapString
      :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
      ->         Ptr a -> Ptr CUChar -> IO ()

    {-# NOINLINE ptr_glutBitmapString #-}
    ptr_glutBitmapString :: FunPtr a
    ptr_glutBitmapString :: forall a. FunPtr a
    ptr_glutBitmapString = 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
    "glutBitmapString"

    -- glutBitmapWidth -------------------------------------------------------------

    glutBitmapWidth :: MonadIO m => Ptr a -> CInt -> m CInt
    glutBitmapWidth :: forall (m :: * -> *) a. MonadIO m => Ptr a -> CInt -> m CInt
    glutBitmapWidth Ptr a
    v1 CInt
    v2 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
    forall a.
    FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
    dyn_glutBitmapWidth FunPtr (Ptr a -> CInt -> IO CInt)
    forall a. FunPtr a
    ptr_glutBitmapWidth Ptr a
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutBitmapWidth
      :: FunPtr (Ptr a -> CInt -> IO CInt)
      ->         Ptr a -> CInt -> IO CInt

    {-# NOINLINE ptr_glutBitmapWidth #-}
    ptr_glutBitmapWidth :: FunPtr a
    ptr_glutBitmapWidth :: forall a. FunPtr a
    ptr_glutBitmapWidth = 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
    "glutBitmapWidth"

    -- glutButtonBoxFunc -----------------------------------------------------------

    glutButtonBoxFunc :: MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutButtonBoxFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutButtonBoxFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutButtonBoxFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutButtonBoxFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutButtonBoxFunc
      :: FunPtr (FunPtr ButtonBoxFunc -> IO ())
      ->         FunPtr ButtonBoxFunc -> IO ()

    {-# NOINLINE ptr_glutButtonBoxFunc #-}
    ptr_glutButtonBoxFunc :: FunPtr a
    ptr_glutButtonBoxFunc :: forall a. FunPtr a
    ptr_glutButtonBoxFunc = 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
    "glutButtonBoxFunc"

    -- glutChangeToMenuEntry -------------------------------------------------------

    glutChangeToMenuEntry :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
    glutChangeToMenuEntry :: forall (m :: * -> *). MonadIO m => CInt -> CString -> CInt -> m ()
    glutChangeToMenuEntry CInt
    v1 CString
    v2 CInt
    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 (CInt -> CString -> CInt -> IO ())
    -> CInt -> CString -> CInt -> IO ()
    dyn_glutChangeToMenuEntry FunPtr (CInt -> CString -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutChangeToMenuEntry CInt
    v1 CString
    v2 CInt
    v3

    foreign import CALLCONV "dynamic" dyn_glutChangeToMenuEntry
      :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
      ->         CInt -> Ptr CChar -> CInt -> IO ()

    {-# NOINLINE ptr_glutChangeToMenuEntry #-}
    ptr_glutChangeToMenuEntry :: FunPtr a
    ptr_glutChangeToMenuEntry :: forall a. FunPtr a
    ptr_glutChangeToMenuEntry = 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
    "glutChangeToMenuEntry"

    -- glutChangeToSubMenu ---------------------------------------------------------

    glutChangeToSubMenu :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
    glutChangeToSubMenu :: forall (m :: * -> *). MonadIO m => CInt -> CString -> CInt -> m ()
    glutChangeToSubMenu CInt
    v1 CString
    v2 CInt
    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 (CInt -> CString -> CInt -> IO ())
    -> CInt -> CString -> CInt -> IO ()
    dyn_glutChangeToSubMenu FunPtr (CInt -> CString -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutChangeToSubMenu CInt
    v1 CString
    v2 CInt
    v3

    foreign import CALLCONV "dynamic" dyn_glutChangeToSubMenu
      :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
      ->         CInt -> Ptr CChar -> CInt -> IO ()

    {-# NOINLINE ptr_glutChangeToSubMenu #-}
    ptr_glutChangeToSubMenu :: FunPtr a
    ptr_glutChangeToSubMenu :: forall a. FunPtr a
    ptr_glutChangeToSubMenu = 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
    "glutChangeToSubMenu"

    -- glutCloseFunc ---------------------------------------------------------------

    glutCloseFunc :: MonadIO m => FunPtr CloseFunc -> m ()
    glutCloseFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutCloseFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutCloseFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutCloseFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutCloseFunc
      :: FunPtr (FunPtr CloseFunc -> IO ())
      ->         FunPtr CloseFunc -> IO ()

    {-# NOINLINE ptr_glutCloseFunc #-}
    ptr_glutCloseFunc :: FunPtr a
    ptr_glutCloseFunc :: forall a. FunPtr a
    ptr_glutCloseFunc = 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
    "glutCloseFunc"

    -- glutCopyColormap ------------------------------------------------------------

    glutCopyColormap :: MonadIO m => CInt -> m ()
    glutCopyColormap :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutCopyColormap CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutCopyColormap FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutCopyColormap CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutCopyColormap
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutCopyColormap #-}
    ptr_glutCopyColormap :: FunPtr a
    ptr_glutCopyColormap :: forall a. FunPtr a
    ptr_glutCopyColormap = 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
    "glutCopyColormap"

    -- glutCreateMenu --------------------------------------------------------------

    glutCreateMenu :: MonadIO m => FunPtr MenuFunc -> m CInt
    glutCreateMenu :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m CInt
    glutCreateMenu FunPtr (CInt -> IO ())
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (FunPtr (CInt -> IO ()) -> IO CInt)
    -> FunPtr (CInt -> IO ()) -> IO CInt
    dyn_glutCreateMenu FunPtr (FunPtr (CInt -> IO ()) -> IO CInt)
    forall a. FunPtr a
    ptr_glutCreateMenu FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutCreateMenu
      :: FunPtr (FunPtr MenuFunc -> IO CInt)
      ->         FunPtr MenuFunc -> IO CInt

    {-# NOINLINE ptr_glutCreateMenu #-}
    ptr_glutCreateMenu :: FunPtr a
    ptr_glutCreateMenu :: forall a. FunPtr a
    ptr_glutCreateMenu = 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
    "glutCreateMenu"

    -- glutCreateSubWindow ---------------------------------------------------------

    glutCreateSubWindow :: MonadIO m => CInt -> CInt -> CInt -> CInt -> CInt -> m CInt
    glutCreateSubWindow :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> CInt -> CInt -> CInt -> CInt -> m CInt
    glutCreateSubWindow CInt
    v1 CInt
    v2 CInt
    v3 CInt
    v4 CInt
    v5 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
    -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt
    dyn_glutCreateSubWindow FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
    forall a. FunPtr a
    ptr_glutCreateSubWindow CInt
    v1 CInt
    v2 CInt
    v3 CInt
    v4 CInt
    v5

    foreign import CALLCONV "dynamic" dyn_glutCreateSubWindow
      :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
      ->         CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt

    {-# NOINLINE ptr_glutCreateSubWindow #-}
    ptr_glutCreateSubWindow :: FunPtr a
    ptr_glutCreateSubWindow :: forall a. FunPtr a
    ptr_glutCreateSubWindow = 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
    "glutCreateSubWindow"

    -- glutCreateWindow ------------------------------------------------------------

    glutCreateWindow :: MonadIO m => Ptr CChar -> m CInt
    glutCreateWindow :: forall (m :: * -> *). MonadIO m => CString -> m CInt
    glutCreateWindow CString
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (CString -> IO CInt) -> CString -> IO CInt
    dyn_glutCreateWindow FunPtr (CString -> IO CInt)
    forall a. FunPtr a
    ptr_glutCreateWindow CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutCreateWindow
      :: FunPtr (Ptr CChar -> IO CInt)
      ->         Ptr CChar -> IO CInt

    {-# NOINLINE ptr_glutCreateWindow #-}
    ptr_glutCreateWindow :: FunPtr a
    ptr_glutCreateWindow :: forall a. FunPtr a
    ptr_glutCreateWindow = 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
    "glutCreateWindow"

    -- glutDestroyMenu -------------------------------------------------------------

    glutDestroyMenu :: MonadIO m => CInt -> m ()
    glutDestroyMenu :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutDestroyMenu CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutDestroyMenu FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutDestroyMenu CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutDestroyMenu
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutDestroyMenu #-}
    ptr_glutDestroyMenu :: FunPtr a
    ptr_glutDestroyMenu :: forall a. FunPtr a
    ptr_glutDestroyMenu = 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
    "glutDestroyMenu"

    -- glutDestroyWindow -----------------------------------------------------------

    glutDestroyWindow :: MonadIO m => CInt -> m ()
    glutDestroyWindow :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutDestroyWindow CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutDestroyWindow FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutDestroyWindow CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutDestroyWindow
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutDestroyWindow #-}
    ptr_glutDestroyWindow :: FunPtr a
    ptr_glutDestroyWindow :: forall a. FunPtr a
    ptr_glutDestroyWindow = 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
    "glutDestroyWindow"

    -- glutDetachMenu --------------------------------------------------------------

    glutDetachMenu :: MonadIO m => CInt -> m ()
    glutDetachMenu :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutDetachMenu CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutDetachMenu FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutDetachMenu CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutDetachMenu
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutDetachMenu #-}
    ptr_glutDetachMenu :: FunPtr a
    ptr_glutDetachMenu :: forall a. FunPtr a
    ptr_glutDetachMenu = 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
    "glutDetachMenu"

    -- glutDeviceGet ---------------------------------------------------------------

    glutDeviceGet :: MonadIO m => GLenum -> m CInt
    glutDeviceGet :: forall (m :: * -> *). MonadIO m => GLenum -> m CInt
    glutDeviceGet GLenum
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
    dyn_glutDeviceGet FunPtr (GLenum -> IO CInt)
    forall a. FunPtr a
    ptr_glutDeviceGet GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutDeviceGet
      :: FunPtr (GLenum -> IO CInt)
      ->         GLenum -> IO CInt

    {-# NOINLINE ptr_glutDeviceGet #-}
    ptr_glutDeviceGet :: FunPtr a
    ptr_glutDeviceGet :: forall a. FunPtr a
    ptr_glutDeviceGet = 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
    "glutDeviceGet"

    -- glutDialsFunc ---------------------------------------------------------------

    glutDialsFunc :: MonadIO m => FunPtr DialsFunc -> m ()
    glutDialsFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutDialsFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutDialsFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutDialsFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutDialsFunc
      :: FunPtr (FunPtr DialsFunc -> IO ())
      ->         FunPtr DialsFunc -> IO ()

    {-# NOINLINE ptr_glutDialsFunc #-}
    ptr_glutDialsFunc :: FunPtr a
    ptr_glutDialsFunc :: forall a. FunPtr a
    ptr_glutDialsFunc = 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
    "glutDialsFunc"

    -- glutDisplayFunc -------------------------------------------------------------

    glutDisplayFunc :: MonadIO m => FunPtr DisplayFunc -> m ()
    glutDisplayFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutDisplayFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutDisplayFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutDisplayFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutDisplayFunc
      :: FunPtr (FunPtr DisplayFunc -> IO ())
      ->         FunPtr DisplayFunc -> IO ()

    {-# NOINLINE ptr_glutDisplayFunc #-}
    ptr_glutDisplayFunc :: FunPtr a
    ptr_glutDisplayFunc :: forall a. FunPtr a
    ptr_glutDisplayFunc = 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
    "glutDisplayFunc"

    -- glutEnterGameMode -----------------------------------------------------------

    glutEnterGameMode :: MonadIO m => m CInt
    glutEnterGameMode :: forall (m :: * -> *). MonadIO m => m CInt
    glutEnterGameMode = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO CInt) -> IO CInt
    dyn_glutEnterGameMode FunPtr (IO CInt)
    forall a. FunPtr a
    ptr_glutEnterGameMode

    foreign import CALLCONV "dynamic" dyn_glutEnterGameMode
      :: FunPtr (IO CInt)
      ->         IO CInt

    {-# NOINLINE ptr_glutEnterGameMode #-}
    ptr_glutEnterGameMode :: FunPtr a
    ptr_glutEnterGameMode :: forall a. FunPtr a
    ptr_glutEnterGameMode = 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
    "glutEnterGameMode"

    -- glutEntryFunc ---------------------------------------------------------------

    glutEntryFunc :: MonadIO m => FunPtr EntryFunc -> m ()
    glutEntryFunc :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m ()
    glutEntryFunc FunPtr (CInt -> IO ())
    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 (FunPtr (CInt -> IO ()) -> IO ())
    -> FunPtr (CInt -> IO ()) -> IO ()
    dyn_glutEntryFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutEntryFunc FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutEntryFunc
      :: FunPtr (FunPtr EntryFunc -> IO ())
      ->         FunPtr EntryFunc -> IO ()

    {-# NOINLINE ptr_glutEntryFunc #-}
    ptr_glutEntryFunc :: FunPtr a
    ptr_glutEntryFunc :: forall a. FunPtr a
    ptr_glutEntryFunc = 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
    "glutEntryFunc"

    -- glutEstablishOverlay --------------------------------------------------------

    glutEstablishOverlay :: MonadIO m => m ()
    glutEstablishOverlay :: forall (m :: * -> *). MonadIO m => m ()
    glutEstablishOverlay = 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 (IO ()) -> IO ()
    dyn_glutEstablishOverlay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutEstablishOverlay

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

    {-# NOINLINE ptr_glutEstablishOverlay #-}
    ptr_glutEstablishOverlay :: FunPtr a
    ptr_glutEstablishOverlay :: forall a. FunPtr a
    ptr_glutEstablishOverlay = 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
    "glutEstablishOverlay"

    -- glutExit --------------------------------------------------------------------

    glutExit :: MonadIO m => m ()
    glutExit :: forall (m :: * -> *). MonadIO m => m ()
    glutExit = 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 (IO ()) -> IO ()
    dyn_glutExit FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutExit

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

    {-# NOINLINE ptr_glutExit #-}
    ptr_glutExit :: FunPtr a
    ptr_glutExit :: forall a. FunPtr a
    ptr_glutExit = 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
    "glutExit"

    -- glutExtensionSupported ------------------------------------------------------

    glutExtensionSupported :: MonadIO m => Ptr CChar -> m CInt
    glutExtensionSupported :: forall (m :: * -> *). MonadIO m => CString -> m CInt
    glutExtensionSupported CString
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (CString -> IO CInt) -> CString -> IO CInt
    dyn_glutExtensionSupported FunPtr (CString -> IO CInt)
    forall a. FunPtr a
    ptr_glutExtensionSupported CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutExtensionSupported
      :: FunPtr (Ptr CChar -> IO CInt)
      ->         Ptr CChar -> IO CInt

    {-# NOINLINE ptr_glutExtensionSupported #-}
    ptr_glutExtensionSupported :: FunPtr a
    ptr_glutExtensionSupported :: forall a. FunPtr a
    ptr_glutExtensionSupported = 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
    "glutExtensionSupported"

    -- glutForceJoystickFunc -------------------------------------------------------

    glutForceJoystickFunc :: MonadIO m => m ()
    glutForceJoystickFunc :: forall (m :: * -> *). MonadIO m => m ()
    glutForceJoystickFunc = 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 (IO ()) -> IO ()
    dyn_glutForceJoystickFunc FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutForceJoystickFunc

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

    {-# NOINLINE ptr_glutForceJoystickFunc #-}
    ptr_glutForceJoystickFunc :: FunPtr a
    ptr_glutForceJoystickFunc :: forall a. FunPtr a
    ptr_glutForceJoystickFunc = 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
    "glutForceJoystickFunc"

    -- glutFullScreen --------------------------------------------------------------

    glutFullScreen :: MonadIO m => m ()
    glutFullScreen :: forall (m :: * -> *). MonadIO m => m ()
    glutFullScreen = 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 (IO ()) -> IO ()
    dyn_glutFullScreen FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutFullScreen

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

    {-# NOINLINE ptr_glutFullScreen #-}
    ptr_glutFullScreen :: FunPtr a
    ptr_glutFullScreen :: forall a. FunPtr a
    ptr_glutFullScreen = 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
    "glutFullScreen"

    -- glutFullScreenToggle --------------------------------------------------------

    glutFullScreenToggle :: MonadIO m => m ()
    glutFullScreenToggle :: forall (m :: * -> *). MonadIO m => m ()
    glutFullScreenToggle = 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 (IO ()) -> IO ()
    dyn_glutFullScreenToggle FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutFullScreenToggle

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

    {-# NOINLINE ptr_glutFullScreenToggle #-}
    ptr_glutFullScreenToggle :: FunPtr a
    ptr_glutFullScreenToggle :: forall a. FunPtr a
    ptr_glutFullScreenToggle = 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
    "glutFullScreenToggle"

    -- glutGameModeGet -------------------------------------------------------------

    glutGameModeGet :: MonadIO m => GLenum -> m CInt
    glutGameModeGet :: forall (m :: * -> *). MonadIO m => GLenum -> m CInt
    glutGameModeGet GLenum
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
    dyn_glutGameModeGet FunPtr (GLenum -> IO CInt)
    forall a. FunPtr a
    ptr_glutGameModeGet GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutGameModeGet
      :: FunPtr (GLenum -> IO CInt)
      ->         GLenum -> IO CInt

    {-# NOINLINE ptr_glutGameModeGet #-}
    ptr_glutGameModeGet :: FunPtr a
    ptr_glutGameModeGet :: forall a. FunPtr a
    ptr_glutGameModeGet = 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
    "glutGameModeGet"

    -- glutGameModeString ----------------------------------------------------------

    glutGameModeString :: MonadIO m => Ptr CChar -> m ()
    glutGameModeString :: forall (m :: * -> *). MonadIO m => CString -> m ()
    glutGameModeString CString
    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 (CString -> IO ()) -> CString -> IO ()
    dyn_glutGameModeString FunPtr (CString -> IO ())
    forall a. FunPtr a
    ptr_glutGameModeString CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutGameModeString
      :: FunPtr (Ptr CChar -> IO ())
      ->         Ptr CChar -> IO ()

    {-# NOINLINE ptr_glutGameModeString #-}
    ptr_glutGameModeString :: FunPtr a
    ptr_glutGameModeString :: forall a. FunPtr a
    ptr_glutGameModeString = 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
    "glutGameModeString"

    -- glutGet ---------------------------------------------------------------------

    glutGet :: MonadIO m => GLenum -> m CInt
    glutGet :: forall (m :: * -> *). MonadIO m => GLenum -> m CInt
    glutGet GLenum
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
    dyn_glutGet FunPtr (GLenum -> IO CInt)
    forall a. FunPtr a
    ptr_glutGet GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutGet
      :: FunPtr (GLenum -> IO CInt)
      ->         GLenum -> IO CInt

    {-# NOINLINE ptr_glutGet #-}
    ptr_glutGet :: FunPtr a
    ptr_glutGet :: forall a. FunPtr a
    ptr_glutGet = 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
    "glutGet"

    -- glutGetColor ----------------------------------------------------------------

    glutGetColor :: MonadIO m => CInt -> CInt -> m GLfloat
    glutGetColor :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m GLfloat
    glutGetColor CInt
    v1 CInt
    v2 = IO GLfloat -> m GLfloat
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLfloat -> m GLfloat) -> IO GLfloat -> m GLfloat
    forall a b. (a -> b) -> a -> b
    $ FunPtr (CInt -> CInt -> IO GLfloat) -> CInt -> CInt -> IO GLfloat
    dyn_glutGetColor FunPtr (CInt -> CInt -> IO GLfloat)
    forall a. FunPtr a
    ptr_glutGetColor CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutGetColor
      :: FunPtr (CInt -> CInt -> IO GLfloat)
      ->         CInt -> CInt -> IO GLfloat

    {-# NOINLINE ptr_glutGetColor #-}
    ptr_glutGetColor :: FunPtr a
    ptr_glutGetColor :: forall a. FunPtr a
    ptr_glutGetColor = 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
    "glutGetColor"

    -- glutGetMenu -----------------------------------------------------------------

    glutGetMenu :: MonadIO m => m CInt
    glutGetMenu :: forall (m :: * -> *). MonadIO m => m CInt
    glutGetMenu = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO CInt) -> IO CInt
    dyn_glutGetMenu FunPtr (IO CInt)
    forall a. FunPtr a
    ptr_glutGetMenu

    foreign import CALLCONV "dynamic" dyn_glutGetMenu
      :: FunPtr (IO CInt)
      ->         IO CInt

    {-# NOINLINE ptr_glutGetMenu #-}
    ptr_glutGetMenu :: FunPtr a
    ptr_glutGetMenu :: forall a. FunPtr a
    ptr_glutGetMenu = 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
    "glutGetMenu"

    -- glutGetMenuData -------------------------------------------------------------

    glutGetMenuData :: MonadIO m => m (Ptr a)
    glutGetMenuData :: forall (m :: * -> *) a. MonadIO m => m (Ptr a)
    glutGetMenuData = IO (Ptr a) -> m (Ptr a)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr a) -> m (Ptr a)) -> IO (Ptr a) -> m (Ptr a)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO (Ptr a)) -> IO (Ptr a)
    forall a. FunPtr (IO (Ptr a)) -> IO (Ptr a)
    dyn_glutGetMenuData FunPtr (IO (Ptr a))
    forall a. FunPtr a
    ptr_glutGetMenuData

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

    {-# NOINLINE ptr_glutGetMenuData #-}
    ptr_glutGetMenuData :: FunPtr a
    ptr_glutGetMenuData :: forall a. FunPtr a
    ptr_glutGetMenuData = 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
    "glutGetMenuData"

    -- glutGetModeValues -----------------------------------------------------------

    glutGetModeValues :: MonadIO m => GLenum -> Ptr CInt -> m (Ptr CInt)
    glutGetModeValues :: forall (m :: * -> *).
    MonadIO m =>
    GLenum -> Ptr CInt -> m (Ptr CInt)
    glutGetModeValues GLenum
    v1 Ptr CInt
    v2 = IO (Ptr CInt) -> m (Ptr CInt)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr CInt) -> m (Ptr CInt)) -> IO (Ptr CInt) -> m (Ptr CInt)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
    -> GLenum -> Ptr CInt -> IO (Ptr CInt)
    dyn_glutGetModeValues FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
    forall a. FunPtr a
    ptr_glutGetModeValues GLenum
    v1 Ptr CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutGetModeValues
      :: FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
      ->         GLenum -> Ptr CInt -> IO (Ptr CInt)

    {-# NOINLINE ptr_glutGetModeValues #-}
    ptr_glutGetModeValues :: FunPtr a
    ptr_glutGetModeValues :: forall a. FunPtr a
    ptr_glutGetModeValues = 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
    "glutGetModeValues"

    -- glutGetModifiers ------------------------------------------------------------

    glutGetModifiers :: MonadIO m => m CInt
    glutGetModifiers :: forall (m :: * -> *). MonadIO m => m CInt
    glutGetModifiers = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO CInt) -> IO CInt
    dyn_glutGetModifiers FunPtr (IO CInt)
    forall a. FunPtr a
    ptr_glutGetModifiers

    foreign import CALLCONV "dynamic" dyn_glutGetModifiers
      :: FunPtr (IO CInt)
      ->         IO CInt

    {-# NOINLINE ptr_glutGetModifiers #-}
    ptr_glutGetModifiers :: FunPtr a
    ptr_glutGetModifiers :: forall a. FunPtr a
    ptr_glutGetModifiers = 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
    "glutGetModifiers"

    -- glutGetProcAddress ----------------------------------------------------------

    glutGetProcAddress :: MonadIO m => Ptr CChar -> m (FunPtr a)
    glutGetProcAddress :: forall (m :: * -> *) a. MonadIO m => CString -> m (FunPtr a)
    glutGetProcAddress CString
    v1 = IO (FunPtr a) -> m (FunPtr a)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (FunPtr a) -> m (FunPtr a)) -> IO (FunPtr a) -> m (FunPtr a)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (CString -> IO (FunPtr a)) -> CString -> IO (FunPtr a)
    forall a.
    FunPtr (CString -> IO (FunPtr a)) -> CString -> IO (FunPtr a)
    dyn_glutGetProcAddress FunPtr (CString -> IO (FunPtr a))
    forall a. FunPtr a
    ptr_glutGetProcAddress CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutGetProcAddress
      :: FunPtr (Ptr CChar -> IO (FunPtr a))
      ->         Ptr CChar -> IO (FunPtr a)

    {-# NOINLINE ptr_glutGetProcAddress #-}
    ptr_glutGetProcAddress :: FunPtr a
    ptr_glutGetProcAddress :: forall a. FunPtr a
    ptr_glutGetProcAddress = 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
    "glutGetProcAddress"

    -- glutGetWindow ---------------------------------------------------------------

    glutGetWindow :: MonadIO m => m CInt
    glutGetWindow :: forall (m :: * -> *). MonadIO m => m CInt
    glutGetWindow = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO CInt) -> IO CInt
    dyn_glutGetWindow FunPtr (IO CInt)
    forall a. FunPtr a
    ptr_glutGetWindow

    foreign import CALLCONV "dynamic" dyn_glutGetWindow
      :: FunPtr (IO CInt)
      ->         IO CInt

    {-# NOINLINE ptr_glutGetWindow #-}
    ptr_glutGetWindow :: FunPtr a
    ptr_glutGetWindow :: forall a. FunPtr a
    ptr_glutGetWindow = 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
    "glutGetWindow"

    -- glutGetWindowData -----------------------------------------------------------

    glutGetWindowData :: MonadIO m => m (Ptr a)
    glutGetWindowData :: forall (m :: * -> *) a. MonadIO m => m (Ptr a)
    glutGetWindowData = IO (Ptr a) -> m (Ptr a)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Ptr a) -> m (Ptr a)) -> IO (Ptr a) -> m (Ptr a)
    forall a b. (a -> b) -> a -> b
    $ FunPtr (IO (Ptr a)) -> IO (Ptr a)
    forall a. FunPtr (IO (Ptr a)) -> IO (Ptr a)
    dyn_glutGetWindowData FunPtr (IO (Ptr a))
    forall a. FunPtr a
    ptr_glutGetWindowData

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

    {-# NOINLINE ptr_glutGetWindowData #-}
    ptr_glutGetWindowData :: FunPtr a
    ptr_glutGetWindowData :: forall a. FunPtr a
    ptr_glutGetWindowData = 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
    "glutGetWindowData"

    -- glutHideOverlay -------------------------------------------------------------

    glutHideOverlay :: MonadIO m => m ()
    glutHideOverlay :: forall (m :: * -> *). MonadIO m => m ()
    glutHideOverlay = 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 (IO ()) -> IO ()
    dyn_glutHideOverlay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutHideOverlay

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

    {-# NOINLINE ptr_glutHideOverlay #-}
    ptr_glutHideOverlay :: FunPtr a
    ptr_glutHideOverlay :: forall a. FunPtr a
    ptr_glutHideOverlay = 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
    "glutHideOverlay"

    -- glutHideWindow --------------------------------------------------------------

    glutHideWindow :: MonadIO m => m ()
    glutHideWindow :: forall (m :: * -> *). MonadIO m => m ()
    glutHideWindow = 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 (IO ()) -> IO ()
    dyn_glutHideWindow FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutHideWindow

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

    {-# NOINLINE ptr_glutHideWindow #-}
    ptr_glutHideWindow :: FunPtr a
    ptr_glutHideWindow :: forall a. FunPtr a
    ptr_glutHideWindow = 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
    "glutHideWindow"

    -- glutIconifyWindow -----------------------------------------------------------

    glutIconifyWindow :: MonadIO m => m ()
    glutIconifyWindow :: forall (m :: * -> *). MonadIO m => m ()
    glutIconifyWindow = 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 (IO ()) -> IO ()
    dyn_glutIconifyWindow FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutIconifyWindow

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

    {-# NOINLINE ptr_glutIconifyWindow #-}
    ptr_glutIconifyWindow :: FunPtr a
    ptr_glutIconifyWindow :: forall a. FunPtr a
    ptr_glutIconifyWindow = 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
    "glutIconifyWindow"

    -- glutIdleFunc ----------------------------------------------------------------

    glutIdleFunc :: MonadIO m => FunPtr IdleFunc -> m ()
    glutIdleFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutIdleFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutIdleFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutIdleFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutIdleFunc
      :: FunPtr (FunPtr IdleFunc -> IO ())
      ->         FunPtr IdleFunc -> IO ()

    {-# NOINLINE ptr_glutIdleFunc #-}
    ptr_glutIdleFunc :: FunPtr a
    ptr_glutIdleFunc :: forall a. FunPtr a
    ptr_glutIdleFunc = 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
    "glutIdleFunc"

    -- glutIgnoreKeyRepeat ---------------------------------------------------------

    glutIgnoreKeyRepeat :: MonadIO m => CInt -> m ()
    glutIgnoreKeyRepeat :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutIgnoreKeyRepeat CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutIgnoreKeyRepeat FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutIgnoreKeyRepeat CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutIgnoreKeyRepeat
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutIgnoreKeyRepeat #-}
    ptr_glutIgnoreKeyRepeat :: FunPtr a
    ptr_glutIgnoreKeyRepeat :: forall a. FunPtr a
    ptr_glutIgnoreKeyRepeat = 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
    "glutIgnoreKeyRepeat"

    -- glutInit --------------------------------------------------------------------

    glutInit :: MonadIO m => Ptr CInt -> Ptr (Ptr CChar) -> m ()
    glutInit :: forall (m :: * -> *). MonadIO m => Ptr CInt -> Ptr CString -> m ()
    glutInit Ptr CInt
    v1 Ptr CString
    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 CInt -> Ptr CString -> IO ())
    -> Ptr CInt -> Ptr CString -> IO ()
    dyn_glutInit FunPtr (Ptr CInt -> Ptr CString -> IO ())
    forall a. FunPtr a
    ptr_glutInit Ptr CInt
    v1 Ptr CString
    v2

    foreign import CALLCONV "dynamic" dyn_glutInit
      :: FunPtr (Ptr CInt -> Ptr (Ptr CChar) -> IO ())
      ->         Ptr CInt -> Ptr (Ptr CChar) -> IO ()

    {-# NOINLINE ptr_glutInit #-}
    ptr_glutInit :: FunPtr a
    ptr_glutInit :: forall a. FunPtr a
    ptr_glutInit = 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
    "glutInit"

    -- glutInitContextFlags --------------------------------------------------------

    glutInitContextFlags :: MonadIO m => CInt -> m ()
    glutInitContextFlags :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutInitContextFlags CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutInitContextFlags FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutInitContextFlags CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutInitContextFlags
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutInitContextFlags #-}
    ptr_glutInitContextFlags :: FunPtr a
    ptr_glutInitContextFlags :: forall a. FunPtr a
    ptr_glutInitContextFlags = 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
    "glutInitContextFlags"

    -- glutInitContextFunc ---------------------------------------------------------

    glutInitContextFunc :: MonadIO m => FunPtr InitContextFunc -> m ()
    glutInitContextFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutInitContextFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutInitContextFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutInitContextFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutInitContextFunc
      :: FunPtr (FunPtr InitContextFunc -> IO ())
      ->         FunPtr InitContextFunc -> IO ()

    {-# NOINLINE ptr_glutInitContextFunc #-}
    ptr_glutInitContextFunc :: FunPtr a
    ptr_glutInitContextFunc :: forall a. FunPtr a
    ptr_glutInitContextFunc = 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
    "glutInitContextFunc"

    -- glutInitContextProfile ------------------------------------------------------

    glutInitContextProfile :: MonadIO m => CInt -> m ()
    glutInitContextProfile :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutInitContextProfile CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutInitContextProfile FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutInitContextProfile CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutInitContextProfile
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutInitContextProfile #-}
    ptr_glutInitContextProfile :: FunPtr a
    ptr_glutInitContextProfile :: forall a. FunPtr a
    ptr_glutInitContextProfile = 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
    "glutInitContextProfile"

    -- glutInitContextVersion ------------------------------------------------------

    glutInitContextVersion :: MonadIO m => CInt -> CInt -> m ()
    glutInitContextVersion :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutInitContextVersion CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutInitContextVersion FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutInitContextVersion CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutInitContextVersion
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutInitContextVersion #-}
    ptr_glutInitContextVersion :: FunPtr a
    ptr_glutInitContextVersion :: forall a. FunPtr a
    ptr_glutInitContextVersion = 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
    "glutInitContextVersion"

    -- glutInitDisplayMode ---------------------------------------------------------

    glutInitDisplayMode :: MonadIO m => CUInt -> m ()
    glutInitDisplayMode :: forall (m :: * -> *). MonadIO m => CUInt -> m ()
    glutInitDisplayMode CUInt
    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 (CUInt -> IO ()) -> CUInt -> IO ()
    dyn_glutInitDisplayMode FunPtr (CUInt -> IO ())
    forall a. FunPtr a
    ptr_glutInitDisplayMode CUInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutInitDisplayMode
      :: FunPtr (CUInt -> IO ())
      ->         CUInt -> IO ()

    {-# NOINLINE ptr_glutInitDisplayMode #-}
    ptr_glutInitDisplayMode :: FunPtr a
    ptr_glutInitDisplayMode :: forall a. FunPtr a
    ptr_glutInitDisplayMode = 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
    "glutInitDisplayMode"

    -- glutInitDisplayString -------------------------------------------------------

    glutInitDisplayString :: MonadIO m => Ptr CChar -> m ()
    glutInitDisplayString :: forall (m :: * -> *). MonadIO m => CString -> m ()
    glutInitDisplayString CString
    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 (CString -> IO ()) -> CString -> IO ()
    dyn_glutInitDisplayString FunPtr (CString -> IO ())
    forall a. FunPtr a
    ptr_glutInitDisplayString CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutInitDisplayString
      :: FunPtr (Ptr CChar -> IO ())
      ->         Ptr CChar -> IO ()

    {-# NOINLINE ptr_glutInitDisplayString #-}
    ptr_glutInitDisplayString :: FunPtr a
    ptr_glutInitDisplayString :: forall a. FunPtr a
    ptr_glutInitDisplayString = 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
    "glutInitDisplayString"

    -- glutInitWindowPosition ------------------------------------------------------

    glutInitWindowPosition :: MonadIO m => CInt -> CInt -> m ()
    glutInitWindowPosition :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutInitWindowPosition CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutInitWindowPosition FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutInitWindowPosition CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutInitWindowPosition
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutInitWindowPosition #-}
    ptr_glutInitWindowPosition :: FunPtr a
    ptr_glutInitWindowPosition :: forall a. FunPtr a
    ptr_glutInitWindowPosition = 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
    "glutInitWindowPosition"

    -- glutInitWindowSize ----------------------------------------------------------

    glutInitWindowSize :: MonadIO m => CInt -> CInt -> m ()
    glutInitWindowSize :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutInitWindowSize CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutInitWindowSize FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutInitWindowSize CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutInitWindowSize
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutInitWindowSize #-}
    ptr_glutInitWindowSize :: FunPtr a
    ptr_glutInitWindowSize :: forall a. FunPtr a
    ptr_glutInitWindowSize = 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
    "glutInitWindowSize"

    -- glutJoystickFunc ------------------------------------------------------------

    glutJoystickFunc :: MonadIO m => FunPtr JoystickFunc -> CInt -> m ()
    glutJoystickFunc :: forall (m :: * -> *).
    MonadIO m =>
    FunPtr JoystickFunc -> CInt -> m ()
    glutJoystickFunc FunPtr JoystickFunc
    v1 CInt
    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 (FunPtr JoystickFunc -> CInt -> IO ())
    -> FunPtr JoystickFunc -> CInt -> IO ()
    dyn_glutJoystickFunc FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutJoystickFunc FunPtr JoystickFunc
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutJoystickFunc
      :: FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
      ->         FunPtr JoystickFunc -> CInt -> IO ()

    {-# NOINLINE ptr_glutJoystickFunc #-}
    ptr_glutJoystickFunc :: FunPtr a
    ptr_glutJoystickFunc :: forall a. FunPtr a
    ptr_glutJoystickFunc = 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
    "glutJoystickFunc"

    -- glutKeyboardFunc ------------------------------------------------------------

    glutKeyboardFunc :: MonadIO m => FunPtr KeyboardFunc -> m ()
    glutKeyboardFunc :: forall (m :: * -> *). MonadIO m => FunPtr KeyboardFunc -> m ()
    glutKeyboardFunc FunPtr KeyboardFunc
    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 (FunPtr KeyboardFunc -> IO ())
    -> FunPtr KeyboardFunc -> IO ()
    dyn_glutKeyboardFunc FunPtr (FunPtr KeyboardFunc -> IO ())
    forall a. FunPtr a
    ptr_glutKeyboardFunc FunPtr KeyboardFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutKeyboardFunc
      :: FunPtr (FunPtr KeyboardFunc -> IO ())
      ->         FunPtr KeyboardFunc -> IO ()

    {-# NOINLINE ptr_glutKeyboardFunc #-}
    ptr_glutKeyboardFunc :: FunPtr a
    ptr_glutKeyboardFunc :: forall a. FunPtr a
    ptr_glutKeyboardFunc = 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
    "glutKeyboardFunc"

    -- glutKeyboardUpFunc ----------------------------------------------------------

    glutKeyboardUpFunc :: MonadIO m => FunPtr KeyboardUpFunc -> m ()
    glutKeyboardUpFunc :: forall (m :: * -> *). MonadIO m => FunPtr KeyboardFunc -> m ()
    glutKeyboardUpFunc FunPtr KeyboardFunc
    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 (FunPtr KeyboardFunc -> IO ())
    -> FunPtr KeyboardFunc -> IO ()
    dyn_glutKeyboardUpFunc FunPtr (FunPtr KeyboardFunc -> IO ())
    forall a. FunPtr a
    ptr_glutKeyboardUpFunc FunPtr KeyboardFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutKeyboardUpFunc
      :: FunPtr (FunPtr KeyboardUpFunc -> IO ())
      ->         FunPtr KeyboardUpFunc -> IO ()

    {-# NOINLINE ptr_glutKeyboardUpFunc #-}
    ptr_glutKeyboardUpFunc :: FunPtr a
    ptr_glutKeyboardUpFunc :: forall a. FunPtr a
    ptr_glutKeyboardUpFunc = 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
    "glutKeyboardUpFunc"

    -- glutLayerGet ----------------------------------------------------------------

    glutLayerGet :: MonadIO m => GLenum -> m CInt
    glutLayerGet :: forall (m :: * -> *). MonadIO m => GLenum -> m CInt
    glutLayerGet GLenum
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
    dyn_glutLayerGet FunPtr (GLenum -> IO CInt)
    forall a. FunPtr a
    ptr_glutLayerGet GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutLayerGet
      :: FunPtr (GLenum -> IO CInt)
      ->         GLenum -> IO CInt

    {-# NOINLINE ptr_glutLayerGet #-}
    ptr_glutLayerGet :: FunPtr a
    ptr_glutLayerGet :: forall a. FunPtr a
    ptr_glutLayerGet = 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
    "glutLayerGet"

    -- glutLeaveFullScreen ---------------------------------------------------------

    glutLeaveFullScreen :: MonadIO m => m ()
    glutLeaveFullScreen :: forall (m :: * -> *). MonadIO m => m ()
    glutLeaveFullScreen = 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 (IO ()) -> IO ()
    dyn_glutLeaveFullScreen FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutLeaveFullScreen

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

    {-# NOINLINE ptr_glutLeaveFullScreen #-}
    ptr_glutLeaveFullScreen :: FunPtr a
    ptr_glutLeaveFullScreen :: forall a. FunPtr a
    ptr_glutLeaveFullScreen = 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
    "glutLeaveFullScreen"

    -- glutLeaveGameMode -----------------------------------------------------------

    glutLeaveGameMode :: MonadIO m => m ()
    glutLeaveGameMode :: forall (m :: * -> *). MonadIO m => m ()
    glutLeaveGameMode = 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 (IO ()) -> IO ()
    dyn_glutLeaveGameMode FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutLeaveGameMode

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

    {-# NOINLINE ptr_glutLeaveGameMode #-}
    ptr_glutLeaveGameMode :: FunPtr a
    ptr_glutLeaveGameMode :: forall a. FunPtr a
    ptr_glutLeaveGameMode = 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
    "glutLeaveGameMode"

    -- glutLeaveMainLoop -----------------------------------------------------------

    glutLeaveMainLoop :: MonadIO m => m ()
    glutLeaveMainLoop :: forall (m :: * -> *). MonadIO m => m ()
    glutLeaveMainLoop = 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 (IO ()) -> IO ()
    dyn_glutLeaveMainLoop FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutLeaveMainLoop

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

    {-# NOINLINE ptr_glutLeaveMainLoop #-}
    ptr_glutLeaveMainLoop :: FunPtr a
    ptr_glutLeaveMainLoop :: forall a. FunPtr a
    ptr_glutLeaveMainLoop = 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
    "glutLeaveMainLoop"

    -- glutMainLoop ----------------------------------------------------------------

    glutMainLoop :: MonadIO m => m ()
    glutMainLoop :: forall (m :: * -> *). MonadIO m => m ()
    glutMainLoop = 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 (IO ()) -> IO ()
    dyn_glutMainLoop FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutMainLoop

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

    {-# NOINLINE ptr_glutMainLoop #-}
    ptr_glutMainLoop :: FunPtr a
    ptr_glutMainLoop :: forall a. FunPtr a
    ptr_glutMainLoop = 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
    "glutMainLoop"

    -- glutMainLoopEvent -----------------------------------------------------------

    glutMainLoopEvent :: MonadIO m => m ()
    glutMainLoopEvent :: forall (m :: * -> *). MonadIO m => m ()
    glutMainLoopEvent = 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 (IO ()) -> IO ()
    dyn_glutMainLoopEvent FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutMainLoopEvent

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

    {-# NOINLINE ptr_glutMainLoopEvent #-}
    ptr_glutMainLoopEvent :: FunPtr a
    ptr_glutMainLoopEvent :: forall a. FunPtr a
    ptr_glutMainLoopEvent = 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
    "glutMainLoopEvent"

    -- glutMenuDestroyFunc ---------------------------------------------------------

    glutMenuDestroyFunc :: MonadIO m => FunPtr MenuDestroyFunc -> m ()
    glutMenuDestroyFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutMenuDestroyFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutMenuDestroyFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutMenuDestroyFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutMenuDestroyFunc
      :: FunPtr (FunPtr MenuDestroyFunc -> IO ())
      ->         FunPtr MenuDestroyFunc -> IO ()

    {-# NOINLINE ptr_glutMenuDestroyFunc #-}
    ptr_glutMenuDestroyFunc :: FunPtr a
    ptr_glutMenuDestroyFunc :: forall a. FunPtr a
    ptr_glutMenuDestroyFunc = 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
    "glutMenuDestroyFunc"

    -- glutMenuStateFunc -----------------------------------------------------------

    glutMenuStateFunc :: MonadIO m => FunPtr MenuStateFunc -> m ()
    glutMenuStateFunc :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m ()
    glutMenuStateFunc FunPtr (CInt -> IO ())
    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 (FunPtr (CInt -> IO ()) -> IO ())
    -> FunPtr (CInt -> IO ()) -> IO ()
    dyn_glutMenuStateFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutMenuStateFunc FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutMenuStateFunc
      :: FunPtr (FunPtr MenuStateFunc -> IO ())
      ->         FunPtr MenuStateFunc -> IO ()

    {-# NOINLINE ptr_glutMenuStateFunc #-}
    ptr_glutMenuStateFunc :: FunPtr a
    ptr_glutMenuStateFunc :: forall a. FunPtr a
    ptr_glutMenuStateFunc = 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
    "glutMenuStateFunc"

    -- glutMenuStatusFunc ----------------------------------------------------------

    glutMenuStatusFunc :: MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutMenuStatusFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutMenuStatusFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutMenuStatusFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMenuStatusFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMenuStatusFunc
      :: FunPtr (FunPtr MenuStatusFunc -> IO ())
      ->         FunPtr MenuStatusFunc -> IO ()

    {-# NOINLINE ptr_glutMenuStatusFunc #-}
    ptr_glutMenuStatusFunc :: FunPtr a
    ptr_glutMenuStatusFunc :: forall a. FunPtr a
    ptr_glutMenuStatusFunc = 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
    "glutMenuStatusFunc"

    -- glutMotionFunc --------------------------------------------------------------

    glutMotionFunc :: MonadIO m => FunPtr MotionFunc -> m ()
    glutMotionFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutMotionFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMotionFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMotionFunc
      :: FunPtr (FunPtr MotionFunc -> IO ())
      ->         FunPtr MotionFunc -> IO ()

    {-# NOINLINE ptr_glutMotionFunc #-}
    ptr_glutMotionFunc :: FunPtr a
    ptr_glutMotionFunc :: forall a. FunPtr a
    ptr_glutMotionFunc = 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
    "glutMotionFunc"

    -- glutMouseFunc ---------------------------------------------------------------

    glutMouseFunc :: MonadIO m => FunPtr MouseFunc -> m ()
    glutMouseFunc :: forall (m :: * -> *). MonadIO m => FunPtr MouseFunc -> m ()
    glutMouseFunc FunPtr MouseFunc
    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 (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
    dyn_glutMouseFunc FunPtr (FunPtr MouseFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMouseFunc FunPtr MouseFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMouseFunc
      :: FunPtr (FunPtr MouseFunc -> IO ())
      ->         FunPtr MouseFunc -> IO ()

    {-# NOINLINE ptr_glutMouseFunc #-}
    ptr_glutMouseFunc :: FunPtr a
    ptr_glutMouseFunc :: forall a. FunPtr a
    ptr_glutMouseFunc = 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
    "glutMouseFunc"

    -- glutMouseWheelFunc ----------------------------------------------------------

    glutMouseWheelFunc :: MonadIO m => FunPtr MouseWheelFunc -> m ()
    glutMouseWheelFunc :: forall (m :: * -> *). MonadIO m => FunPtr MouseFunc -> m ()
    glutMouseWheelFunc FunPtr MouseFunc
    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 (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
    dyn_glutMouseWheelFunc FunPtr (FunPtr MouseFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMouseWheelFunc FunPtr MouseFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMouseWheelFunc
      :: FunPtr (FunPtr MouseWheelFunc -> IO ())
      ->         FunPtr MouseWheelFunc -> IO ()

    {-# NOINLINE ptr_glutMouseWheelFunc #-}
    ptr_glutMouseWheelFunc :: FunPtr a
    ptr_glutMouseWheelFunc :: forall a. FunPtr a
    ptr_glutMouseWheelFunc = 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
    "glutMouseWheelFunc"

    -- glutMultiButtonFunc ---------------------------------------------------------

    glutMultiButtonFunc :: MonadIO m => FunPtr MultiButtonFunc -> m ()
    glutMultiButtonFunc :: forall (m :: * -> *). MonadIO m => FunPtr MultiButtonFunc -> m ()
    glutMultiButtonFunc FunPtr MultiButtonFunc
    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 (FunPtr MultiButtonFunc -> IO ())
    -> FunPtr MultiButtonFunc -> IO ()
    dyn_glutMultiButtonFunc FunPtr (FunPtr MultiButtonFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMultiButtonFunc FunPtr MultiButtonFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMultiButtonFunc
      :: FunPtr (FunPtr MultiButtonFunc -> IO ())
      ->         FunPtr MultiButtonFunc -> IO ()

    {-# NOINLINE ptr_glutMultiButtonFunc #-}
    ptr_glutMultiButtonFunc :: FunPtr a
    ptr_glutMultiButtonFunc :: forall a. FunPtr a
    ptr_glutMultiButtonFunc = 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
    "glutMultiButtonFunc"

    -- glutMultiEntryFunc ----------------------------------------------------------

    glutMultiEntryFunc :: MonadIO m => FunPtr MultiEntryFunc -> m ()
    glutMultiEntryFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutMultiEntryFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutMultiEntryFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMultiEntryFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMultiEntryFunc
      :: FunPtr (FunPtr MultiEntryFunc -> IO ())
      ->         FunPtr MultiEntryFunc -> IO ()

    {-# NOINLINE ptr_glutMultiEntryFunc #-}
    ptr_glutMultiEntryFunc :: FunPtr a
    ptr_glutMultiEntryFunc :: forall a. FunPtr a
    ptr_glutMultiEntryFunc = 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
    "glutMultiEntryFunc"

    -- glutMultiMotionFunc ---------------------------------------------------------

    glutMultiMotionFunc :: MonadIO m => FunPtr MultiMotionFunc -> m ()
    glutMultiMotionFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutMultiMotionFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutMultiMotionFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMultiMotionFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMultiMotionFunc
      :: FunPtr (FunPtr MultiMotionFunc -> IO ())
      ->         FunPtr MultiMotionFunc -> IO ()

    {-# NOINLINE ptr_glutMultiMotionFunc #-}
    ptr_glutMultiMotionFunc :: FunPtr a
    ptr_glutMultiMotionFunc :: forall a. FunPtr a
    ptr_glutMultiMotionFunc = 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
    "glutMultiMotionFunc"

    -- glutMultiPassiveFunc --------------------------------------------------------

    glutMultiPassiveFunc :: MonadIO m => FunPtr MultiPassiveFunc -> m ()
    glutMultiPassiveFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutMultiPassiveFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutMultiPassiveFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutMultiPassiveFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutMultiPassiveFunc
      :: FunPtr (FunPtr MultiPassiveFunc -> IO ())
      ->         FunPtr MultiPassiveFunc -> IO ()

    {-# NOINLINE ptr_glutMultiPassiveFunc #-}
    ptr_glutMultiPassiveFunc :: FunPtr a
    ptr_glutMultiPassiveFunc :: forall a. FunPtr a
    ptr_glutMultiPassiveFunc = 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
    "glutMultiPassiveFunc"

    -- glutOverlayDisplayFunc ------------------------------------------------------

    glutOverlayDisplayFunc :: MonadIO m => FunPtr OverlayDisplayFunc -> m ()
    glutOverlayDisplayFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutOverlayDisplayFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutOverlayDisplayFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutOverlayDisplayFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutOverlayDisplayFunc
      :: FunPtr (FunPtr OverlayDisplayFunc -> IO ())
      ->         FunPtr OverlayDisplayFunc -> IO ()

    {-# NOINLINE ptr_glutOverlayDisplayFunc #-}
    ptr_glutOverlayDisplayFunc :: FunPtr a
    ptr_glutOverlayDisplayFunc :: forall a. FunPtr a
    ptr_glutOverlayDisplayFunc = 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
    "glutOverlayDisplayFunc"

    -- glutPassiveMotionFunc -------------------------------------------------------

    glutPassiveMotionFunc :: MonadIO m => FunPtr PassiveMotionFunc -> m ()
    glutPassiveMotionFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutPassiveMotionFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutPassiveMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutPassiveMotionFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutPassiveMotionFunc
      :: FunPtr (FunPtr PassiveMotionFunc -> IO ())
      ->         FunPtr PassiveMotionFunc -> IO ()

    {-# NOINLINE ptr_glutPassiveMotionFunc #-}
    ptr_glutPassiveMotionFunc :: FunPtr a
    ptr_glutPassiveMotionFunc :: forall a. FunPtr a
    ptr_glutPassiveMotionFunc = 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
    "glutPassiveMotionFunc"

    -- glutPopWindow ---------------------------------------------------------------

    glutPopWindow :: MonadIO m => m ()
    glutPopWindow :: forall (m :: * -> *). MonadIO m => m ()
    glutPopWindow = 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 (IO ()) -> IO ()
    dyn_glutPopWindow FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutPopWindow

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

    {-# NOINLINE ptr_glutPopWindow #-}
    ptr_glutPopWindow :: FunPtr a
    ptr_glutPopWindow :: forall a. FunPtr a
    ptr_glutPopWindow = 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
    "glutPopWindow"

    -- glutPositionFunc ------------------------------------------------------------

    glutPositionFunc :: MonadIO m => FunPtr PositionFunc -> m ()
    glutPositionFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutPositionFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutPositionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutPositionFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutPositionFunc
      :: FunPtr (FunPtr PositionFunc -> IO ())
      ->         FunPtr PositionFunc -> IO ()

    {-# NOINLINE ptr_glutPositionFunc #-}
    ptr_glutPositionFunc :: FunPtr a
    ptr_glutPositionFunc :: forall a. FunPtr a
    ptr_glutPositionFunc = 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
    "glutPositionFunc"

    -- glutPositionWindow ----------------------------------------------------------

    glutPositionWindow :: MonadIO m => CInt -> CInt -> m ()
    glutPositionWindow :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutPositionWindow CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutPositionWindow FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutPositionWindow CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutPositionWindow
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutPositionWindow #-}
    ptr_glutPositionWindow :: FunPtr a
    ptr_glutPositionWindow :: forall a. FunPtr a
    ptr_glutPositionWindow = 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
    "glutPositionWindow"

    -- glutPostOverlayRedisplay ----------------------------------------------------

    glutPostOverlayRedisplay :: MonadIO m => m ()
    glutPostOverlayRedisplay :: forall (m :: * -> *). MonadIO m => m ()
    glutPostOverlayRedisplay = 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 (IO ()) -> IO ()
    dyn_glutPostOverlayRedisplay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutPostOverlayRedisplay

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

    {-# NOINLINE ptr_glutPostOverlayRedisplay #-}
    ptr_glutPostOverlayRedisplay :: FunPtr a
    ptr_glutPostOverlayRedisplay :: forall a. FunPtr a
    ptr_glutPostOverlayRedisplay = 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
    "glutPostOverlayRedisplay"

    -- glutPostRedisplay -----------------------------------------------------------

    glutPostRedisplay :: MonadIO m => m ()
    glutPostRedisplay :: forall (m :: * -> *). MonadIO m => m ()
    glutPostRedisplay = 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 (IO ()) -> IO ()
    dyn_glutPostRedisplay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutPostRedisplay

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

    {-# NOINLINE ptr_glutPostRedisplay #-}
    ptr_glutPostRedisplay :: FunPtr a
    ptr_glutPostRedisplay :: forall a. FunPtr a
    ptr_glutPostRedisplay = 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
    "glutPostRedisplay"

    -- glutPostWindowOverlayRedisplay ----------------------------------------------

    glutPostWindowOverlayRedisplay :: MonadIO m => CInt -> m ()
    glutPostWindowOverlayRedisplay :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutPostWindowOverlayRedisplay CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutPostWindowOverlayRedisplay FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutPostWindowOverlayRedisplay CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutPostWindowOverlayRedisplay
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutPostWindowOverlayRedisplay #-}
    ptr_glutPostWindowOverlayRedisplay :: FunPtr a
    ptr_glutPostWindowOverlayRedisplay :: forall a. FunPtr a
    ptr_glutPostWindowOverlayRedisplay = 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
    "glutPostWindowOverlayRedisplay"

    -- glutPostWindowRedisplay -----------------------------------------------------

    glutPostWindowRedisplay :: MonadIO m => CInt -> m ()
    glutPostWindowRedisplay :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutPostWindowRedisplay CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutPostWindowRedisplay FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutPostWindowRedisplay CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutPostWindowRedisplay
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutPostWindowRedisplay #-}
    ptr_glutPostWindowRedisplay :: FunPtr a
    ptr_glutPostWindowRedisplay :: forall a. FunPtr a
    ptr_glutPostWindowRedisplay = 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
    "glutPostWindowRedisplay"

    -- glutPushWindow --------------------------------------------------------------

    glutPushWindow :: MonadIO m => m ()
    glutPushWindow :: forall (m :: * -> *). MonadIO m => m ()
    glutPushWindow = 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 (IO ()) -> IO ()
    dyn_glutPushWindow FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutPushWindow

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

    {-# NOINLINE ptr_glutPushWindow #-}
    ptr_glutPushWindow :: FunPtr a
    ptr_glutPushWindow :: forall a. FunPtr a
    ptr_glutPushWindow = 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
    "glutPushWindow"

    -- glutRemoveMenuItem ----------------------------------------------------------

    glutRemoveMenuItem :: MonadIO m => CInt -> m ()
    glutRemoveMenuItem :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutRemoveMenuItem CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutRemoveMenuItem FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutRemoveMenuItem CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutRemoveMenuItem
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutRemoveMenuItem #-}
    ptr_glutRemoveMenuItem :: FunPtr a
    ptr_glutRemoveMenuItem :: forall a. FunPtr a
    ptr_glutRemoveMenuItem = 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
    "glutRemoveMenuItem"

    -- glutRemoveOverlay -----------------------------------------------------------

    glutRemoveOverlay :: MonadIO m => m ()
    glutRemoveOverlay :: forall (m :: * -> *). MonadIO m => m ()
    glutRemoveOverlay = 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 (IO ()) -> IO ()
    dyn_glutRemoveOverlay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutRemoveOverlay

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

    {-# NOINLINE ptr_glutRemoveOverlay #-}
    ptr_glutRemoveOverlay :: FunPtr a
    ptr_glutRemoveOverlay :: forall a. FunPtr a
    ptr_glutRemoveOverlay = 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
    "glutRemoveOverlay"

    -- glutReportErrors ------------------------------------------------------------

    glutReportErrors :: MonadIO m => m ()
    glutReportErrors :: forall (m :: * -> *). MonadIO m => m ()
    glutReportErrors = 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 (IO ()) -> IO ()
    dyn_glutReportErrors FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutReportErrors

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

    {-# NOINLINE ptr_glutReportErrors #-}
    ptr_glutReportErrors :: FunPtr a
    ptr_glutReportErrors :: forall a. FunPtr a
    ptr_glutReportErrors = 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
    "glutReportErrors"

    -- glutReshapeFunc -------------------------------------------------------------

    glutReshapeFunc :: MonadIO m => FunPtr ReshapeFunc -> m ()
    glutReshapeFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutReshapeFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutReshapeFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutReshapeFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutReshapeFunc
      :: FunPtr (FunPtr ReshapeFunc -> IO ())
      ->         FunPtr ReshapeFunc -> IO ()

    {-# NOINLINE ptr_glutReshapeFunc #-}
    ptr_glutReshapeFunc :: FunPtr a
    ptr_glutReshapeFunc :: forall a. FunPtr a
    ptr_glutReshapeFunc = 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
    "glutReshapeFunc"

    -- glutReshapeWindow -----------------------------------------------------------

    glutReshapeWindow :: MonadIO m => CInt -> CInt -> m ()
    glutReshapeWindow :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutReshapeWindow CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutReshapeWindow FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutReshapeWindow CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutReshapeWindow
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutReshapeWindow #-}
    ptr_glutReshapeWindow :: FunPtr a
    ptr_glutReshapeWindow :: forall a. FunPtr a
    ptr_glutReshapeWindow = 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
    "glutReshapeWindow"

    -- glutSetColor ----------------------------------------------------------------

    glutSetColor :: MonadIO m => CInt -> GLfloat -> GLfloat -> GLfloat -> m ()
    glutSetColor :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> GLfloat -> GLfloat -> GLfloat -> m ()
    glutSetColor CInt
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    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 (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn_glutSetColor FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a. FunPtr a
    ptr_glutSetColor CInt
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4

    foreign import CALLCONV "dynamic" dyn_glutSetColor
      :: FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
      ->         CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()

    {-# NOINLINE ptr_glutSetColor #-}
    ptr_glutSetColor :: FunPtr a
    ptr_glutSetColor :: forall a. FunPtr a
    ptr_glutSetColor = 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
    "glutSetColor"

    -- glutSetCursor ---------------------------------------------------------------

    glutSetCursor :: MonadIO m => CInt -> m ()
    glutSetCursor :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutSetCursor CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutSetCursor FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutSetCursor CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetCursor
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutSetCursor #-}
    ptr_glutSetCursor :: FunPtr a
    ptr_glutSetCursor :: forall a. FunPtr a
    ptr_glutSetCursor = 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
    "glutSetCursor"

    -- glutSetIconTitle ------------------------------------------------------------

    glutSetIconTitle :: MonadIO m => Ptr CChar -> m ()
    glutSetIconTitle :: forall (m :: * -> *). MonadIO m => CString -> m ()
    glutSetIconTitle CString
    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 (CString -> IO ()) -> CString -> IO ()
    dyn_glutSetIconTitle FunPtr (CString -> IO ())
    forall a. FunPtr a
    ptr_glutSetIconTitle CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetIconTitle
      :: FunPtr (Ptr CChar -> IO ())
      ->         Ptr CChar -> IO ()

    {-# NOINLINE ptr_glutSetIconTitle #-}
    ptr_glutSetIconTitle :: FunPtr a
    ptr_glutSetIconTitle :: forall a. FunPtr a
    ptr_glutSetIconTitle = 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
    "glutSetIconTitle"

    -- glutSetKeyRepeat ------------------------------------------------------------

    glutSetKeyRepeat :: MonadIO m => CInt -> m ()
    glutSetKeyRepeat :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutSetKeyRepeat CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutSetKeyRepeat FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutSetKeyRepeat CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetKeyRepeat
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutSetKeyRepeat #-}
    ptr_glutSetKeyRepeat :: FunPtr a
    ptr_glutSetKeyRepeat :: forall a. FunPtr a
    ptr_glutSetKeyRepeat = 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
    "glutSetKeyRepeat"

    -- glutSetMenu -----------------------------------------------------------------

    glutSetMenu :: MonadIO m => CInt -> m ()
    glutSetMenu :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutSetMenu CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutSetMenu FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutSetMenu CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetMenu
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutSetMenu #-}
    ptr_glutSetMenu :: FunPtr a
    ptr_glutSetMenu :: forall a. FunPtr a
    ptr_glutSetMenu = 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
    "glutSetMenu"

    -- glutSetMenuData -------------------------------------------------------------

    glutSetMenuData :: MonadIO m => Ptr a -> m ()
    glutSetMenuData :: forall (m :: * -> *) a. MonadIO m => Ptr a -> m ()
    glutSetMenuData Ptr a
    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 a -> IO ()) -> Ptr a -> IO ()
    forall a. FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
    dyn_glutSetMenuData FunPtr (Ptr a -> IO ())
    forall a. FunPtr a
    ptr_glutSetMenuData Ptr a
    v1

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

    {-# NOINLINE ptr_glutSetMenuData #-}
    ptr_glutSetMenuData :: FunPtr a
    ptr_glutSetMenuData :: forall a. FunPtr a
    ptr_glutSetMenuData = 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
    "glutSetMenuData"

    -- glutSetMenuFont -------------------------------------------------------------

    glutSetMenuFont :: MonadIO m => CInt -> Ptr a -> m ()
    glutSetMenuFont :: forall (m :: * -> *) a. MonadIO m => CInt -> Ptr a -> m ()
    glutSetMenuFont CInt
    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 (CInt -> Ptr a -> IO ()) -> CInt -> Ptr a -> IO ()
    forall a. FunPtr (CInt -> Ptr a -> IO ()) -> CInt -> Ptr a -> IO ()
    dyn_glutSetMenuFont FunPtr (CInt -> Ptr a -> IO ())
    forall a. FunPtr a
    ptr_glutSetMenuFont CInt
    v1 Ptr a
    v2

    foreign import CALLCONV "dynamic" dyn_glutSetMenuFont
      :: FunPtr (CInt -> Ptr a -> IO ())
      ->         CInt -> Ptr a -> IO ()

    {-# NOINLINE ptr_glutSetMenuFont #-}
    ptr_glutSetMenuFont :: FunPtr a
    ptr_glutSetMenuFont :: forall a. FunPtr a
    ptr_glutSetMenuFont = 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
    "glutSetMenuFont"

    -- glutSetOption ---------------------------------------------------------------

    glutSetOption :: MonadIO m => GLenum -> CInt -> m ()
    glutSetOption :: forall (m :: * -> *). MonadIO m => GLenum -> CInt -> m ()
    glutSetOption GLenum
    v1 CInt
    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 (GLenum -> CInt -> IO ()) -> GLenum -> CInt -> IO ()
    dyn_glutSetOption FunPtr (GLenum -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutSetOption GLenum
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutSetOption
      :: FunPtr (GLenum -> CInt -> IO ())
      ->         GLenum -> CInt -> IO ()

    {-# NOINLINE ptr_glutSetOption #-}
    ptr_glutSetOption :: FunPtr a
    ptr_glutSetOption :: forall a. FunPtr a
    ptr_glutSetOption = 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
    "glutSetOption"

    -- glutSetVertexAttribCoord3 ---------------------------------------------------

    glutSetVertexAttribCoord3 :: MonadIO m => GLint -> m ()
    glutSetVertexAttribCoord3 :: forall (m :: * -> *). MonadIO m => GLint -> m ()
    glutSetVertexAttribCoord3 GLint
    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 (GLint -> IO ()) -> GLint -> IO ()
    dyn_glutSetVertexAttribCoord3 FunPtr (GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSetVertexAttribCoord3 GLint
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribCoord3
      :: FunPtr (GLint -> IO ())
      ->         GLint -> IO ()

    {-# NOINLINE ptr_glutSetVertexAttribCoord3 #-}
    ptr_glutSetVertexAttribCoord3 :: FunPtr a
    ptr_glutSetVertexAttribCoord3 :: forall a. FunPtr a
    ptr_glutSetVertexAttribCoord3 = 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
    "glutSetVertexAttribCoord3"

    -- glutSetVertexAttribNormal ---------------------------------------------------

    glutSetVertexAttribNormal :: MonadIO m => GLint -> m ()
    glutSetVertexAttribNormal :: forall (m :: * -> *). MonadIO m => GLint -> m ()
    glutSetVertexAttribNormal GLint
    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 (GLint -> IO ()) -> GLint -> IO ()
    dyn_glutSetVertexAttribNormal FunPtr (GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSetVertexAttribNormal GLint
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribNormal
      :: FunPtr (GLint -> IO ())
      ->         GLint -> IO ()

    {-# NOINLINE ptr_glutSetVertexAttribNormal #-}
    ptr_glutSetVertexAttribNormal :: FunPtr a
    ptr_glutSetVertexAttribNormal :: forall a. FunPtr a
    ptr_glutSetVertexAttribNormal = 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
    "glutSetVertexAttribNormal"

    -- glutSetVertexAttribTexCoord2 ------------------------------------------------

    glutSetVertexAttribTexCoord2 :: MonadIO m => GLint -> m ()
    glutSetVertexAttribTexCoord2 :: forall (m :: * -> *). MonadIO m => GLint -> m ()
    glutSetVertexAttribTexCoord2 GLint
    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 (GLint -> IO ()) -> GLint -> IO ()
    dyn_glutSetVertexAttribTexCoord2 FunPtr (GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSetVertexAttribTexCoord2 GLint
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribTexCoord2
      :: FunPtr (GLint -> IO ())
      ->         GLint -> IO ()

    {-# NOINLINE ptr_glutSetVertexAttribTexCoord2 #-}
    ptr_glutSetVertexAttribTexCoord2 :: FunPtr a
    ptr_glutSetVertexAttribTexCoord2 :: forall a. FunPtr a
    ptr_glutSetVertexAttribTexCoord2 = 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
    "glutSetVertexAttribTexCoord2"

    -- glutSetWindow ---------------------------------------------------------------

    glutSetWindow :: MonadIO m => CInt -> m ()
    glutSetWindow :: forall (m :: * -> *). MonadIO m => CInt -> m ()
    glutSetWindow CInt
    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 (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutSetWindow FunPtr (CInt -> IO ())
    forall a. FunPtr a
    ptr_glutSetWindow CInt
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetWindow
      :: FunPtr (CInt -> IO ())
      ->         CInt -> IO ()

    {-# NOINLINE ptr_glutSetWindow #-}
    ptr_glutSetWindow :: FunPtr a
    ptr_glutSetWindow :: forall a. FunPtr a
    ptr_glutSetWindow = 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
    "glutSetWindow"

    -- glutSetWindowData -----------------------------------------------------------

    glutSetWindowData :: MonadIO m => Ptr a -> m ()
    glutSetWindowData :: forall (m :: * -> *) a. MonadIO m => Ptr a -> m ()
    glutSetWindowData Ptr a
    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 a -> IO ()) -> Ptr a -> IO ()
    forall a. FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
    dyn_glutSetWindowData FunPtr (Ptr a -> IO ())
    forall a. FunPtr a
    ptr_glutSetWindowData Ptr a
    v1

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

    {-# NOINLINE ptr_glutSetWindowData #-}
    ptr_glutSetWindowData :: FunPtr a
    ptr_glutSetWindowData :: forall a. FunPtr a
    ptr_glutSetWindowData = 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
    "glutSetWindowData"

    -- glutSetWindowTitle ----------------------------------------------------------

    glutSetWindowTitle :: MonadIO m => Ptr CChar -> m ()
    glutSetWindowTitle :: forall (m :: * -> *). MonadIO m => CString -> m ()
    glutSetWindowTitle CString
    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 (CString -> IO ()) -> CString -> IO ()
    dyn_glutSetWindowTitle FunPtr (CString -> IO ())
    forall a. FunPtr a
    ptr_glutSetWindowTitle CString
    v1

    foreign import CALLCONV "dynamic" dyn_glutSetWindowTitle
      :: FunPtr (Ptr CChar -> IO ())
      ->         Ptr CChar -> IO ()

    {-# NOINLINE ptr_glutSetWindowTitle #-}
    ptr_glutSetWindowTitle :: FunPtr a
    ptr_glutSetWindowTitle :: forall a. FunPtr a
    ptr_glutSetWindowTitle = 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
    "glutSetWindowTitle"

    -- glutSetupVideoResizing ------------------------------------------------------

    glutSetupVideoResizing :: MonadIO m => m ()
    glutSetupVideoResizing :: forall (m :: * -> *). MonadIO m => m ()
    glutSetupVideoResizing = 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 (IO ()) -> IO ()
    dyn_glutSetupVideoResizing FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSetupVideoResizing

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

    {-# NOINLINE ptr_glutSetupVideoResizing #-}
    ptr_glutSetupVideoResizing :: FunPtr a
    ptr_glutSetupVideoResizing :: forall a. FunPtr a
    ptr_glutSetupVideoResizing = 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
    "glutSetupVideoResizing"

    -- glutShowOverlay -------------------------------------------------------------

    glutShowOverlay :: MonadIO m => m ()
    glutShowOverlay :: forall (m :: * -> *). MonadIO m => m ()
    glutShowOverlay = 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 (IO ()) -> IO ()
    dyn_glutShowOverlay FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutShowOverlay

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

    {-# NOINLINE ptr_glutShowOverlay #-}
    ptr_glutShowOverlay :: FunPtr a
    ptr_glutShowOverlay :: forall a. FunPtr a
    ptr_glutShowOverlay = 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
    "glutShowOverlay"

    -- glutShowWindow --------------------------------------------------------------

    glutShowWindow :: MonadIO m => m ()
    glutShowWindow :: forall (m :: * -> *). MonadIO m => m ()
    glutShowWindow = 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 (IO ()) -> IO ()
    dyn_glutShowWindow FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutShowWindow

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

    {-# NOINLINE ptr_glutShowWindow #-}
    ptr_glutShowWindow :: FunPtr a
    ptr_glutShowWindow :: forall a. FunPtr a
    ptr_glutShowWindow = 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
    "glutShowWindow"

    -- glutSolidCone ---------------------------------------------------------------

    glutSolidCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidCone :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidCone GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutSolidCone FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSolidCone GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutSolidCone #-}
    ptr_glutSolidCone :: FunPtr a
    ptr_glutSolidCone :: forall a. FunPtr a
    ptr_glutSolidCone = 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
    "glutSolidCone"

    -- glutSolidCube ---------------------------------------------------------------

    glutSolidCube :: MonadIO m => GLdouble -> m ()
    glutSolidCube :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutSolidCube GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutSolidCube FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutSolidCube GLdouble
    v1

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

    {-# NOINLINE ptr_glutSolidCube #-}
    ptr_glutSolidCube :: FunPtr a
    ptr_glutSolidCube :: forall a. FunPtr a
    ptr_glutSolidCube = 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
    "glutSolidCube"

    -- glutSolidCylinder -----------------------------------------------------------

    glutSolidCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidCylinder :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidCylinder GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutSolidCylinder FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSolidCylinder GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutSolidCylinder #-}
    ptr_glutSolidCylinder :: FunPtr a
    ptr_glutSolidCylinder :: forall a. FunPtr a
    ptr_glutSolidCylinder = 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
    "glutSolidCylinder"

    -- glutSolidDodecahedron -------------------------------------------------------

    glutSolidDodecahedron :: MonadIO m => m ()
    glutSolidDodecahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutSolidDodecahedron = 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 (IO ()) -> IO ()
    dyn_glutSolidDodecahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSolidDodecahedron

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

    {-# NOINLINE ptr_glutSolidDodecahedron #-}
    ptr_glutSolidDodecahedron :: FunPtr a
    ptr_glutSolidDodecahedron :: forall a. FunPtr a
    ptr_glutSolidDodecahedron = 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
    "glutSolidDodecahedron"

    -- glutSolidIcosahedron --------------------------------------------------------

    glutSolidIcosahedron :: MonadIO m => m ()
    glutSolidIcosahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutSolidIcosahedron = 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 (IO ()) -> IO ()
    dyn_glutSolidIcosahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSolidIcosahedron

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

    {-# NOINLINE ptr_glutSolidIcosahedron #-}
    ptr_glutSolidIcosahedron :: FunPtr a
    ptr_glutSolidIcosahedron :: forall a. FunPtr a
    ptr_glutSolidIcosahedron = 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
    "glutSolidIcosahedron"

    -- glutSolidOctahedron ---------------------------------------------------------

    glutSolidOctahedron :: MonadIO m => m ()
    glutSolidOctahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutSolidOctahedron = 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 (IO ()) -> IO ()
    dyn_glutSolidOctahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSolidOctahedron

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

    {-# NOINLINE ptr_glutSolidOctahedron #-}
    ptr_glutSolidOctahedron :: FunPtr a
    ptr_glutSolidOctahedron :: forall a. FunPtr a
    ptr_glutSolidOctahedron = 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
    "glutSolidOctahedron"

    -- glutSolidRhombicDodecahedron ------------------------------------------------

    glutSolidRhombicDodecahedron :: MonadIO m => m ()
    glutSolidRhombicDodecahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutSolidRhombicDodecahedron = 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 (IO ()) -> IO ()
    dyn_glutSolidRhombicDodecahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSolidRhombicDodecahedron

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

    {-# NOINLINE ptr_glutSolidRhombicDodecahedron #-}
    ptr_glutSolidRhombicDodecahedron :: FunPtr a
    ptr_glutSolidRhombicDodecahedron :: forall a. FunPtr a
    ptr_glutSolidRhombicDodecahedron = 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
    "glutSolidRhombicDodecahedron"

    -- glutSolidSierpinskiSponge ---------------------------------------------------

    glutSolidSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
    glutSolidSierpinskiSponge :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> Ptr GLdouble -> GLdouble -> m ()
    glutSolidSierpinskiSponge CInt
    v1 Ptr GLdouble
    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 (CInt -> Ptr GLdouble -> GLdouble -> IO ())
    -> CInt -> Ptr GLdouble -> GLdouble -> IO ()
    dyn_glutSolidSierpinskiSponge FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutSolidSierpinskiSponge CInt
    v1 Ptr GLdouble
    v2 GLdouble
    v3

    foreign import CALLCONV "dynamic" dyn_glutSolidSierpinskiSponge
      :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
      ->         CInt -> Ptr GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_glutSolidSierpinskiSponge #-}
    ptr_glutSolidSierpinskiSponge :: FunPtr a
    ptr_glutSolidSierpinskiSponge :: forall a. FunPtr a
    ptr_glutSolidSierpinskiSponge = 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
    "glutSolidSierpinskiSponge"

    -- glutSolidSphere -------------------------------------------------------------

    glutSolidSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
    glutSolidSphere :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLint -> GLint -> m ()
    glutSolidSphere GLdouble
    v1 GLint
    v2 GLint
    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 (GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutSolidSphere FunPtr (GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSolidSphere GLdouble
    v1 GLint
    v2 GLint
    v3

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

    {-# NOINLINE ptr_glutSolidSphere #-}
    ptr_glutSolidSphere :: FunPtr a
    ptr_glutSolidSphere :: forall a. FunPtr a
    ptr_glutSolidSphere = 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
    "glutSolidSphere"

    -- glutSolidTeacup -------------------------------------------------------------

    glutSolidTeacup :: MonadIO m => GLdouble -> m ()
    glutSolidTeacup :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutSolidTeacup GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutSolidTeacup FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutSolidTeacup GLdouble
    v1

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

    {-# NOINLINE ptr_glutSolidTeacup #-}
    ptr_glutSolidTeacup :: FunPtr a
    ptr_glutSolidTeacup :: forall a. FunPtr a
    ptr_glutSolidTeacup = 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
    "glutSolidTeacup"

    -- glutSolidTeapot -------------------------------------------------------------

    glutSolidTeapot :: MonadIO m => GLdouble -> m ()
    glutSolidTeapot :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutSolidTeapot GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutSolidTeapot FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutSolidTeapot GLdouble
    v1

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

    {-# NOINLINE ptr_glutSolidTeapot #-}
    ptr_glutSolidTeapot :: FunPtr a
    ptr_glutSolidTeapot :: forall a. FunPtr a
    ptr_glutSolidTeapot = 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
    "glutSolidTeapot"

    -- glutSolidTeaspoon -----------------------------------------------------------

    glutSolidTeaspoon :: MonadIO m => GLdouble -> m ()
    glutSolidTeaspoon :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutSolidTeaspoon GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutSolidTeaspoon FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutSolidTeaspoon GLdouble
    v1

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

    {-# NOINLINE ptr_glutSolidTeaspoon #-}
    ptr_glutSolidTeaspoon :: FunPtr a
    ptr_glutSolidTeaspoon :: forall a. FunPtr a
    ptr_glutSolidTeaspoon = 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
    "glutSolidTeaspoon"

    -- glutSolidTetrahedron --------------------------------------------------------

    glutSolidTetrahedron :: MonadIO m => m ()
    glutSolidTetrahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutSolidTetrahedron = 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 (IO ()) -> IO ()
    dyn_glutSolidTetrahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSolidTetrahedron

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

    {-# NOINLINE ptr_glutSolidTetrahedron #-}
    ptr_glutSolidTetrahedron :: FunPtr a
    ptr_glutSolidTetrahedron :: forall a. FunPtr a
    ptr_glutSolidTetrahedron = 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
    "glutSolidTetrahedron"

    -- glutSolidTorus --------------------------------------------------------------

    glutSolidTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidTorus :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutSolidTorus GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutSolidTorus FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutSolidTorus GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutSolidTorus #-}
    ptr_glutSolidTorus :: FunPtr a
    ptr_glutSolidTorus :: forall a. FunPtr a
    ptr_glutSolidTorus = 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
    "glutSolidTorus"

    -- glutSpaceballButtonFunc -----------------------------------------------------

    glutSpaceballButtonFunc :: MonadIO m => FunPtr SpaceballButtonFunc -> m ()
    glutSpaceballButtonFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutSpaceballButtonFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutSpaceballButtonFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutSpaceballButtonFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutSpaceballButtonFunc
      :: FunPtr (FunPtr SpaceballButtonFunc -> IO ())
      ->         FunPtr SpaceballButtonFunc -> IO ()

    {-# NOINLINE ptr_glutSpaceballButtonFunc #-}
    ptr_glutSpaceballButtonFunc :: FunPtr a
    ptr_glutSpaceballButtonFunc :: forall a. FunPtr a
    ptr_glutSpaceballButtonFunc = 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
    "glutSpaceballButtonFunc"

    -- glutSpaceballMotionFunc -----------------------------------------------------

    glutSpaceballMotionFunc :: MonadIO m => FunPtr SpaceballMotionFunc -> m ()
    glutSpaceballMotionFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutSpaceballMotionFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutSpaceballMotionFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutSpaceballMotionFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutSpaceballMotionFunc
      :: FunPtr (FunPtr SpaceballMotionFunc -> IO ())
      ->         FunPtr SpaceballMotionFunc -> IO ()

    {-# NOINLINE ptr_glutSpaceballMotionFunc #-}
    ptr_glutSpaceballMotionFunc :: FunPtr a
    ptr_glutSpaceballMotionFunc :: forall a. FunPtr a
    ptr_glutSpaceballMotionFunc = 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
    "glutSpaceballMotionFunc"

    -- glutSpaceballRotateFunc -----------------------------------------------------

    glutSpaceballRotateFunc :: MonadIO m => FunPtr SpaceballRotateFunc -> m ()
    glutSpaceballRotateFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutSpaceballRotateFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutSpaceballRotateFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutSpaceballRotateFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutSpaceballRotateFunc
      :: FunPtr (FunPtr SpaceballRotateFunc -> IO ())
      ->         FunPtr SpaceballRotateFunc -> IO ()

    {-# NOINLINE ptr_glutSpaceballRotateFunc #-}
    ptr_glutSpaceballRotateFunc :: FunPtr a
    ptr_glutSpaceballRotateFunc :: forall a. FunPtr a
    ptr_glutSpaceballRotateFunc = 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
    "glutSpaceballRotateFunc"

    -- glutSpecialFunc -------------------------------------------------------------

    glutSpecialFunc :: MonadIO m => FunPtr SpecialFunc -> m ()
    glutSpecialFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutSpecialFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutSpecialFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutSpecialFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutSpecialFunc
      :: FunPtr (FunPtr SpecialFunc -> IO ())
      ->         FunPtr SpecialFunc -> IO ()

    {-# NOINLINE ptr_glutSpecialFunc #-}
    ptr_glutSpecialFunc :: FunPtr a
    ptr_glutSpecialFunc :: forall a. FunPtr a
    ptr_glutSpecialFunc = 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
    "glutSpecialFunc"

    -- glutSpecialUpFunc -----------------------------------------------------------

    glutSpecialUpFunc :: MonadIO m => FunPtr SpecialUpFunc -> m ()
    glutSpecialUpFunc :: forall (m :: * -> *). MonadIO m => FunPtr MenuStatusFunc -> m ()
    glutSpecialUpFunc FunPtr MenuStatusFunc
    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 (FunPtr MenuStatusFunc -> IO ())
    -> FunPtr MenuStatusFunc -> IO ()
    dyn_glutSpecialUpFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
    forall a. FunPtr a
    ptr_glutSpecialUpFunc FunPtr MenuStatusFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutSpecialUpFunc
      :: FunPtr (FunPtr SpecialUpFunc -> IO ())
      ->         FunPtr SpecialUpFunc -> IO ()

    {-# NOINLINE ptr_glutSpecialUpFunc #-}
    ptr_glutSpecialUpFunc :: FunPtr a
    ptr_glutSpecialUpFunc :: forall a. FunPtr a
    ptr_glutSpecialUpFunc = 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
    "glutSpecialUpFunc"

    -- glutStopVideoResizing -------------------------------------------------------

    glutStopVideoResizing :: MonadIO m => m ()
    glutStopVideoResizing :: forall (m :: * -> *). MonadIO m => m ()
    glutStopVideoResizing = 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 (IO ()) -> IO ()
    dyn_glutStopVideoResizing FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutStopVideoResizing

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

    {-# NOINLINE ptr_glutStopVideoResizing #-}
    ptr_glutStopVideoResizing :: FunPtr a
    ptr_glutStopVideoResizing :: forall a. FunPtr a
    ptr_glutStopVideoResizing = 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
    "glutStopVideoResizing"

    -- glutStrokeCharacter ---------------------------------------------------------

    glutStrokeCharacter :: MonadIO m => Ptr a -> CInt -> m ()
    glutStrokeCharacter :: forall (m :: * -> *) a. MonadIO m => Ptr a -> CInt -> m ()
    glutStrokeCharacter Ptr a
    v1 CInt
    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 a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
    forall a. FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
    dyn_glutStrokeCharacter FunPtr (Ptr a -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutStrokeCharacter Ptr a
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutStrokeCharacter
      :: FunPtr (Ptr a -> CInt -> IO ())
      ->         Ptr a -> CInt -> IO ()

    {-# NOINLINE ptr_glutStrokeCharacter #-}
    ptr_glutStrokeCharacter :: FunPtr a
    ptr_glutStrokeCharacter :: forall a. FunPtr a
    ptr_glutStrokeCharacter = 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
    "glutStrokeCharacter"

    -- glutStrokeHeight ------------------------------------------------------------

    glutStrokeHeight :: MonadIO m => Ptr a -> m GLfloat
    glutStrokeHeight :: forall (m :: * -> *) a. MonadIO m => Ptr a -> m GLfloat
    glutStrokeHeight Ptr a
    v1 = IO GLfloat -> m GLfloat
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLfloat -> m GLfloat) -> IO GLfloat -> m GLfloat
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> IO GLfloat) -> Ptr a -> IO GLfloat
    forall a. FunPtr (Ptr a -> IO GLfloat) -> Ptr a -> IO GLfloat
    dyn_glutStrokeHeight FunPtr (Ptr a -> IO GLfloat)
    forall a. FunPtr a
    ptr_glutStrokeHeight Ptr a
    v1

    foreign import CALLCONV "dynamic" dyn_glutStrokeHeight
      :: FunPtr (Ptr a -> IO GLfloat)
      ->         Ptr a -> IO GLfloat

    {-# NOINLINE ptr_glutStrokeHeight #-}
    ptr_glutStrokeHeight :: FunPtr a
    ptr_glutStrokeHeight :: forall a. FunPtr a
    ptr_glutStrokeHeight = 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
    "glutStrokeHeight"

    -- glutStrokeLength ------------------------------------------------------------

    glutStrokeLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
    glutStrokeLength :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Ptr CUChar -> m CInt
    glutStrokeLength Ptr a
    v1 Ptr CUChar
    v2 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    -> Ptr a -> Ptr CUChar -> IO CInt
    forall a.
    FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    -> Ptr a -> Ptr CUChar -> IO CInt
    dyn_glutStrokeLength FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
    forall a. FunPtr a
    ptr_glutStrokeLength Ptr a
    v1 Ptr CUChar
    v2

    foreign import CALLCONV "dynamic" dyn_glutStrokeLength
      :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
      ->         Ptr a -> Ptr CUChar -> IO CInt

    {-# NOINLINE ptr_glutStrokeLength #-}
    ptr_glutStrokeLength :: FunPtr a
    ptr_glutStrokeLength :: forall a. FunPtr a
    ptr_glutStrokeLength = 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
    "glutStrokeLength"

    -- glutStrokeString ------------------------------------------------------------

    glutStrokeString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
    glutStrokeString :: forall (m :: * -> *) a. MonadIO m => Ptr a -> Ptr CUChar -> m ()
    glutStrokeString Ptr a
    v1 Ptr CUChar
    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 a -> Ptr CUChar -> IO ())
    -> Ptr a -> Ptr CUChar -> IO ()
    forall a.
    FunPtr (Ptr a -> Ptr CUChar -> IO ())
    -> Ptr a -> Ptr CUChar -> IO ()
    dyn_glutStrokeString FunPtr (Ptr a -> Ptr CUChar -> IO ())
    forall a. FunPtr a
    ptr_glutStrokeString Ptr a
    v1 Ptr CUChar
    v2

    foreign import CALLCONV "dynamic" dyn_glutStrokeString
      :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
      ->         Ptr a -> Ptr CUChar -> IO ()

    {-# NOINLINE ptr_glutStrokeString #-}
    ptr_glutStrokeString :: FunPtr a
    ptr_glutStrokeString :: forall a. FunPtr a
    ptr_glutStrokeString = 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
    "glutStrokeString"

    -- glutStrokeWidth -------------------------------------------------------------

    glutStrokeWidth :: MonadIO m => Ptr a -> CInt -> m CInt
    glutStrokeWidth :: forall (m :: * -> *) a. MonadIO m => Ptr a -> CInt -> m CInt
    glutStrokeWidth Ptr a
    v1 CInt
    v2 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
    forall a.
    FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
    dyn_glutStrokeWidth FunPtr (Ptr a -> CInt -> IO CInt)
    forall a. FunPtr a
    ptr_glutStrokeWidth Ptr a
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutStrokeWidth
      :: FunPtr (Ptr a -> CInt -> IO CInt)
      ->         Ptr a -> CInt -> IO CInt

    {-# NOINLINE ptr_glutStrokeWidth #-}
    ptr_glutStrokeWidth :: FunPtr a
    ptr_glutStrokeWidth :: forall a. FunPtr a
    ptr_glutStrokeWidth = 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
    "glutStrokeWidth"

    -- glutSwapBuffers -------------------------------------------------------------

    glutSwapBuffers :: MonadIO m => m ()
    glutSwapBuffers :: forall (m :: * -> *). MonadIO m => m ()
    glutSwapBuffers = 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 (IO ()) -> IO ()
    dyn_glutSwapBuffers FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutSwapBuffers

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

    {-# NOINLINE ptr_glutSwapBuffers #-}
    ptr_glutSwapBuffers :: FunPtr a
    ptr_glutSwapBuffers :: forall a. FunPtr a
    ptr_glutSwapBuffers = 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
    "glutSwapBuffers"

    -- glutTabletButtonFunc --------------------------------------------------------

    glutTabletButtonFunc :: MonadIO m => FunPtr TabletButtonFunc -> m ()
    glutTabletButtonFunc :: forall (m :: * -> *). MonadIO m => FunPtr MouseFunc -> m ()
    glutTabletButtonFunc FunPtr MouseFunc
    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 (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
    dyn_glutTabletButtonFunc FunPtr (FunPtr MouseFunc -> IO ())
    forall a. FunPtr a
    ptr_glutTabletButtonFunc FunPtr MouseFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutTabletButtonFunc
      :: FunPtr (FunPtr TabletButtonFunc -> IO ())
      ->         FunPtr TabletButtonFunc -> IO ()

    {-# NOINLINE ptr_glutTabletButtonFunc #-}
    ptr_glutTabletButtonFunc :: FunPtr a
    ptr_glutTabletButtonFunc :: forall a. FunPtr a
    ptr_glutTabletButtonFunc = 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
    "glutTabletButtonFunc"

    -- glutTabletMotionFunc --------------------------------------------------------

    glutTabletMotionFunc :: MonadIO m => FunPtr TabletMotionFunc -> m ()
    glutTabletMotionFunc :: forall (m :: * -> *). MonadIO m => FunPtr ButtonBoxFunc -> m ()
    glutTabletMotionFunc FunPtr ButtonBoxFunc
    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 (FunPtr ButtonBoxFunc -> IO ())
    -> FunPtr ButtonBoxFunc -> IO ()
    dyn_glutTabletMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
    forall a. FunPtr a
    ptr_glutTabletMotionFunc FunPtr ButtonBoxFunc
    v1

    foreign import CALLCONV "dynamic" dyn_glutTabletMotionFunc
      :: FunPtr (FunPtr TabletMotionFunc -> IO ())
      ->         FunPtr TabletMotionFunc -> IO ()

    {-# NOINLINE ptr_glutTabletMotionFunc #-}
    ptr_glutTabletMotionFunc :: FunPtr a
    ptr_glutTabletMotionFunc :: forall a. FunPtr a
    ptr_glutTabletMotionFunc = 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
    "glutTabletMotionFunc"

    -- glutTimerFunc ---------------------------------------------------------------

    glutTimerFunc :: MonadIO m => CUInt -> FunPtr TimerFunc -> CInt -> m ()
    glutTimerFunc :: forall (m :: * -> *).
    MonadIO m =>
    CUInt -> FunPtr (CInt -> IO ()) -> CInt -> m ()
    glutTimerFunc CUInt
    v1 FunPtr (CInt -> IO ())
    v2 CInt
    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 (CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ())
    -> CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ()
    dyn_glutTimerFunc FunPtr (CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ())
    forall a. FunPtr a
    ptr_glutTimerFunc CUInt
    v1 FunPtr (CInt -> IO ())
    v2 CInt
    v3

    foreign import CALLCONV "dynamic" dyn_glutTimerFunc
      :: FunPtr (CUInt -> FunPtr TimerFunc -> CInt -> IO ())
      ->         CUInt -> FunPtr TimerFunc -> CInt -> IO ()

    {-# NOINLINE ptr_glutTimerFunc #-}
    ptr_glutTimerFunc :: FunPtr a
    ptr_glutTimerFunc :: forall a. FunPtr a
    ptr_glutTimerFunc = 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
    "glutTimerFunc"

    -- glutUseLayer ----------------------------------------------------------------

    glutUseLayer :: MonadIO m => GLenum -> m ()
    glutUseLayer :: forall (m :: * -> *). MonadIO m => GLenum -> m ()
    glutUseLayer GLenum
    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 (GLenum -> IO ()) -> GLenum -> IO ()
    dyn_glutUseLayer FunPtr (GLenum -> IO ())
    forall a. FunPtr a
    ptr_glutUseLayer GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutUseLayer
      :: FunPtr (GLenum -> IO ())
      ->         GLenum -> IO ()

    {-# NOINLINE ptr_glutUseLayer #-}
    ptr_glutUseLayer :: FunPtr a
    ptr_glutUseLayer :: forall a. FunPtr a
    ptr_glutUseLayer = 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
    "glutUseLayer"

    -- glutVideoPan ----------------------------------------------------------------

    glutVideoPan :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
    glutVideoPan :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> CInt -> CInt -> CInt -> m ()
    glutVideoPan CInt
    v1 CInt
    v2 CInt
    v3 CInt
    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 MouseFunc -> MouseFunc
    dyn_glutVideoPan FunPtr MouseFunc
    forall a. FunPtr a
    ptr_glutVideoPan CInt
    v1 CInt
    v2 CInt
    v3 CInt
    v4

    foreign import CALLCONV "dynamic" dyn_glutVideoPan
      :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
      ->         CInt -> CInt -> CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutVideoPan #-}
    ptr_glutVideoPan :: FunPtr a
    ptr_glutVideoPan :: forall a. FunPtr a
    ptr_glutVideoPan = 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
    "glutVideoPan"

    -- glutVideoResize -------------------------------------------------------------

    glutVideoResize :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
    glutVideoResize :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> CInt -> CInt -> CInt -> m ()
    glutVideoResize CInt
    v1 CInt
    v2 CInt
    v3 CInt
    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 MouseFunc -> MouseFunc
    dyn_glutVideoResize FunPtr MouseFunc
    forall a. FunPtr a
    ptr_glutVideoResize CInt
    v1 CInt
    v2 CInt
    v3 CInt
    v4

    foreign import CALLCONV "dynamic" dyn_glutVideoResize
      :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
      ->         CInt -> CInt -> CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutVideoResize #-}
    ptr_glutVideoResize :: FunPtr a
    ptr_glutVideoResize :: forall a. FunPtr a
    ptr_glutVideoResize = 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
    "glutVideoResize"

    -- glutVideoResizeGet ----------------------------------------------------------

    glutVideoResizeGet :: MonadIO m => GLenum -> m CInt
    glutVideoResizeGet :: forall (m :: * -> *). MonadIO m => GLenum -> m CInt
    glutVideoResizeGet GLenum
    v1 = IO CInt -> m CInt
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
    dyn_glutVideoResizeGet FunPtr (GLenum -> IO CInt)
    forall a. FunPtr a
    ptr_glutVideoResizeGet GLenum
    v1

    foreign import CALLCONV "dynamic" dyn_glutVideoResizeGet
      :: FunPtr (GLenum -> IO CInt)
      ->         GLenum -> IO CInt

    {-# NOINLINE ptr_glutVideoResizeGet #-}
    ptr_glutVideoResizeGet :: FunPtr a
    ptr_glutVideoResizeGet :: forall a. FunPtr a
    ptr_glutVideoResizeGet = 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
    "glutVideoResizeGet"

    -- glutVisibilityFunc ----------------------------------------------------------

    glutVisibilityFunc :: MonadIO m => FunPtr VisibilityFunc -> m ()
    glutVisibilityFunc :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m ()
    glutVisibilityFunc FunPtr (CInt -> IO ())
    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 (FunPtr (CInt -> IO ()) -> IO ())
    -> FunPtr (CInt -> IO ()) -> IO ()
    dyn_glutVisibilityFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutVisibilityFunc FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutVisibilityFunc
      :: FunPtr (FunPtr VisibilityFunc -> IO ())
      ->         FunPtr VisibilityFunc -> IO ()

    {-# NOINLINE ptr_glutVisibilityFunc #-}
    ptr_glutVisibilityFunc :: FunPtr a
    ptr_glutVisibilityFunc :: forall a. FunPtr a
    ptr_glutVisibilityFunc = 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
    "glutVisibilityFunc"

    -- glutWMCloseFunc -------------------------------------------------------------

    glutWMCloseFunc :: MonadIO m => FunPtr WMCloseFunc -> m ()
    glutWMCloseFunc :: forall (m :: * -> *). MonadIO m => FunPtr (IO ()) -> m ()
    glutWMCloseFunc FunPtr (IO ())
    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 (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
    dyn_glutWMCloseFunc FunPtr (FunPtr (IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutWMCloseFunc FunPtr (IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutWMCloseFunc
      :: FunPtr (FunPtr WMCloseFunc -> IO ())
      ->         FunPtr WMCloseFunc -> IO ()

    {-# NOINLINE ptr_glutWMCloseFunc #-}
    ptr_glutWMCloseFunc :: FunPtr a
    ptr_glutWMCloseFunc :: forall a. FunPtr a
    ptr_glutWMCloseFunc = 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
    "glutWMCloseFunc"

    -- glutWarpPointer -------------------------------------------------------------

    glutWarpPointer :: MonadIO m => CInt -> CInt -> m ()
    glutWarpPointer :: forall (m :: * -> *). MonadIO m => CInt -> CInt -> m ()
    glutWarpPointer CInt
    v1 CInt
    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 ButtonBoxFunc -> ButtonBoxFunc
    dyn_glutWarpPointer FunPtr ButtonBoxFunc
    forall a. FunPtr a
    ptr_glutWarpPointer CInt
    v1 CInt
    v2

    foreign import CALLCONV "dynamic" dyn_glutWarpPointer
      :: FunPtr (CInt -> CInt -> IO ())
      ->         CInt -> CInt -> IO ()

    {-# NOINLINE ptr_glutWarpPointer #-}
    ptr_glutWarpPointer :: FunPtr a
    ptr_glutWarpPointer :: forall a. FunPtr a
    ptr_glutWarpPointer = 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
    "glutWarpPointer"

    -- glutWindowStatusFunc --------------------------------------------------------

    glutWindowStatusFunc :: MonadIO m => FunPtr WindowStatusFunc -> m ()
    glutWindowStatusFunc :: forall (m :: * -> *). MonadIO m => FunPtr (CInt -> IO ()) -> m ()
    glutWindowStatusFunc FunPtr (CInt -> IO ())
    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 (FunPtr (CInt -> IO ()) -> IO ())
    -> FunPtr (CInt -> IO ()) -> IO ()
    dyn_glutWindowStatusFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
    forall a. FunPtr a
    ptr_glutWindowStatusFunc FunPtr (CInt -> IO ())
    v1

    foreign import CALLCONV "dynamic" dyn_glutWindowStatusFunc
      :: FunPtr (FunPtr WindowStatusFunc -> IO ())
      ->         FunPtr WindowStatusFunc -> IO ()

    {-# NOINLINE ptr_glutWindowStatusFunc #-}
    ptr_glutWindowStatusFunc :: FunPtr a
    ptr_glutWindowStatusFunc :: forall a. FunPtr a
    ptr_glutWindowStatusFunc = 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
    "glutWindowStatusFunc"

    -- glutWireCone ----------------------------------------------------------------

    glutWireCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireCone :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireCone GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutWireCone FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutWireCone GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutWireCone #-}
    ptr_glutWireCone :: FunPtr a
    ptr_glutWireCone :: forall a. FunPtr a
    ptr_glutWireCone = 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
    "glutWireCone"

    -- glutWireCube ----------------------------------------------------------------

    glutWireCube :: MonadIO m => GLdouble -> m ()
    glutWireCube :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutWireCube GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutWireCube FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutWireCube GLdouble
    v1

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

    {-# NOINLINE ptr_glutWireCube #-}
    ptr_glutWireCube :: FunPtr a
    ptr_glutWireCube :: forall a. FunPtr a
    ptr_glutWireCube = 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
    "glutWireCube"

    -- glutWireCylinder ------------------------------------------------------------

    glutWireCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireCylinder :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireCylinder GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutWireCylinder FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutWireCylinder GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutWireCylinder #-}
    ptr_glutWireCylinder :: FunPtr a
    ptr_glutWireCylinder :: forall a. FunPtr a
    ptr_glutWireCylinder = 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
    "glutWireCylinder"

    -- glutWireDodecahedron --------------------------------------------------------

    glutWireDodecahedron :: MonadIO m => m ()
    glutWireDodecahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutWireDodecahedron = 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 (IO ()) -> IO ()
    dyn_glutWireDodecahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutWireDodecahedron

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

    {-# NOINLINE ptr_glutWireDodecahedron #-}
    ptr_glutWireDodecahedron :: FunPtr a
    ptr_glutWireDodecahedron :: forall a. FunPtr a
    ptr_glutWireDodecahedron = 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
    "glutWireDodecahedron"

    -- glutWireIcosahedron ---------------------------------------------------------

    glutWireIcosahedron :: MonadIO m => m ()
    glutWireIcosahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutWireIcosahedron = 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 (IO ()) -> IO ()
    dyn_glutWireIcosahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutWireIcosahedron

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

    {-# NOINLINE ptr_glutWireIcosahedron #-}
    ptr_glutWireIcosahedron :: FunPtr a
    ptr_glutWireIcosahedron :: forall a. FunPtr a
    ptr_glutWireIcosahedron = 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
    "glutWireIcosahedron"

    -- glutWireOctahedron ----------------------------------------------------------

    glutWireOctahedron :: MonadIO m => m ()
    glutWireOctahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutWireOctahedron = 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 (IO ()) -> IO ()
    dyn_glutWireOctahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutWireOctahedron

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

    {-# NOINLINE ptr_glutWireOctahedron #-}
    ptr_glutWireOctahedron :: FunPtr a
    ptr_glutWireOctahedron :: forall a. FunPtr a
    ptr_glutWireOctahedron = 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
    "glutWireOctahedron"

    -- glutWireRhombicDodecahedron -------------------------------------------------

    glutWireRhombicDodecahedron :: MonadIO m => m ()
    glutWireRhombicDodecahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutWireRhombicDodecahedron = 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 (IO ()) -> IO ()
    dyn_glutWireRhombicDodecahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutWireRhombicDodecahedron

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

    {-# NOINLINE ptr_glutWireRhombicDodecahedron #-}
    ptr_glutWireRhombicDodecahedron :: FunPtr a
    ptr_glutWireRhombicDodecahedron :: forall a. FunPtr a
    ptr_glutWireRhombicDodecahedron = 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
    "glutWireRhombicDodecahedron"

    -- glutWireSierpinskiSponge ----------------------------------------------------

    glutWireSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
    glutWireSierpinskiSponge :: forall (m :: * -> *).
    MonadIO m =>
    CInt -> Ptr GLdouble -> GLdouble -> m ()
    glutWireSierpinskiSponge CInt
    v1 Ptr GLdouble
    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 (CInt -> Ptr GLdouble -> GLdouble -> IO ())
    -> CInt -> Ptr GLdouble -> GLdouble -> IO ()
    dyn_glutWireSierpinskiSponge FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutWireSierpinskiSponge CInt
    v1 Ptr GLdouble
    v2 GLdouble
    v3

    foreign import CALLCONV "dynamic" dyn_glutWireSierpinskiSponge
      :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
      ->         CInt -> Ptr GLdouble -> GLdouble -> IO ()

    {-# NOINLINE ptr_glutWireSierpinskiSponge #-}
    ptr_glutWireSierpinskiSponge :: FunPtr a
    ptr_glutWireSierpinskiSponge :: forall a. FunPtr a
    ptr_glutWireSierpinskiSponge = 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
    "glutWireSierpinskiSponge"

    -- glutWireSphere --------------------------------------------------------------

    glutWireSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
    glutWireSphere :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLint -> GLint -> m ()
    glutWireSphere GLdouble
    v1 GLint
    v2 GLint
    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 (GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutWireSphere FunPtr (GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutWireSphere GLdouble
    v1 GLint
    v2 GLint
    v3

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

    {-# NOINLINE ptr_glutWireSphere #-}
    ptr_glutWireSphere :: FunPtr a
    ptr_glutWireSphere :: forall a. FunPtr a
    ptr_glutWireSphere = 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
    "glutWireSphere"

    -- glutWireTeacup --------------------------------------------------------------

    glutWireTeacup :: MonadIO m => GLdouble -> m ()
    glutWireTeacup :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutWireTeacup GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutWireTeacup FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutWireTeacup GLdouble
    v1

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

    {-# NOINLINE ptr_glutWireTeacup #-}
    ptr_glutWireTeacup :: FunPtr a
    ptr_glutWireTeacup :: forall a. FunPtr a
    ptr_glutWireTeacup = 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
    "glutWireTeacup"

    -- glutWireTeapot --------------------------------------------------------------

    glutWireTeapot :: MonadIO m => GLdouble -> m ()
    glutWireTeapot :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutWireTeapot GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutWireTeapot FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutWireTeapot GLdouble
    v1

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

    {-# NOINLINE ptr_glutWireTeapot #-}
    ptr_glutWireTeapot :: FunPtr a
    ptr_glutWireTeapot :: forall a. FunPtr a
    ptr_glutWireTeapot = 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
    "glutWireTeapot"

    -- glutWireTeaspoon ------------------------------------------------------------

    glutWireTeaspoon :: MonadIO m => GLdouble -> m ()
    glutWireTeaspoon :: forall (m :: * -> *). MonadIO m => GLdouble -> m ()
    glutWireTeaspoon GLdouble
    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 (GLdouble -> IO ()) -> GLdouble -> IO ()
    dyn_glutWireTeaspoon FunPtr (GLdouble -> IO ())
    forall a. FunPtr a
    ptr_glutWireTeaspoon GLdouble
    v1

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

    {-# NOINLINE ptr_glutWireTeaspoon #-}
    ptr_glutWireTeaspoon :: FunPtr a
    ptr_glutWireTeaspoon :: forall a. FunPtr a
    ptr_glutWireTeaspoon = 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
    "glutWireTeaspoon"

    -- glutWireTetrahedron ---------------------------------------------------------

    glutWireTetrahedron :: MonadIO m => m ()
    glutWireTetrahedron :: forall (m :: * -> *). MonadIO m => m ()
    glutWireTetrahedron = 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 (IO ()) -> IO ()
    dyn_glutWireTetrahedron FunPtr (IO ())
    forall a. FunPtr a
    ptr_glutWireTetrahedron

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

    {-# NOINLINE ptr_glutWireTetrahedron #-}
    ptr_glutWireTetrahedron :: FunPtr a
    ptr_glutWireTetrahedron :: forall a. FunPtr a
    ptr_glutWireTetrahedron = 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
    "glutWireTetrahedron"

    -- glutWireTorus ---------------------------------------------------------------

    glutWireTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireTorus :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLint -> GLint -> m ()
    glutWireTorus GLdouble
    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 (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
    dyn_glutWireTorus FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
    forall a. FunPtr a
    ptr_glutWireTorus GLdouble
    v1 GLdouble
    v2 GLint
    v3 GLint
    v4

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

    {-# NOINLINE ptr_glutWireTorus #-}
    ptr_glutWireTorus :: FunPtr a
    ptr_glutWireTorus :: forall a. FunPtr a
    ptr_glutWireTorus = 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
    "glutWireTorus"