    {-# OPTIONS_HADDOCK hide #-}
    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.GL.Functions.F03
    -- Copyright   :  (c) Sven Panne 2019
    -- License     :  BSD3
    --
    -- Maintainer  :  Sven Panne <svenpanne@gmail.com>
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- Raw functions from the
    -- <http://www.opengl.org/registry/ OpenGL registry>.
    --
    --------------------------------------------------------------------------------

    module Graphics.GL.Functions.F03 (
      glClearDepthxOES,
      glClearIndex,
      glClearNamedBufferData,
      glClearNamedBufferDataEXT,
      glClearNamedBufferSubData,
      glClearNamedBufferSubDataEXT,
      glClearNamedFramebufferfi,
      glClearNamedFramebufferfv,
      glClearNamedFramebufferiv,
      glClearNamedFramebufferuiv,
      glClearPixelLocalStorageuiEXT,
      glClearStencil,
      glClearTexImage,
      glClearTexImageEXT,
      glClearTexSubImage,
      glClearTexSubImageEXT,
      glClientActiveTexture,
      glClientActiveTextureARB,
      glClientActiveVertexStreamATI,
      glClientAttribDefaultEXT,
      glClientWaitSemaphoreui64NVX,
      glClientWaitSync,
      glClientWaitSyncAPPLE,
      glClipControl,
      glClipControlEXT,
      glClipPlane,
      glClipPlanef,
      glClipPlanefIMG,
      glClipPlanefOES,
      glClipPlanex,
      glClipPlanexIMG,
      glClipPlanexOES,
      glColor3b,
      glColor3bv,
      glColor3d,
      glColor3dv,
      glColor3f,
      glColor3fVertex3fSUN,
      glColor3fVertex3fvSUN,
      glColor3fv,
      glColor3hNV,
      glColor3hvNV,
      glColor3i,
      glColor3iv,
      glColor3s,
      glColor3sv,
      glColor3ub,
      glColor3ubv,
      glColor3ui,
      glColor3uiv,
      glColor3us,
      glColor3usv,
      glColor3xOES,
      glColor3xvOES,
      glColor4b,
      glColor4bv,
      glColor4d,
      glColor4dv,
      glColor4f,
      glColor4fNormal3fVertex3fSUN,
      glColor4fNormal3fVertex3fvSUN,
      glColor4fv,
      glColor4hNV,
      glColor4hvNV,
      glColor4i,
      glColor4iv,
      glColor4s,
      glColor4sv,
      glColor4ub,
      glColor4ubVertex2fSUN,
      glColor4ubVertex2fvSUN,
      glColor4ubVertex3fSUN,
      glColor4ubVertex3fvSUN,
      glColor4ubv,
      glColor4ui,
      glColor4uiv,
      glColor4us,
      glColor4usv,
      glColor4x,
      glColor4xOES,
      glColor4xvOES,
      glColorFormatNV,
      glColorFragmentOp1ATI,
      glColorFragmentOp2ATI,
      glColorFragmentOp3ATI,
      glColorMask,
      glColorMaskIndexedEXT,
      glColorMaski,
      glColorMaskiEXT,
      glColorMaskiOES,
      glColorMaterial,
      glColorP3ui,
      glColorP3uiv,
      glColorP4ui,
      glColorP4uiv,
      glColorPointer,
      glColorPointerEXT,
      glColorPointerListIBM,
      glColorPointervINTEL,
      glColorSubTable
    ) where

    import Control.Monad.IO.Class ( MonadIO(..) )
    import Foreign.Ptr
    import Graphics.GL.Foreign
    import Graphics.GL.Types
    import System.IO.Unsafe ( unsafePerformIO )

    -- glClearDepthxOES ------------------------------------------------------------

    glClearDepthxOES
      :: MonadIO m
      => GLfixed -- ^ @depth@ of type @ClampedFixed@.
      -> m ()
    glClearDepthxOES :: forall (m :: * -> *). MonadIO m => GLfixed -> m ()
    glClearDepthxOES GLfixed
    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 (GLfixed -> IO ()) -> GLfixed -> IO ()
    dyn87 FunPtr (GLfixed -> IO ())
    ptr_glClearDepthxOES GLfixed
    v1

    {-# NOINLINE ptr_glClearDepthxOES #-}
    ptr_glClearDepthxOES :: FunPtr (GLfixed -> IO ())
    ptr_glClearDepthxOES :: FunPtr (GLfixed -> IO ())
    ptr_glClearDepthxOES = IO (FunPtr (GLfixed -> IO ())) -> FunPtr (GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfixed -> IO ())) -> FunPtr (GLfixed -> IO ()))
    -> IO (FunPtr (GLfixed -> IO ())) -> FunPtr (GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearDepthxOES"

    -- glClearIndex ----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glClearIndex.xml OpenGL 2.x>.
    glClearIndex
      :: MonadIO m
      => GLfloat -- ^ @c@ of type @MaskedColorIndexValueF@.
      -> m ()
    glClearIndex :: forall (m :: * -> *). MonadIO m => GLfloat -> m ()
    glClearIndex GLfloat
    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 (GLfloat -> IO ()) -> GLfloat -> IO ()
    dyn85 FunPtr (GLfloat -> IO ())
    ptr_glClearIndex GLfloat
    v1

    {-# NOINLINE ptr_glClearIndex #-}
    ptr_glClearIndex :: FunPtr (GLfloat -> IO ())
    ptr_glClearIndex :: FunPtr (GLfloat -> IO ())
    ptr_glClearIndex = IO (FunPtr (GLfloat -> IO ())) -> FunPtr (GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfloat -> IO ())) -> FunPtr (GLfloat -> IO ()))
    -> IO (FunPtr (GLfloat -> IO ())) -> FunPtr (GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearIndex"

    -- glClearNamedBufferData ------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBufferData.xhtml OpenGL 4.x>.
    glClearNamedBufferData
      :: MonadIO m
      => GLuint -- ^ @buffer@.
      -> GLenum -- ^ @internalformat@ of type [InternalFormat](Graphics-GL-Groups.html#InternalFormat).
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@.
      -> m ()
    glClearNamedBufferData :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> m ()
    glClearNamedBufferData GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()
    dyn88 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearNamedBufferData GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5

    {-# NOINLINE ptr_glClearNamedBufferData #-}
    ptr_glClearNamedBufferData :: FunPtr (GLuint -> GLenum -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearNamedBufferData :: forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearNamedBufferData = IO
      (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> IO
         (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedBufferData"

    -- glClearNamedBufferDataEXT ---------------------------------------------------

    glClearNamedBufferDataEXT
      :: MonadIO m
      => GLuint -- ^ @buffer@.
      -> GLenum -- ^ @internalformat@ of type [InternalFormat](Graphics-GL-Groups.html#InternalFormat).
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearNamedBufferDataEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> m ()
    glClearNamedBufferDataEXT GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()
    dyn88 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearNamedBufferDataEXT GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5

    {-# NOINLINE ptr_glClearNamedBufferDataEXT #-}
    ptr_glClearNamedBufferDataEXT :: FunPtr (GLuint -> GLenum -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearNamedBufferDataEXT :: forall a.
    FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearNamedBufferDataEXT = IO
      (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> IO
         (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedBufferDataEXT"

    -- glClearNamedBufferSubData ---------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBufferSubData.xhtml OpenGL 4.x>.
    glClearNamedBufferSubData
      :: MonadIO m
      => GLuint -- ^ @buffer@.
      -> GLenum -- ^ @internalformat@ of type [InternalFormat](Graphics-GL-Groups.html#InternalFormat).
      -> GLintptr -- ^ @offset@.
      -> GLsizeiptr -- ^ @size@ of type @BufferSize@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@.
      -> m ()
    glClearNamedBufferSubData :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> m ()
    glClearNamedBufferSubData GLuint
    v1 GLuint
    v2 GLintptr
    v3 GLintptr
    v4 GLuint
    v5 GLuint
    v6 Ptr a
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    dyn89 FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearNamedBufferSubData GLuint
    v1 GLuint
    v2 GLintptr
    v3 GLintptr
    v4 GLuint
    v5 GLuint
    v6 Ptr a
    v7

    {-# NOINLINE ptr_glClearNamedBufferSubData #-}
    ptr_glClearNamedBufferSubData :: FunPtr (GLuint -> GLenum -> GLintptr -> GLsizeiptr -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearNamedBufferSubData :: forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearNamedBufferSubData = IO
      (FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLuint
           -> GLintptr
           -> GLintptr
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLuint
           -> GLintptr
           -> GLintptr
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLintptr
             -> GLintptr
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLintptr
             -> GLintptr
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedBufferSubData"

    -- glClearNamedBufferSubDataEXT ------------------------------------------------

    glClearNamedBufferSubDataEXT
      :: MonadIO m
      => GLuint -- ^ @buffer@.
      -> GLenum -- ^ @internalformat@.
      -> GLsizeiptr -- ^ @offset@ of type @BufferSize@.
      -> GLsizeiptr -- ^ @size@ of type @BufferSize@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearNamedBufferSubDataEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> m ()
    glClearNamedBufferSubDataEXT GLuint
    v1 GLuint
    v2 GLintptr
    v3 GLintptr
    v4 GLuint
    v5 GLuint
    v6 Ptr a
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLintptr
    -> GLintptr
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    dyn90 FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearNamedBufferSubDataEXT GLuint
    v1 GLuint
    v2 GLintptr
    v3 GLintptr
    v4 GLuint
    v5 GLuint
    v6 Ptr a
    v7

    {-# NOINLINE ptr_glClearNamedBufferSubDataEXT #-}
    ptr_glClearNamedBufferSubDataEXT :: FunPtr (GLuint -> GLenum -> GLsizeiptr -> GLsizeiptr -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearNamedBufferSubDataEXT :: forall a.
    FunPtr
      (GLuint
       -> GLuint
       -> GLintptr
       -> GLintptr
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearNamedBufferSubDataEXT = IO
      (FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLuint
           -> GLintptr
           -> GLintptr
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLuint
           -> GLintptr
           -> GLintptr
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLintptr
             -> GLintptr
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLintptr
          -> GLintptr
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLintptr
             -> GLintptr
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedBufferSubDataEXT"

    -- glClearNamedFramebufferfi ---------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBuffer.xhtml OpenGL 4.x>.
    glClearNamedFramebufferfi
      :: MonadIO m
      => GLuint -- ^ @framebuffer@.
      -> GLenum -- ^ @buffer@ of type [Buffer](Graphics-GL-Groups.html#Buffer).
      -> GLint -- ^ @drawbuffer@.
      -> GLfloat -- ^ @depth@.
      -> GLint -- ^ @stencil@.
      -> m ()
    glClearNamedFramebufferfi :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLint -> GLfloat -> GLint -> m ()
    glClearNamedFramebufferfi GLuint
    v1 GLuint
    v2 GLint
    v3 GLfloat
    v4 GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ())
    -> GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()
    dyn91 FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ())
    ptr_glClearNamedFramebufferfi GLuint
    v1 GLuint
    v2 GLint
    v3 GLfloat
    v4 GLint
    v5

    {-# NOINLINE ptr_glClearNamedFramebufferfi #-}
    ptr_glClearNamedFramebufferfi :: FunPtr (GLuint -> GLenum -> GLint -> GLfloat -> GLint -> IO ())
    ptr_glClearNamedFramebufferfi :: FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ())
    ptr_glClearNamedFramebufferfi = IO
      (FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()))
    -> IO
         (FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLuint -> GLuint -> GLint -> GLfloat -> GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedFramebufferfi"

    -- glClearNamedFramebufferfv ---------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBuffer.xhtml OpenGL 4.x>.
    glClearNamedFramebufferfv
      :: MonadIO m
      => GLuint -- ^ @framebuffer@.
      -> GLenum -- ^ @buffer@ of type [Buffer](Graphics-GL-Groups.html#Buffer).
      -> GLint -- ^ @drawbuffer@.
      -> Ptr GLfloat -- ^ @value@.
      -> m ()
    glClearNamedFramebufferfv :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLint -> Ptr GLfloat -> m ()
    glClearNamedFramebufferfv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr 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 (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ())
    -> GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()
    dyn92 FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ())
    ptr_glClearNamedFramebufferfv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr GLfloat
    v4

    {-# NOINLINE ptr_glClearNamedFramebufferfv #-}
    ptr_glClearNamedFramebufferfv :: FunPtr (GLuint -> GLenum -> GLint -> Ptr GLfloat -> IO ())
    ptr_glClearNamedFramebufferfv :: FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ())
    ptr_glClearNamedFramebufferfv = IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedFramebufferfv"

    -- glClearNamedFramebufferiv ---------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBuffer.xhtml OpenGL 4.x>.
    glClearNamedFramebufferiv
      :: MonadIO m
      => GLuint -- ^ @framebuffer@.
      -> GLenum -- ^ @buffer@ of type [Buffer](Graphics-GL-Groups.html#Buffer).
      -> GLint -- ^ @drawbuffer@.
      -> Ptr GLint -- ^ @value@.
      -> m ()
    glClearNamedFramebufferiv :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLint -> Ptr GLint -> m ()
    glClearNamedFramebufferiv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr GLint
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ())
    -> GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()
    dyn93 FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ())
    ptr_glClearNamedFramebufferiv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr GLint
    v4

    {-# NOINLINE ptr_glClearNamedFramebufferiv #-}
    ptr_glClearNamedFramebufferiv :: FunPtr (GLuint -> GLenum -> GLint -> Ptr GLint -> IO ())
    ptr_glClearNamedFramebufferiv :: FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ())
    ptr_glClearNamedFramebufferiv = IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedFramebufferiv"

    -- glClearNamedFramebufferuiv --------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearBuffer.xhtml OpenGL 4.x>.
    glClearNamedFramebufferuiv
      :: MonadIO m
      => GLuint -- ^ @framebuffer@.
      -> GLenum -- ^ @buffer@ of type [Buffer](Graphics-GL-Groups.html#Buffer).
      -> GLint -- ^ @drawbuffer@.
      -> Ptr GLuint -- ^ @value@.
      -> m ()
    glClearNamedFramebufferuiv :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLint -> Ptr GLuint -> m ()
    glClearNamedFramebufferuiv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr GLuint
    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 (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ())
    -> GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()
    dyn94 FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ())
    ptr_glClearNamedFramebufferuiv GLuint
    v1 GLuint
    v2 GLint
    v3 Ptr GLuint
    v4

    {-# NOINLINE ptr_glClearNamedFramebufferuiv #-}
    ptr_glClearNamedFramebufferuiv :: FunPtr (GLuint -> GLenum -> GLint -> Ptr GLuint -> IO ())
    ptr_glClearNamedFramebufferuiv :: FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ())
    ptr_glClearNamedFramebufferuiv = IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLuint -> GLuint -> GLint -> Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearNamedFramebufferuiv"

    -- glClearPixelLocalStorageuiEXT -----------------------------------------------

    glClearPixelLocalStorageuiEXT
      :: MonadIO m
      => GLsizei -- ^ @offset@.
      -> GLsizei -- ^ @n@.
      -> Ptr GLuint -- ^ @values@ pointing to @n@ elements of type @GLuint@.
      -> m ()
    glClearPixelLocalStorageuiEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLint -> GLint -> Ptr GLuint -> m ()
    glClearPixelLocalStorageuiEXT GLint
    v1 GLint
    v2 Ptr GLuint
    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 (GLint -> GLint -> Ptr GLuint -> IO ())
    -> GLint -> GLint -> Ptr GLuint -> IO ()
    dyn95 FunPtr (GLint -> GLint -> Ptr GLuint -> IO ())
    ptr_glClearPixelLocalStorageuiEXT GLint
    v1 GLint
    v2 Ptr GLuint
    v3

    {-# NOINLINE ptr_glClearPixelLocalStorageuiEXT #-}
    ptr_glClearPixelLocalStorageuiEXT :: FunPtr (GLsizei -> GLsizei -> Ptr GLuint -> IO ())
    ptr_glClearPixelLocalStorageuiEXT :: FunPtr (GLint -> GLint -> Ptr GLuint -> IO ())
    ptr_glClearPixelLocalStorageuiEXT = IO (FunPtr (GLint -> GLint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLint -> GLint -> Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLint -> Ptr GLuint -> IO ()))
     -> FunPtr (GLint -> GLint -> Ptr GLuint -> IO ()))
    -> IO (FunPtr (GLint -> GLint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLint -> GLint -> Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLint -> Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearPixelLocalStorageuiEXT"

    -- glClearStencil --------------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glClearStencil.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glClearStencil.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glClearStencil.xhtml OpenGL 4.x>.
    glClearStencil
      :: MonadIO m
      => GLint -- ^ @s@ of type @StencilValue@.
      -> m ()
    glClearStencil :: forall (m :: * -> *). MonadIO m => GLint -> m ()
    glClearStencil 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 ()
    dyn13 FunPtr (GLint -> IO ())
    ptr_glClearStencil GLint
    v1

    {-# NOINLINE ptr_glClearStencil #-}
    ptr_glClearStencil :: FunPtr (GLint -> IO ())
    ptr_glClearStencil :: FunPtr (GLint -> IO ())
    ptr_glClearStencil = IO (FunPtr (GLint -> IO ())) -> FunPtr (GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> IO ())) -> FunPtr (GLint -> IO ()))
    -> IO (FunPtr (GLint -> IO ())) -> FunPtr (GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearStencil"

    -- glClearTexImage -------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearTexImage.xhtml OpenGL 4.x>.
    glClearTexImage
      :: MonadIO m
      => GLuint -- ^ @texture@.
      -> GLint -- ^ @level@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearTexImage :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> m ()
    glClearTexImage GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    dyn96 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearTexImage GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5

    {-# NOINLINE ptr_glClearTexImage #-}
    ptr_glClearTexImage :: FunPtr (GLuint -> GLint -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearTexImage :: forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearTexImage = IO (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
     -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> IO
         (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearTexImage"

    -- glClearTexImageEXT ----------------------------------------------------------

    -- | This command is an alias for 'glClearTexImage'.
    glClearTexImageEXT
      :: MonadIO m
      => GLuint -- ^ @texture@.
      -> GLint -- ^ @level@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearTexImageEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> m ()
    glClearTexImageEXT GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    dyn96 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearTexImageEXT GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4 Ptr a
    v5

    {-# NOINLINE ptr_glClearTexImageEXT #-}
    ptr_glClearTexImageEXT :: FunPtr (GLuint -> GLint -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearTexImageEXT :: forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glClearTexImageEXT = IO (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
     -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> IO
         (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLuint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearTexImageEXT"

    -- glClearTexSubImage ----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClearTexSubImage.xhtml OpenGL 4.x>.
    glClearTexSubImage
      :: MonadIO m
      => GLuint -- ^ @texture@.
      -> GLint -- ^ @level@.
      -> GLint -- ^ @xoffset@.
      -> GLint -- ^ @yoffset@.
      -> GLint -- ^ @zoffset@.
      -> GLsizei -- ^ @width@.
      -> GLsizei -- ^ @height@.
      -> GLsizei -- ^ @depth@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearTexSubImage :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> m ()
    glClearTexSubImage GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLint
    v6 GLint
    v7 GLint
    v8 GLuint
    v9 GLuint
    v10 Ptr a
    v11 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    dyn97 FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearTexSubImage GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLint
    v6 GLint
    v7 GLint
    v8 GLuint
    v9 GLuint
    v10 Ptr a
    v11

    {-# NOINLINE ptr_glClearTexSubImage #-}
    ptr_glClearTexSubImage :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearTexSubImage :: forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearTexSubImage = IO
      (FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearTexSubImage"

    -- glClearTexSubImageEXT -------------------------------------------------------

    -- | This command is an alias for 'glClearTexSubImage'.
    glClearTexSubImageEXT
      :: MonadIO m
      => GLuint -- ^ @texture@.
      -> GLint -- ^ @level@.
      -> GLint -- ^ @xoffset@.
      -> GLint -- ^ @yoffset@.
      -> GLint -- ^ @zoffset@.
      -> GLsizei -- ^ @width@.
      -> GLsizei -- ^ @height@.
      -> GLsizei -- ^ @depth@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type)@ elements of type @a@.
      -> m ()
    glClearTexSubImageEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> m ()
    glClearTexSubImageEXT GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLint
    v6 GLint
    v7 GLint
    v8 GLuint
    v9 GLuint
    v10 Ptr a
    v11 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    -> GLuint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLint
    -> GLuint
    -> GLuint
    -> Ptr a
    -> IO ()
    dyn97 FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearTexSubImageEXT GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 GLint
    v6 GLint
    v7 GLint
    v8 GLuint
    v9 GLuint
    v10 Ptr a
    v11

    {-# NOINLINE ptr_glClearTexSubImageEXT #-}
    ptr_glClearTexSubImageEXT :: FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glClearTexSubImageEXT :: forall a.
    FunPtr
      (GLuint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLint
       -> GLuint
       -> GLuint
       -> Ptr a
       -> IO ())
    ptr_glClearTexSubImageEXT = IO
      (FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLint
           -> GLuint
           -> GLuint
           -> Ptr a
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLint
          -> GLuint
          -> GLuint
          -> Ptr a
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLint
             -> GLuint
             -> GLuint
             -> Ptr a
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClearTexSubImageEXT"

    -- glClientActiveTexture -------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glClientActiveTexture.xml OpenGL 2.x>.
    glClientActiveTexture
      :: MonadIO m
      => GLenum -- ^ @texture@ of type [TextureUnit](Graphics-GL-Groups.html#TextureUnit).
      -> m ()
    glClientActiveTexture :: forall (m :: * -> *). MonadIO m => GLuint -> m ()
    glClientActiveTexture GLuint
    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 (GLuint -> IO ()) -> GLuint -> IO ()
    dyn5 FunPtr (GLuint -> IO ())
    ptr_glClientActiveTexture GLuint
    v1

    {-# NOINLINE ptr_glClientActiveTexture #-}
    ptr_glClientActiveTexture :: FunPtr (GLenum -> IO ())
    ptr_glClientActiveTexture :: FunPtr (GLuint -> IO ())
    ptr_glClientActiveTexture = IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientActiveTexture"

    -- glClientActiveTextureARB ----------------------------------------------------

    -- | This command is an alias for 'glClientActiveTexture'.
    glClientActiveTextureARB
      :: MonadIO m
      => GLenum -- ^ @texture@ of type [TextureUnit](Graphics-GL-Groups.html#TextureUnit).
      -> m ()
    glClientActiveTextureARB :: forall (m :: * -> *). MonadIO m => GLuint -> m ()
    glClientActiveTextureARB GLuint
    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 (GLuint -> IO ()) -> GLuint -> IO ()
    dyn5 FunPtr (GLuint -> IO ())
    ptr_glClientActiveTextureARB GLuint
    v1

    {-# NOINLINE ptr_glClientActiveTextureARB #-}
    ptr_glClientActiveTextureARB :: FunPtr (GLenum -> IO ())
    ptr_glClientActiveTextureARB :: FunPtr (GLuint -> IO ())
    ptr_glClientActiveTextureARB = IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientActiveTextureARB"

    -- glClientActiveVertexStreamATI -----------------------------------------------

    glClientActiveVertexStreamATI
      :: MonadIO m
      => GLenum -- ^ @stream@ of type [VertexStreamATI](Graphics-GL-Groups.html#VertexStreamATI).
      -> m ()
    glClientActiveVertexStreamATI :: forall (m :: * -> *). MonadIO m => GLuint -> m ()
    glClientActiveVertexStreamATI GLuint
    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 (GLuint -> IO ()) -> GLuint -> IO ()
    dyn5 FunPtr (GLuint -> IO ())
    ptr_glClientActiveVertexStreamATI GLuint
    v1

    {-# NOINLINE ptr_glClientActiveVertexStreamATI #-}
    ptr_glClientActiveVertexStreamATI :: FunPtr (GLenum -> IO ())
    ptr_glClientActiveVertexStreamATI :: FunPtr (GLuint -> IO ())
    ptr_glClientActiveVertexStreamATI = IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientActiveVertexStreamATI"

    -- glClientAttribDefaultEXT ----------------------------------------------------

    glClientAttribDefaultEXT
      :: MonadIO m
      => GLbitfield -- ^ @mask@ of type [ClientAttribMask](Graphics-GL-Groups.html#ClientAttribMask).
      -> m ()
    glClientAttribDefaultEXT :: forall (m :: * -> *). MonadIO m => GLuint -> m ()
    glClientAttribDefaultEXT GLuint
    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 (GLuint -> IO ()) -> GLuint -> IO ()
    dyn75 FunPtr (GLuint -> IO ())
    ptr_glClientAttribDefaultEXT GLuint
    v1

    {-# NOINLINE ptr_glClientAttribDefaultEXT #-}
    ptr_glClientAttribDefaultEXT :: FunPtr (GLbitfield -> IO ())
    ptr_glClientAttribDefaultEXT :: FunPtr (GLuint -> IO ())
    ptr_glClientAttribDefaultEXT = IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> IO ())) -> FunPtr (GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientAttribDefaultEXT"

    -- glClientWaitSemaphoreui64NVX ------------------------------------------------

    glClientWaitSemaphoreui64NVX
      :: MonadIO m
      => GLsizei -- ^ @fenceObjectCount@.
      -> Ptr GLuint -- ^ @semaphoreArray@ pointing to @fenceObjectCount@ elements of type @GLuint@.
      -> Ptr GLuint64 -- ^ @fenceValueArray@ pointing to @fenceObjectCount@ elements of type @GLuint64@.
      -> m ()
    glClientWaitSemaphoreui64NVX :: forall (m :: * -> *).
    MonadIO m =>
    GLint -> Ptr GLuint -> Ptr GLuint64 -> m ()
    glClientWaitSemaphoreui64NVX GLint
    v1 Ptr GLuint
    v2 Ptr GLuint64
    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 (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    -> GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()
    dyn98 FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    ptr_glClientWaitSemaphoreui64NVX GLint
    v1 Ptr GLuint
    v2 Ptr GLuint64
    v3

    {-# NOINLINE ptr_glClientWaitSemaphoreui64NVX #-}
    ptr_glClientWaitSemaphoreui64NVX :: FunPtr (GLsizei -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    ptr_glClientWaitSemaphoreui64NVX :: FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    ptr_glClientWaitSemaphoreui64NVX = IO (FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()))
    -> FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()))
     -> FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()))
    -> IO (FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()))
    -> FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLint -> Ptr GLuint -> Ptr GLuint64 -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientWaitSemaphoreui64NVX"

    -- glClientWaitSync ------------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glClientWaitSync.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glClientWaitSync.xhtml OpenGL 4.x>.
    glClientWaitSync
      :: MonadIO m
      => GLsync -- ^ @sync@ of type @sync@.
      -> GLbitfield -- ^ @flags@ of type [SyncObjectMask](Graphics-GL-Groups.html#SyncObjectMask).
      -> GLuint64 -- ^ @timeout@.
      -> m GLenum -- ^ of type [SyncStatus](Graphics-GL-Groups.html#SyncStatus).
    glClientWaitSync :: forall (m :: * -> *).
    MonadIO m =>
    GLsync -> GLuint -> GLuint64 -> m GLuint
    glClientWaitSync GLsync
    v1 GLuint
    v2 GLuint64
    v3 = IO GLuint -> m GLuint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLuint -> m GLuint) -> IO GLuint -> m GLuint
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    -> GLsync -> GLuint -> GLuint64 -> IO GLuint
    dyn99 FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    ptr_glClientWaitSync GLsync
    v1 GLuint
    v2 GLuint64
    v3

    {-# NOINLINE ptr_glClientWaitSync #-}
    ptr_glClientWaitSync :: FunPtr (GLsync -> GLbitfield -> GLuint64 -> IO GLenum)
    ptr_glClientWaitSync :: FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    ptr_glClientWaitSync = IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
     -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientWaitSync"

    -- glClientWaitSyncAPPLE -------------------------------------------------------

    -- | This command is an alias for 'glClientWaitSync'.
    glClientWaitSyncAPPLE
      :: MonadIO m
      => GLsync -- ^ @sync@.
      -> GLbitfield -- ^ @flags@ of type [SyncObjectMask](Graphics-GL-Groups.html#SyncObjectMask).
      -> GLuint64 -- ^ @timeout@.
      -> m GLenum -- ^ of type [SyncStatus](Graphics-GL-Groups.html#SyncStatus).
    glClientWaitSyncAPPLE :: forall (m :: * -> *).
    MonadIO m =>
    GLsync -> GLuint -> GLuint64 -> m GLuint
    glClientWaitSyncAPPLE GLsync
    v1 GLuint
    v2 GLuint64
    v3 = IO GLuint -> m GLuint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GLuint -> m GLuint) -> IO GLuint -> m GLuint
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    -> GLsync -> GLuint -> GLuint64 -> IO GLuint
    dyn99 FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    ptr_glClientWaitSyncAPPLE GLsync
    v1 GLuint
    v2 GLuint64
    v3

    {-# NOINLINE ptr_glClientWaitSyncAPPLE #-}
    ptr_glClientWaitSyncAPPLE :: FunPtr (GLsync -> GLbitfield -> GLuint64 -> IO GLenum)
    ptr_glClientWaitSyncAPPLE :: FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    ptr_glClientWaitSyncAPPLE = IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
     -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    -> FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint)
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLsync -> GLuint -> GLuint64 -> IO GLuint))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClientWaitSyncAPPLE"

    -- glClipControl ---------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glClipControl.xhtml OpenGL 4.x>.
    glClipControl
      :: MonadIO m
      => GLenum -- ^ @origin@ of type [ClipControlOrigin](Graphics-GL-Groups.html#ClipControlOrigin).
      -> GLenum -- ^ @depth@ of type [ClipControlDepth](Graphics-GL-Groups.html#ClipControlDepth).
      -> m ()
    glClipControl :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glClipControl GLuint
    v1 GLuint
    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 (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
    dyn54 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glClipControl GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glClipControl #-}
    ptr_glClipControl :: FunPtr (GLenum -> GLenum -> IO ())
    ptr_glClipControl :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glClipControl = IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipControl"

    -- glClipControlEXT ------------------------------------------------------------

    -- | This command is an alias for 'glClipControl'.
    glClipControlEXT
      :: MonadIO m
      => GLenum -- ^ @origin@.
      -> GLenum -- ^ @depth@.
      -> m ()
    glClipControlEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glClipControlEXT GLuint
    v1 GLuint
    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 (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
    dyn54 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glClipControlEXT GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glClipControlEXT #-}
    ptr_glClipControlEXT :: FunPtr (GLenum -> GLenum -> IO ())
    ptr_glClipControlEXT :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glClipControlEXT = IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipControlEXT"

    -- glClipPlane -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glClipPlane.xml OpenGL 2.x>.
    glClipPlane
      :: MonadIO m
      => GLenum -- ^ @plane@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLdouble -- ^ @equation@ pointing to @4@ elements of type @GLdouble@.
      -> m ()
    glClipPlane :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glClipPlane GLuint
    v1 Ptr GLdouble
    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 (GLuint -> Ptr GLdouble -> IO ())
    -> GLuint -> Ptr GLdouble -> IO ()
    dyn100 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glClipPlane GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glClipPlane #-}
    ptr_glClipPlane :: FunPtr (GLenum -> Ptr GLdouble -> IO ())
    ptr_glClipPlane :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glClipPlane = IO (FunPtr (GLuint -> Ptr GLdouble -> IO ()))
    -> FunPtr (GLuint -> Ptr GLdouble -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLdouble -> IO ()))
     -> FunPtr (GLuint -> Ptr GLdouble -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLdouble -> IO ()))
    -> FunPtr (GLuint -> Ptr GLdouble -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLdouble -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlane"

    -- glClipPlanef ----------------------------------------------------------------

    glClipPlanef
      :: MonadIO m
      => GLenum -- ^ @p@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfloat -- ^ @eqn@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glClipPlanef :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glClipPlanef GLuint
    v1 Ptr GLfloat
    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 (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn101 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanef GLuint
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glClipPlanef #-}
    ptr_glClipPlanef :: FunPtr (GLenum -> Ptr GLfloat -> IO ())
    ptr_glClipPlanef :: FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanef = IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanef"

    -- glClipPlanefIMG -------------------------------------------------------------

    glClipPlanefIMG
      :: MonadIO m
      => GLenum -- ^ @p@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfloat -- ^ @eqn@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glClipPlanefIMG :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glClipPlanefIMG GLuint
    v1 Ptr GLfloat
    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 (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn101 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefIMG GLuint
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glClipPlanefIMG #-}
    ptr_glClipPlanefIMG :: FunPtr (GLenum -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefIMG :: FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefIMG = IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanefIMG"

    -- glClipPlanefOES -------------------------------------------------------------

    glClipPlanefOES
      :: MonadIO m
      => GLenum -- ^ @plane@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfloat -- ^ @equation@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glClipPlanefOES :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glClipPlanefOES GLuint
    v1 Ptr GLfloat
    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 (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn101 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefOES GLuint
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glClipPlanefOES #-}
    ptr_glClipPlanefOES :: FunPtr (GLenum -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefOES :: FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glClipPlanefOES = IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanefOES"

    -- glClipPlanex ----------------------------------------------------------------

    glClipPlanex
      :: MonadIO m
      => GLenum -- ^ @plane@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfixed -- ^ @equation@ pointing to @4@ elements of type @GLfixed@.
      -> m ()
    glClipPlanex :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfixed -> m ()
    glClipPlanex GLuint
    v1 Ptr GLfixed
    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 (GLuint -> Ptr GLfixed -> IO ())
    -> GLuint -> Ptr GLfixed -> IO ()
    dyn102 FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanex GLuint
    v1 Ptr GLfixed
    v2

    {-# NOINLINE ptr_glClipPlanex #-}
    ptr_glClipPlanex :: FunPtr (GLenum -> Ptr GLfixed -> IO ())
    ptr_glClipPlanex :: FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanex = IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanex"

    -- glClipPlanexIMG -------------------------------------------------------------

    glClipPlanexIMG
      :: MonadIO m
      => GLenum -- ^ @p@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfixed -- ^ @eqn@ pointing to @4@ elements of type @GLfixed@.
      -> m ()
    glClipPlanexIMG :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfixed -> m ()
    glClipPlanexIMG GLuint
    v1 Ptr GLfixed
    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 (GLuint -> Ptr GLfixed -> IO ())
    -> GLuint -> Ptr GLfixed -> IO ()
    dyn102 FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexIMG GLuint
    v1 Ptr GLfixed
    v2

    {-# NOINLINE ptr_glClipPlanexIMG #-}
    ptr_glClipPlanexIMG :: FunPtr (GLenum -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexIMG :: FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexIMG = IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanexIMG"

    -- glClipPlanexOES -------------------------------------------------------------

    glClipPlanexOES
      :: MonadIO m
      => GLenum -- ^ @plane@ of type [ClipPlaneName](Graphics-GL-Groups.html#ClipPlaneName).
      -> Ptr GLfixed -- ^ @equation@ pointing to @4@ elements of type @GLfixed@.
      -> m ()
    glClipPlanexOES :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfixed -> m ()
    glClipPlanexOES GLuint
    v1 Ptr GLfixed
    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 (GLuint -> Ptr GLfixed -> IO ())
    -> GLuint -> Ptr GLfixed -> IO ()
    dyn102 FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexOES GLuint
    v1 Ptr GLfixed
    v2

    {-# NOINLINE ptr_glClipPlanexOES #-}
    ptr_glClipPlanexOES :: FunPtr (GLenum -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexOES :: FunPtr (GLuint -> Ptr GLfixed -> IO ())
    ptr_glClipPlanexOES = IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
     -> FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    -> FunPtr (GLuint -> Ptr GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glClipPlanexOES"

    -- glColor3b -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3bv'.
    glColor3b
      :: MonadIO m
      => GLbyte -- ^ @red@ of type @ColorB@.
      -> GLbyte -- ^ @green@ of type @ColorB@.
      -> GLbyte -- ^ @blue@ of type @ColorB@.
      -> m ()
    glColor3b :: forall (m :: * -> *).
    MonadIO m =>
    GLbyte -> GLbyte -> GLbyte -> m ()
    glColor3b GLbyte
    v1 GLbyte
    v2 GLbyte
    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 (GLbyte -> GLbyte -> GLbyte -> IO ())
    -> GLbyte -> GLbyte -> GLbyte -> IO ()
    dyn39 FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor3b GLbyte
    v1 GLbyte
    v2 GLbyte
    v3

    {-# NOINLINE ptr_glColor3b #-}
    ptr_glColor3b :: FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor3b :: FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor3b = IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ()))
     -> FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3b"

    -- glColor3bv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3bv
      :: MonadIO m
      => Ptr GLbyte -- ^ @v@ pointing to @3@ elements of type @ColorB@.
      -> m ()
    glColor3bv :: forall (m :: * -> *). MonadIO m => Ptr GLbyte -> m ()
    glColor3bv Ptr GLbyte
    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 GLbyte -> IO ()) -> Ptr GLbyte -> IO ()
    dyn40 FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor3bv Ptr GLbyte
    v1

    {-# NOINLINE ptr_glColor3bv #-}
    ptr_glColor3bv :: FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor3bv :: FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor3bv = IO (FunPtr (Ptr GLbyte -> IO ())) -> FunPtr (Ptr GLbyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLbyte -> IO ())) -> FunPtr (Ptr GLbyte -> IO ()))
    -> IO (FunPtr (Ptr GLbyte -> IO ()))
    -> FunPtr (Ptr GLbyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLbyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3bv"

    -- glColor3d -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3dv'.
    glColor3d
      :: MonadIO m
      => GLdouble -- ^ @red@ of type @ColorD@.
      -> GLdouble -- ^ @green@ of type @ColorD@.
      -> GLdouble -- ^ @blue@ of type @ColorD@.
      -> m ()
    glColor3d :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLdouble -> m ()
    glColor3d GLdouble
    v1 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 (GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn41 FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor3d GLdouble
    v1 GLdouble
    v2 GLdouble
    v3

    {-# NOINLINE ptr_glColor3d #-}
    ptr_glColor3d :: FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor3d :: FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor3d = IO (FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ()))
     -> FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> IO (FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLdouble -> GLdouble -> GLdouble -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3d"

    -- glColor3dv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3dv
      :: MonadIO m
      => Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @ColorD@.
      -> m ()
    glColor3dv :: forall (m :: * -> *). MonadIO m => Ptr GLdouble -> m ()
    glColor3dv Ptr 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 (Ptr GLdouble -> IO ()) -> Ptr GLdouble -> IO ()
    dyn42 FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor3dv Ptr GLdouble
    v1

    {-# NOINLINE ptr_glColor3dv #-}
    ptr_glColor3dv :: FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor3dv :: FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor3dv = IO (FunPtr (Ptr GLdouble -> IO ()))
    -> FunPtr (Ptr GLdouble -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLdouble -> IO ()))
     -> FunPtr (Ptr GLdouble -> IO ()))
    -> IO (FunPtr (Ptr GLdouble -> IO ()))
    -> FunPtr (Ptr GLdouble -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLdouble -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3dv"

    -- glColor3f -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3fv'.
    glColor3f
      :: MonadIO m
      => GLfloat -- ^ @red@ of type @ColorF@.
      -> GLfloat -- ^ @green@ of type @ColorF@.
      -> GLfloat -- ^ @blue@ of type @ColorF@.
      -> m ()
    glColor3f :: forall (m :: * -> *).
    MonadIO m =>
    GLfloat -> GLfloat -> GLfloat -> m ()
    glColor3f GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn43 FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3f GLfloat
    v1 GLfloat
    v2 GLfloat
    v3

    {-# NOINLINE ptr_glColor3f #-}
    ptr_glColor3f :: FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3f :: FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3f = IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ()))
     -> FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3f"

    -- glColor3fVertex3fSUN --------------------------------------------------------

    glColor3fVertex3fSUN
      :: MonadIO m
      => GLfloat -- ^ @r@.
      -> GLfloat -- ^ @g@.
      -> GLfloat -- ^ @b@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glColor3fVertex3fSUN :: forall (m :: * -> *).
    MonadIO m =>
    GLfloat
    -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
    glColor3fVertex3fSUN GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    v5 GLfloat
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLfloat
       -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> IO ()
    dyn103 FunPtr
      (GLfloat
       -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3fVertex3fSUN GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    v5 GLfloat
    v6

    {-# NOINLINE ptr_glColor3fVertex3fSUN #-}
    ptr_glColor3fVertex3fSUN :: FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3fVertex3fSUN :: FunPtr
      (GLfloat
       -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor3fVertex3fSUN = IO
      (FunPtr
         (GLfloat
          -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr
         (GLfloat
          -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLfloat
           -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
     -> FunPtr
          (GLfloat
           -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> IO
         (FunPtr
            (GLfloat
             -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr
         (GLfloat
          -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLfloat
             -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3fVertex3fSUN"

    -- glColor3fVertex3fvSUN -------------------------------------------------------

    glColor3fVertex3fvSUN
      :: MonadIO m
      => Ptr GLfloat -- ^ @c@ pointing to @3@ elements of type @GLfloat@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glColor3fVertex3fvSUN :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLfloat -> Ptr GLfloat -> m ()
    glColor3fVertex3fvSUN Ptr GLfloat
    v1 Ptr GLfloat
    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 GLfloat -> Ptr GLfloat -> IO ())
    -> Ptr GLfloat -> Ptr GLfloat -> IO ()
    dyn104 FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor3fVertex3fvSUN Ptr GLfloat
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glColor3fVertex3fvSUN #-}
    ptr_glColor3fVertex3fvSUN :: FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor3fVertex3fvSUN :: FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor3fVertex3fvSUN = IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3fVertex3fvSUN"

    -- glColor3fv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3fv
      :: MonadIO m
      => Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @ColorF@.
      -> m ()
    glColor3fv :: forall (m :: * -> *). MonadIO m => Ptr GLfloat -> m ()
    glColor3fv Ptr GLfloat
    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 GLfloat -> IO ()) -> Ptr GLfloat -> IO ()
    dyn44 FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor3fv Ptr GLfloat
    v1

    {-# NOINLINE ptr_glColor3fv #-}
    ptr_glColor3fv :: FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor3fv :: FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor3fv = IO (FunPtr (Ptr GLfloat -> IO ())) -> FunPtr (Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3fv"

    -- glColor3hNV -----------------------------------------------------------------

    -- | The vector equivalent of this command is 'glColor3hvNV'.
    glColor3hNV
      :: MonadIO m
      => GLhalfNV -- ^ @red@ of type @Half16NV@.
      -> GLhalfNV -- ^ @green@ of type @Half16NV@.
      -> GLhalfNV -- ^ @blue@ of type @Half16NV@.
      -> m ()
    glColor3hNV :: forall (m :: * -> *).
    MonadIO m =>
    GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
    glColor3hNV GLhalfNV
    v1 GLhalfNV
    v2 GLhalfNV
    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 (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
    dyn105 FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor3hNV GLhalfNV
    v1 GLhalfNV
    v2 GLhalfNV
    v3

    {-# NOINLINE ptr_glColor3hNV #-}
    ptr_glColor3hNV :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor3hNV :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor3hNV = IO (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
     -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> IO (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3hNV"

    -- glColor3hvNV ----------------------------------------------------------------

    glColor3hvNV
      :: MonadIO m
      => Ptr GLhalfNV -- ^ @v@ pointing to @3@ elements of type @Half16NV@.
      -> m ()
    glColor3hvNV :: forall (m :: * -> *). MonadIO m => Ptr GLhalfNV -> m ()
    glColor3hvNV Ptr GLhalfNV
    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 GLhalfNV -> IO ()) -> Ptr GLhalfNV -> IO ()
    dyn106 FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor3hvNV Ptr GLhalfNV
    v1

    {-# NOINLINE ptr_glColor3hvNV #-}
    ptr_glColor3hvNV :: FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor3hvNV :: FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor3hvNV = IO (FunPtr (Ptr GLhalfNV -> IO ()))
    -> FunPtr (Ptr GLhalfNV -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLhalfNV -> IO ()))
     -> FunPtr (Ptr GLhalfNV -> IO ()))
    -> IO (FunPtr (Ptr GLhalfNV -> IO ()))
    -> FunPtr (Ptr GLhalfNV -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLhalfNV -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3hvNV"

    -- glColor3i -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3iv'.
    glColor3i
      :: MonadIO m
      => GLint -- ^ @red@ of type @ColorI@.
      -> GLint -- ^ @green@ of type @ColorI@.
      -> GLint -- ^ @blue@ of type @ColorI@.
      -> m ()
    glColor3i :: forall (m :: * -> *). MonadIO m => GLint -> GLint -> GLint -> m ()
    glColor3i GLint
    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 (GLint -> GLint -> GLint -> IO ())
    -> GLint -> GLint -> GLint -> IO ()
    dyn45 FunPtr (GLint -> GLint -> GLint -> IO ())
    ptr_glColor3i GLint
    v1 GLint
    v2 GLint
    v3

    {-# NOINLINE ptr_glColor3i #-}
    ptr_glColor3i :: FunPtr (GLint -> GLint -> GLint -> IO ())
    ptr_glColor3i :: FunPtr (GLint -> GLint -> GLint -> IO ())
    ptr_glColor3i = IO (FunPtr (GLint -> GLint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLint -> GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLint -> GLint -> IO ()))
     -> FunPtr (GLint -> GLint -> GLint -> IO ()))
    -> IO (FunPtr (GLint -> GLint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLint -> GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLint -> GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3i"

    -- glColor3iv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3iv
      :: MonadIO m
      => Ptr GLint -- ^ @v@ pointing to @3@ elements of type @ColorI@.
      -> m ()
    glColor3iv :: forall (m :: * -> *). MonadIO m => Ptr GLint -> m ()
    glColor3iv Ptr 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 (Ptr GLint -> IO ()) -> Ptr GLint -> IO ()
    dyn46 FunPtr (Ptr GLint -> IO ())
    ptr_glColor3iv Ptr GLint
    v1

    {-# NOINLINE ptr_glColor3iv #-}
    ptr_glColor3iv :: FunPtr (Ptr GLint -> IO ())
    ptr_glColor3iv :: FunPtr (Ptr GLint -> IO ())
    ptr_glColor3iv = IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ()))
    -> IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3iv"

    -- glColor3s -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3sv'.
    glColor3s
      :: MonadIO m
      => GLshort -- ^ @red@ of type @ColorS@.
      -> GLshort -- ^ @green@ of type @ColorS@.
      -> GLshort -- ^ @blue@ of type @ColorS@.
      -> m ()
    glColor3s :: forall (m :: * -> *).
    MonadIO m =>
    GLshort -> GLshort -> GLshort -> m ()
    glColor3s GLshort
    v1 GLshort
    v2 GLshort
    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 (GLshort -> GLshort -> GLshort -> IO ())
    -> GLshort -> GLshort -> GLshort -> IO ()
    dyn47 FunPtr (GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor3s GLshort
    v1 GLshort
    v2 GLshort
    v3

    {-# NOINLINE ptr_glColor3s #-}
    ptr_glColor3s :: FunPtr (GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor3s :: FunPtr (GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor3s = IO (FunPtr (GLshort -> GLshort -> GLshort -> IO ()))
    -> FunPtr (GLshort -> GLshort -> GLshort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLshort -> GLshort -> GLshort -> IO ()))
     -> FunPtr (GLshort -> GLshort -> GLshort -> IO ()))
    -> IO (FunPtr (GLshort -> GLshort -> GLshort -> IO ()))
    -> FunPtr (GLshort -> GLshort -> GLshort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLshort -> GLshort -> GLshort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3s"

    -- glColor3sv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3sv
      :: MonadIO m
      => Ptr GLshort -- ^ @v@ pointing to @3@ elements of type @ColorS@.
      -> m ()
    glColor3sv :: forall (m :: * -> *). MonadIO m => Ptr GLshort -> m ()
    glColor3sv Ptr GLshort
    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 GLshort -> IO ()) -> Ptr GLshort -> IO ()
    dyn48 FunPtr (Ptr GLshort -> IO ())
    ptr_glColor3sv Ptr GLshort
    v1

    {-# NOINLINE ptr_glColor3sv #-}
    ptr_glColor3sv :: FunPtr (Ptr GLshort -> IO ())
    ptr_glColor3sv :: FunPtr (Ptr GLshort -> IO ())
    ptr_glColor3sv = IO (FunPtr (Ptr GLshort -> IO ())) -> FunPtr (Ptr GLshort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLshort -> IO ()))
     -> FunPtr (Ptr GLshort -> IO ()))
    -> IO (FunPtr (Ptr GLshort -> IO ()))
    -> FunPtr (Ptr GLshort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLshort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3sv"

    -- glColor3ub ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3ubv'.
    glColor3ub
      :: MonadIO m
      => GLubyte -- ^ @red@ of type @ColorUB@.
      -> GLubyte -- ^ @green@ of type @ColorUB@.
      -> GLubyte -- ^ @blue@ of type @ColorUB@.
      -> m ()
    glColor3ub :: forall (m :: * -> *).
    MonadIO m =>
    GLubyte -> GLubyte -> GLubyte -> m ()
    glColor3ub GLubyte
    v1 GLubyte
    v2 GLubyte
    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 (GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn107 FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor3ub GLubyte
    v1 GLubyte
    v2 GLubyte
    v3

    {-# NOINLINE ptr_glColor3ub #-}
    ptr_glColor3ub :: FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor3ub :: FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor3ub = IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3ub"

    -- glColor3ubv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3ubv
      :: MonadIO m
      => Ptr GLubyte -- ^ @v@ pointing to @3@ elements of type @ColorUB@.
      -> m ()
    glColor3ubv :: forall (m :: * -> *). MonadIO m => Ptr GLubyte -> m ()
    glColor3ubv Ptr GLubyte
    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 GLubyte -> IO ()) -> Ptr GLubyte -> IO ()
    dyn108 FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor3ubv Ptr GLubyte
    v1

    {-# NOINLINE ptr_glColor3ubv #-}
    ptr_glColor3ubv :: FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor3ubv :: FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor3ubv = IO (FunPtr (Ptr GLubyte -> IO ())) -> FunPtr (Ptr GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLubyte -> IO ()))
     -> FunPtr (Ptr GLubyte -> IO ()))
    -> IO (FunPtr (Ptr GLubyte -> IO ()))
    -> FunPtr (Ptr GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3ubv"

    -- glColor3ui ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3uiv'.
    glColor3ui
      :: MonadIO m
      => GLuint -- ^ @red@ of type @ColorUI@.
      -> GLuint -- ^ @green@ of type @ColorUI@.
      -> GLuint -- ^ @blue@ of type @ColorUI@.
      -> m ()
    glColor3ui :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> m ()
    glColor3ui GLuint
    v1 GLuint
    v2 GLuint
    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 (GLuint -> GLuint -> GLuint -> IO ())
    -> GLuint -> GLuint -> GLuint -> IO ()
    dyn109 FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor3ui GLuint
    v1 GLuint
    v2 GLuint
    v3

    {-# NOINLINE ptr_glColor3ui #-}
    ptr_glColor3ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor3ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor3ui = IO (FunPtr (GLuint -> GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3ui"

    -- glColor3uiv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3uiv
      :: MonadIO m
      => Ptr GLuint -- ^ @v@ pointing to @3@ elements of type @ColorUI@.
      -> m ()
    glColor3uiv :: forall (m :: * -> *). MonadIO m => Ptr GLuint -> m ()
    glColor3uiv Ptr GLuint
    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 GLuint -> IO ()) -> Ptr GLuint -> IO ()
    dyn110 FunPtr (Ptr GLuint -> IO ())
    ptr_glColor3uiv Ptr GLuint
    v1

    {-# NOINLINE ptr_glColor3uiv #-}
    ptr_glColor3uiv :: FunPtr (Ptr GLuint -> IO ())
    ptr_glColor3uiv :: FunPtr (Ptr GLuint -> IO ())
    ptr_glColor3uiv = IO (FunPtr (Ptr GLuint -> IO ())) -> FunPtr (Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLuint -> IO ())) -> FunPtr (Ptr GLuint -> IO ()))
    -> IO (FunPtr (Ptr GLuint -> IO ()))
    -> FunPtr (Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3uiv"

    -- glColor3us ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor3usv'.
    glColor3us
      :: MonadIO m
      => GLushort -- ^ @red@ of type @ColorUS@.
      -> GLushort -- ^ @green@ of type @ColorUS@.
      -> GLushort -- ^ @blue@ of type @ColorUS@.
      -> m ()
    glColor3us :: forall (m :: * -> *).
    MonadIO m =>
    GLushort -> GLushort -> GLushort -> m ()
    glColor3us GLushort
    v1 GLushort
    v2 GLushort
    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 (GLushort -> GLushort -> GLushort -> IO ())
    -> GLushort -> GLushort -> GLushort -> IO ()
    dyn111 FunPtr (GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor3us GLushort
    v1 GLushort
    v2 GLushort
    v3

    {-# NOINLINE ptr_glColor3us #-}
    ptr_glColor3us :: FunPtr (GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor3us :: FunPtr (GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor3us = IO (FunPtr (GLushort -> GLushort -> GLushort -> IO ()))
    -> FunPtr (GLushort -> GLushort -> GLushort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLushort -> GLushort -> GLushort -> IO ()))
     -> FunPtr (GLushort -> GLushort -> GLushort -> IO ()))
    -> IO (FunPtr (GLushort -> GLushort -> GLushort -> IO ()))
    -> FunPtr (GLushort -> GLushort -> GLushort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLushort -> GLushort -> GLushort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3us"

    -- glColor3usv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor3usv
      :: MonadIO m
      => Ptr GLushort -- ^ @v@ pointing to @3@ elements of type @ColorUS@.
      -> m ()
    glColor3usv :: forall (m :: * -> *). MonadIO m => Ptr GLushort -> m ()
    glColor3usv Ptr GLushort
    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 GLushort -> IO ()) -> Ptr GLushort -> IO ()
    dyn112 FunPtr (Ptr GLushort -> IO ())
    ptr_glColor3usv Ptr GLushort
    v1

    {-# NOINLINE ptr_glColor3usv #-}
    ptr_glColor3usv :: FunPtr (Ptr GLushort -> IO ())
    ptr_glColor3usv :: FunPtr (Ptr GLushort -> IO ())
    ptr_glColor3usv = IO (FunPtr (Ptr GLushort -> IO ()))
    -> FunPtr (Ptr GLushort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLushort -> IO ()))
     -> FunPtr (Ptr GLushort -> IO ()))
    -> IO (FunPtr (Ptr GLushort -> IO ()))
    -> FunPtr (Ptr GLushort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLushort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3usv"

    -- glColor3xOES ----------------------------------------------------------------

    glColor3xOES
      :: MonadIO m
      => GLfixed -- ^ @red@.
      -> GLfixed -- ^ @green@.
      -> GLfixed -- ^ @blue@.
      -> m ()
    glColor3xOES :: forall (m :: * -> *).
    MonadIO m =>
    GLfixed -> GLfixed -> GLfixed -> m ()
    glColor3xOES GLfixed
    v1 GLfixed
    v2 GLfixed
    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 (GLfixed -> GLfixed -> GLfixed -> IO ())
    -> GLfixed -> GLfixed -> GLfixed -> IO ()
    dyn113 FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor3xOES GLfixed
    v1 GLfixed
    v2 GLfixed
    v3

    {-# NOINLINE ptr_glColor3xOES #-}
    ptr_glColor3xOES :: FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor3xOES :: FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor3xOES = IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ()))
     -> FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3xOES"

    -- glColor3xvOES ---------------------------------------------------------------

    glColor3xvOES
      :: MonadIO m
      => Ptr GLfixed -- ^ @components@ pointing to @3@ elements of type @GLfixed@.
      -> m ()
    glColor3xvOES :: forall (m :: * -> *). MonadIO m => Ptr GLfixed -> m ()
    glColor3xvOES Ptr GLfixed
    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 GLfixed -> IO ()) -> Ptr GLfixed -> IO ()
    dyn114 FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor3xvOES Ptr GLfixed
    v1

    {-# NOINLINE ptr_glColor3xvOES #-}
    ptr_glColor3xvOES :: FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor3xvOES :: FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor3xvOES = IO (FunPtr (Ptr GLfixed -> IO ())) -> FunPtr (Ptr GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfixed -> IO ()))
     -> FunPtr (Ptr GLfixed -> IO ()))
    -> IO (FunPtr (Ptr GLfixed -> IO ()))
    -> FunPtr (Ptr GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor3xvOES"

    -- glColor4b -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4bv'.
    glColor4b
      :: MonadIO m
      => GLbyte -- ^ @red@ of type @ColorB@.
      -> GLbyte -- ^ @green@ of type @ColorB@.
      -> GLbyte -- ^ @blue@ of type @ColorB@.
      -> GLbyte -- ^ @alpha@ of type @ColorB@.
      -> m ()
    glColor4b :: forall (m :: * -> *).
    MonadIO m =>
    GLbyte -> GLbyte -> GLbyte -> GLbyte -> m ()
    glColor4b GLbyte
    v1 GLbyte
    v2 GLbyte
    v3 GLbyte
    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 (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    -> GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()
    dyn115 FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor4b GLbyte
    v1 GLbyte
    v2 GLbyte
    v3 GLbyte
    v4

    {-# NOINLINE ptr_glColor4b #-}
    ptr_glColor4b :: FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor4b :: FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    ptr_glColor4b = IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()))
     -> FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()))
    -> FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4b"

    -- glColor4bv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4bv
      :: MonadIO m
      => Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @ColorB@.
      -> m ()
    glColor4bv :: forall (m :: * -> *). MonadIO m => Ptr GLbyte -> m ()
    glColor4bv Ptr GLbyte
    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 GLbyte -> IO ()) -> Ptr GLbyte -> IO ()
    dyn40 FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor4bv Ptr GLbyte
    v1

    {-# NOINLINE ptr_glColor4bv #-}
    ptr_glColor4bv :: FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor4bv :: FunPtr (Ptr GLbyte -> IO ())
    ptr_glColor4bv = IO (FunPtr (Ptr GLbyte -> IO ())) -> FunPtr (Ptr GLbyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLbyte -> IO ())) -> FunPtr (Ptr GLbyte -> IO ()))
    -> IO (FunPtr (Ptr GLbyte -> IO ()))
    -> FunPtr (Ptr GLbyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLbyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4bv"

    -- glColor4d -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4dv'.
    glColor4d
      :: MonadIO m
      => GLdouble -- ^ @red@ of type @ColorD@.
      -> GLdouble -- ^ @green@ of type @ColorD@.
      -> GLdouble -- ^ @blue@ of type @ColorD@.
      -> GLdouble -- ^ @alpha@ of type @ColorD@.
      -> m ()
    glColor4d :: forall (m :: * -> *).
    MonadIO m =>
    GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glColor4d GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn116 FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor4d GLdouble
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

    {-# NOINLINE ptr_glColor4d #-}
    ptr_glColor4d :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor4d :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glColor4d = IO (FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()))
     -> FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> IO
         (FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()))
    -> FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4d"

    -- glColor4dv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4dv
      :: MonadIO m
      => Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @ColorD@.
      -> m ()
    glColor4dv :: forall (m :: * -> *). MonadIO m => Ptr GLdouble -> m ()
    glColor4dv Ptr 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 (Ptr GLdouble -> IO ()) -> Ptr GLdouble -> IO ()
    dyn42 FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor4dv Ptr GLdouble
    v1

    {-# NOINLINE ptr_glColor4dv #-}
    ptr_glColor4dv :: FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor4dv :: FunPtr (Ptr GLdouble -> IO ())
    ptr_glColor4dv = IO (FunPtr (Ptr GLdouble -> IO ()))
    -> FunPtr (Ptr GLdouble -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLdouble -> IO ()))
     -> FunPtr (Ptr GLdouble -> IO ()))
    -> IO (FunPtr (Ptr GLdouble -> IO ()))
    -> FunPtr (Ptr GLdouble -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLdouble -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4dv"

    -- glColor4f -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4fv'.
    glColor4f
      :: MonadIO m
      => GLfloat -- ^ @red@ of type @ColorF@.
      -> GLfloat -- ^ @green@ of type @ColorF@.
      -> GLfloat -- ^ @blue@ of type @ColorF@.
      -> GLfloat -- ^ @alpha@ of type @ColorF@.
      -> m ()
    glColor4f :: forall (m :: * -> *).
    MonadIO m =>
    GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
    glColor4f GLfloat
    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 (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn52 FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4f GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4

    {-# NOINLINE ptr_glColor4f #-}
    ptr_glColor4f :: FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4f :: FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4f = IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
     -> FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4f"

    -- glColor4fNormal3fVertex3fSUN ------------------------------------------------

    glColor4fNormal3fVertex3fSUN
      :: MonadIO m
      => GLfloat -- ^ @r@.
      -> GLfloat -- ^ @g@.
      -> GLfloat -- ^ @b@.
      -> GLfloat -- ^ @a@.
      -> GLfloat -- ^ @nx@.
      -> GLfloat -- ^ @ny@.
      -> GLfloat -- ^ @nz@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glColor4fNormal3fVertex3fSUN :: forall (m :: * -> *).
    MonadIO m =>
    GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> m ()
    glColor4fNormal3fVertex3fSUN GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    v5 GLfloat
    v6 GLfloat
    v7 GLfloat
    v8 GLfloat
    v9 GLfloat
    v10 = 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
      (GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> IO ()
    dyn117 FunPtr
      (GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    ptr_glColor4fNormal3fVertex3fSUN GLfloat
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    v5 GLfloat
    v6 GLfloat
    v7 GLfloat
    v8 GLfloat
    v9 GLfloat
    v10

    {-# NOINLINE ptr_glColor4fNormal3fVertex3fSUN #-}
    ptr_glColor4fNormal3fVertex3fSUN :: FunPtr (GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4fNormal3fVertex3fSUN :: FunPtr
      (GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    ptr_glColor4fNormal3fVertex3fSUN = IO
      (FunPtr
         (GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ()))
    -> FunPtr
         (GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> IO ()))
     -> FunPtr
          (GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> IO ()))
    -> IO
         (FunPtr
            (GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> IO ()))
    -> FunPtr
         (GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4fNormal3fVertex3fSUN"

    -- glColor4fNormal3fVertex3fvSUN -----------------------------------------------

    glColor4fNormal3fVertex3fvSUN
      :: MonadIO m
      => Ptr GLfloat -- ^ @c@ pointing to @4@ elements of type @GLfloat@.
      -> Ptr GLfloat -- ^ @n@ pointing to @3@ elements of type @GLfloat@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glColor4fNormal3fVertex3fvSUN :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> m ()
    glColor4fNormal3fVertex3fvSUN Ptr GLfloat
    v1 Ptr GLfloat
    v2 Ptr GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()
    dyn118 FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor4fNormal3fVertex3fvSUN Ptr GLfloat
    v1 Ptr GLfloat
    v2 Ptr GLfloat
    v3

    {-# NOINLINE ptr_glColor4fNormal3fVertex3fvSUN #-}
    ptr_glColor4fNormal3fVertex3fvSUN :: FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor4fNormal3fVertex3fvSUN :: FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    ptr_glColor4fNormal3fVertex3fvSUN = IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (Ptr GLfloat -> Ptr GLfloat -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4fNormal3fVertex3fvSUN"

    -- glColor4fv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4fv
      :: MonadIO m
      => Ptr GLfloat -- ^ @v@ pointing to @4@ elements of type @ColorF@.
      -> m ()
    glColor4fv :: forall (m :: * -> *). MonadIO m => Ptr GLfloat -> m ()
    glColor4fv Ptr GLfloat
    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 GLfloat -> IO ()) -> Ptr GLfloat -> IO ()
    dyn44 FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor4fv Ptr GLfloat
    v1

    {-# NOINLINE ptr_glColor4fv #-}
    ptr_glColor4fv :: FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor4fv :: FunPtr (Ptr GLfloat -> IO ())
    ptr_glColor4fv = IO (FunPtr (Ptr GLfloat -> IO ())) -> FunPtr (Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4fv"

    -- glColor4hNV -----------------------------------------------------------------

    -- | The vector equivalent of this command is 'glColor4hvNV'.
    glColor4hNV
      :: MonadIO m
      => GLhalfNV -- ^ @red@ of type @Half16NV@.
      -> GLhalfNV -- ^ @green@ of type @Half16NV@.
      -> GLhalfNV -- ^ @blue@ of type @Half16NV@.
      -> GLhalfNV -- ^ @alpha@ of type @Half16NV@.
      -> m ()
    glColor4hNV :: forall (m :: * -> *).
    MonadIO m =>
    GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
    glColor4hNV GLhalfNV
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    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 (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
    dyn119 FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor4hNV GLhalfNV
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    v4

    {-# NOINLINE ptr_glColor4hNV #-}
    ptr_glColor4hNV :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor4hNV :: FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glColor4hNV = IO (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
     -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> IO
         (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    -> FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4hNV"

    -- glColor4hvNV ----------------------------------------------------------------

    glColor4hvNV
      :: MonadIO m
      => Ptr GLhalfNV -- ^ @v@ pointing to @4@ elements of type @Half16NV@.
      -> m ()
    glColor4hvNV :: forall (m :: * -> *). MonadIO m => Ptr GLhalfNV -> m ()
    glColor4hvNV Ptr GLhalfNV
    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 GLhalfNV -> IO ()) -> Ptr GLhalfNV -> IO ()
    dyn106 FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor4hvNV Ptr GLhalfNV
    v1

    {-# NOINLINE ptr_glColor4hvNV #-}
    ptr_glColor4hvNV :: FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor4hvNV :: FunPtr (Ptr GLhalfNV -> IO ())
    ptr_glColor4hvNV = IO (FunPtr (Ptr GLhalfNV -> IO ()))
    -> FunPtr (Ptr GLhalfNV -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLhalfNV -> IO ()))
     -> FunPtr (Ptr GLhalfNV -> IO ()))
    -> IO (FunPtr (Ptr GLhalfNV -> IO ()))
    -> FunPtr (Ptr GLhalfNV -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLhalfNV -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4hvNV"

    -- glColor4i -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4iv'.
    glColor4i
      :: MonadIO m
      => GLint -- ^ @red@ of type @ColorI@.
      -> GLint -- ^ @green@ of type @ColorI@.
      -> GLint -- ^ @blue@ of type @ColorI@.
      -> GLint -- ^ @alpha@ of type @ColorI@.
      -> m ()
    glColor4i :: forall (m :: * -> *).
    MonadIO m =>
    GLint -> GLint -> GLint -> GLint -> m ()
    glColor4i GLint
    v1 GLint
    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 (GLint -> GLint -> GLint -> GLint -> IO ())
    -> GLint -> GLint -> GLint -> GLint -> IO ()
    dyn82 FunPtr (GLint -> GLint -> GLint -> GLint -> IO ())
    ptr_glColor4i GLint
    v1 GLint
    v2 GLint
    v3 GLint
    v4

    {-# NOINLINE ptr_glColor4i #-}
    ptr_glColor4i :: FunPtr (GLint -> GLint -> GLint -> GLint -> IO ())
    ptr_glColor4i :: FunPtr (GLint -> GLint -> GLint -> GLint -> IO ())
    ptr_glColor4i = IO (FunPtr (GLint -> GLint -> GLint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLint -> GLint -> GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLint -> GLint -> GLint -> IO ()))
     -> FunPtr (GLint -> GLint -> GLint -> GLint -> IO ()))
    -> IO (FunPtr (GLint -> GLint -> GLint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLint -> GLint -> GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLint -> GLint -> GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4i"

    -- glColor4iv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4iv
      :: MonadIO m
      => Ptr GLint -- ^ @v@ pointing to @4@ elements of type @ColorI@.
      -> m ()
    glColor4iv :: forall (m :: * -> *). MonadIO m => Ptr GLint -> m ()
    glColor4iv Ptr 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 (Ptr GLint -> IO ()) -> Ptr GLint -> IO ()
    dyn46 FunPtr (Ptr GLint -> IO ())
    ptr_glColor4iv Ptr GLint
    v1

    {-# NOINLINE ptr_glColor4iv #-}
    ptr_glColor4iv :: FunPtr (Ptr GLint -> IO ())
    ptr_glColor4iv :: FunPtr (Ptr GLint -> IO ())
    ptr_glColor4iv = IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ()))
    -> IO (FunPtr (Ptr GLint -> IO ())) -> FunPtr (Ptr GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4iv"

    -- glColor4s -------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4sv'.
    glColor4s
      :: MonadIO m
      => GLshort -- ^ @red@ of type @ColorS@.
      -> GLshort -- ^ @green@ of type @ColorS@.
      -> GLshort -- ^ @blue@ of type @ColorS@.
      -> GLshort -- ^ @alpha@ of type @ColorS@.
      -> m ()
    glColor4s :: forall (m :: * -> *).
    MonadIO m =>
    GLshort -> GLshort -> GLshort -> GLshort -> m ()
    glColor4s GLshort
    v1 GLshort
    v2 GLshort
    v3 GLshort
    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 (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()
    dyn120 FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor4s GLshort
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4

    {-# NOINLINE ptr_glColor4s #-}
    ptr_glColor4s :: FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor4s :: FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glColor4s = IO (FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ()))
    -> FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ()))
     -> FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ()))
    -> IO (FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ()))
    -> FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLshort -> GLshort -> GLshort -> GLshort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4s"

    -- glColor4sv ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4sv
      :: MonadIO m
      => Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @ColorS@.
      -> m ()
    glColor4sv :: forall (m :: * -> *). MonadIO m => Ptr GLshort -> m ()
    glColor4sv Ptr GLshort
    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 GLshort -> IO ()) -> Ptr GLshort -> IO ()
    dyn48 FunPtr (Ptr GLshort -> IO ())
    ptr_glColor4sv Ptr GLshort
    v1

    {-# NOINLINE ptr_glColor4sv #-}
    ptr_glColor4sv :: FunPtr (Ptr GLshort -> IO ())
    ptr_glColor4sv :: FunPtr (Ptr GLshort -> IO ())
    ptr_glColor4sv = IO (FunPtr (Ptr GLshort -> IO ())) -> FunPtr (Ptr GLshort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLshort -> IO ()))
     -> FunPtr (Ptr GLshort -> IO ()))
    -> IO (FunPtr (Ptr GLshort -> IO ()))
    -> FunPtr (Ptr GLshort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLshort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4sv"

    -- glColor4ub ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4ubv'.
    glColor4ub
      :: MonadIO m
      => GLubyte -- ^ @red@ of type @ColorUB@.
      -> GLubyte -- ^ @green@ of type @ColorUB@.
      -> GLubyte -- ^ @blue@ of type @ColorUB@.
      -> GLubyte -- ^ @alpha@ of type @ColorUB@.
      -> m ()
    glColor4ub :: forall (m :: * -> *).
    MonadIO m =>
    GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColor4ub GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    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 (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn121 FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor4ub GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4

    {-# NOINLINE ptr_glColor4ub #-}
    ptr_glColor4ub :: FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor4ub :: FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColor4ub = IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ub"

    -- glColor4ubVertex2fSUN -------------------------------------------------------

    glColor4ubVertex2fSUN
      :: MonadIO m
      => GLubyte -- ^ @r@.
      -> GLubyte -- ^ @g@.
      -> GLubyte -- ^ @b@.
      -> GLubyte -- ^ @a@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> m ()
    glColor4ubVertex2fSUN :: forall (m :: * -> *).
    MonadIO m =>
    GLubyte
    -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> m ()
    glColor4ubVertex2fSUN GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLfloat
    v5 GLfloat
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLubyte
       -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    -> GLubyte
    -> GLubyte
    -> GLubyte
    -> GLubyte
    -> GLfloat
    -> GLfloat
    -> IO ()
    dyn122 FunPtr
      (GLubyte
       -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4ubVertex2fSUN GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLfloat
    v5 GLfloat
    v6

    {-# NOINLINE ptr_glColor4ubVertex2fSUN #-}
    ptr_glColor4ubVertex2fSUN :: FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4ubVertex2fSUN :: FunPtr
      (GLubyte
       -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4ubVertex2fSUN = IO
      (FunPtr
         (GLubyte
          -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr
         (GLubyte
          -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLubyte
           -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ()))
     -> FunPtr
          (GLubyte
           -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ()))
    -> IO
         (FunPtr
            (GLubyte
             -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ()))
    -> FunPtr
         (GLubyte
          -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLubyte
             -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ubVertex2fSUN"

    -- glColor4ubVertex2fvSUN ------------------------------------------------------

    glColor4ubVertex2fvSUN
      :: MonadIO m
      => Ptr GLubyte -- ^ @c@ pointing to @4@ elements of type @GLubyte@.
      -> Ptr GLfloat -- ^ @v@ pointing to @2@ elements of type @GLfloat@.
      -> m ()
    glColor4ubVertex2fvSUN :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLubyte -> Ptr GLfloat -> m ()
    glColor4ubVertex2fvSUN Ptr GLubyte
    v1 Ptr GLfloat
    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 GLubyte -> Ptr GLfloat -> IO ())
    -> Ptr GLubyte -> Ptr GLfloat -> IO ()
    dyn123 FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex2fvSUN Ptr GLubyte
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glColor4ubVertex2fvSUN #-}
    ptr_glColor4ubVertex2fvSUN :: FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex2fvSUN :: FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex2fvSUN = IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ubVertex2fvSUN"

    -- glColor4ubVertex3fSUN -------------------------------------------------------

    glColor4ubVertex3fSUN
      :: MonadIO m
      => GLubyte -- ^ @r@.
      -> GLubyte -- ^ @g@.
      -> GLubyte -- ^ @b@.
      -> GLubyte -- ^ @a@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glColor4ubVertex3fSUN :: forall (m :: * -> *).
    MonadIO m =>
    GLubyte
    -> GLubyte
    -> GLubyte
    -> GLubyte
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> m ()
    glColor4ubVertex3fSUN GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLfloat
    v5 GLfloat
    v6 GLfloat
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLubyte
       -> GLubyte
       -> GLubyte
       -> GLubyte
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    -> GLubyte
    -> GLubyte
    -> GLubyte
    -> GLubyte
    -> GLfloat
    -> GLfloat
    -> GLfloat
    -> IO ()
    dyn124 FunPtr
      (GLubyte
       -> GLubyte
       -> GLubyte
       -> GLubyte
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    ptr_glColor4ubVertex3fSUN GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLfloat
    v5 GLfloat
    v6 GLfloat
    v7

    {-# NOINLINE ptr_glColor4ubVertex3fSUN #-}
    ptr_glColor4ubVertex3fSUN :: FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glColor4ubVertex3fSUN :: FunPtr
      (GLubyte
       -> GLubyte
       -> GLubyte
       -> GLubyte
       -> GLfloat
       -> GLfloat
       -> GLfloat
       -> IO ())
    ptr_glColor4ubVertex3fSUN = IO
      (FunPtr
         (GLubyte
          -> GLubyte
          -> GLubyte
          -> GLubyte
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ()))
    -> FunPtr
         (GLubyte
          -> GLubyte
          -> GLubyte
          -> GLubyte
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLubyte
           -> GLubyte
           -> GLubyte
           -> GLubyte
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> IO ()))
     -> FunPtr
          (GLubyte
           -> GLubyte
           -> GLubyte
           -> GLubyte
           -> GLfloat
           -> GLfloat
           -> GLfloat
           -> IO ()))
    -> IO
         (FunPtr
            (GLubyte
             -> GLubyte
             -> GLubyte
             -> GLubyte
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> IO ()))
    -> FunPtr
         (GLubyte
          -> GLubyte
          -> GLubyte
          -> GLubyte
          -> GLfloat
          -> GLfloat
          -> GLfloat
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLubyte
             -> GLubyte
             -> GLubyte
             -> GLubyte
             -> GLfloat
             -> GLfloat
             -> GLfloat
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ubVertex3fSUN"

    -- glColor4ubVertex3fvSUN ------------------------------------------------------

    glColor4ubVertex3fvSUN
      :: MonadIO m
      => Ptr GLubyte -- ^ @c@ pointing to @4@ elements of type @GLubyte@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glColor4ubVertex3fvSUN :: forall (m :: * -> *).
    MonadIO m =>
    Ptr GLubyte -> Ptr GLfloat -> m ()
    glColor4ubVertex3fvSUN Ptr GLubyte
    v1 Ptr GLfloat
    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 GLubyte -> Ptr GLfloat -> IO ())
    -> Ptr GLubyte -> Ptr GLfloat -> IO ()
    dyn123 FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex3fvSUN Ptr GLubyte
    v1 Ptr GLfloat
    v2

    {-# NOINLINE ptr_glColor4ubVertex3fvSUN #-}
    ptr_glColor4ubVertex3fvSUN :: FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex3fvSUN :: FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    ptr_glColor4ubVertex3fvSUN = IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
     -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    -> FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLubyte -> Ptr GLfloat -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ubVertex3fvSUN"

    -- glColor4ubv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4ubv
      :: MonadIO m
      => Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @ColorUB@.
      -> m ()
    glColor4ubv :: forall (m :: * -> *). MonadIO m => Ptr GLubyte -> m ()
    glColor4ubv Ptr GLubyte
    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 GLubyte -> IO ()) -> Ptr GLubyte -> IO ()
    dyn108 FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor4ubv Ptr GLubyte
    v1

    {-# NOINLINE ptr_glColor4ubv #-}
    ptr_glColor4ubv :: FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor4ubv :: FunPtr (Ptr GLubyte -> IO ())
    ptr_glColor4ubv = IO (FunPtr (Ptr GLubyte -> IO ())) -> FunPtr (Ptr GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLubyte -> IO ()))
     -> FunPtr (Ptr GLubyte -> IO ()))
    -> IO (FunPtr (Ptr GLubyte -> IO ()))
    -> FunPtr (Ptr GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ubv"

    -- glColor4ui ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4uiv'.
    glColor4ui
      :: MonadIO m
      => GLuint -- ^ @red@ of type @ColorUI@.
      -> GLuint -- ^ @green@ of type @ColorUI@.
      -> GLuint -- ^ @blue@ of type @ColorUI@.
      -> GLuint -- ^ @alpha@ of type @ColorUI@.
      -> m ()
    glColor4ui :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glColor4ui GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    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 (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
    dyn83 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor4ui GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4

    {-# NOINLINE ptr_glColor4ui #-}
    ptr_glColor4ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor4ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColor4ui = IO (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4ui"

    -- glColor4uiv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4uiv
      :: MonadIO m
      => Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @ColorUI@.
      -> m ()
    glColor4uiv :: forall (m :: * -> *). MonadIO m => Ptr GLuint -> m ()
    glColor4uiv Ptr GLuint
    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 GLuint -> IO ()) -> Ptr GLuint -> IO ()
    dyn110 FunPtr (Ptr GLuint -> IO ())
    ptr_glColor4uiv Ptr GLuint
    v1

    {-# NOINLINE ptr_glColor4uiv #-}
    ptr_glColor4uiv :: FunPtr (Ptr GLuint -> IO ())
    ptr_glColor4uiv :: FunPtr (Ptr GLuint -> IO ())
    ptr_glColor4uiv = IO (FunPtr (Ptr GLuint -> IO ())) -> FunPtr (Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLuint -> IO ())) -> FunPtr (Ptr GLuint -> IO ()))
    -> IO (FunPtr (Ptr GLuint -> IO ()))
    -> FunPtr (Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4uiv"

    -- glColor4us ------------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>. The vector equivalent of this command is 'glColor4usv'.
    glColor4us
      :: MonadIO m
      => GLushort -- ^ @red@ of type @ColorUS@.
      -> GLushort -- ^ @green@ of type @ColorUS@.
      -> GLushort -- ^ @blue@ of type @ColorUS@.
      -> GLushort -- ^ @alpha@ of type @ColorUS@.
      -> m ()
    glColor4us :: forall (m :: * -> *).
    MonadIO m =>
    GLushort -> GLushort -> GLushort -> GLushort -> m ()
    glColor4us GLushort
    v1 GLushort
    v2 GLushort
    v3 GLushort
    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 (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    -> GLushort -> GLushort -> GLushort -> GLushort -> IO ()
    dyn125 FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor4us GLushort
    v1 GLushort
    v2 GLushort
    v3 GLushort
    v4

    {-# NOINLINE ptr_glColor4us #-}
    ptr_glColor4us :: FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor4us :: FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    ptr_glColor4us = IO (FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ()))
    -> FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ()))
     -> FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ()))
    -> IO
         (FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ()))
    -> FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLushort -> GLushort -> GLushort -> GLushort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4us"

    -- glColor4usv -----------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColor.xml OpenGL 2.x>.
    glColor4usv
      :: MonadIO m
      => Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @ColorUS@.
      -> m ()
    glColor4usv :: forall (m :: * -> *). MonadIO m => Ptr GLushort -> m ()
    glColor4usv Ptr GLushort
    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 GLushort -> IO ()) -> Ptr GLushort -> IO ()
    dyn112 FunPtr (Ptr GLushort -> IO ())
    ptr_glColor4usv Ptr GLushort
    v1

    {-# NOINLINE ptr_glColor4usv #-}
    ptr_glColor4usv :: FunPtr (Ptr GLushort -> IO ())
    ptr_glColor4usv :: FunPtr (Ptr GLushort -> IO ())
    ptr_glColor4usv = IO (FunPtr (Ptr GLushort -> IO ()))
    -> FunPtr (Ptr GLushort -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLushort -> IO ()))
     -> FunPtr (Ptr GLushort -> IO ()))
    -> IO (FunPtr (Ptr GLushort -> IO ()))
    -> FunPtr (Ptr GLushort -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLushort -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4usv"

    -- glColor4x -------------------------------------------------------------------

    glColor4x
      :: MonadIO m
      => GLfixed -- ^ @red@.
      -> GLfixed -- ^ @green@.
      -> GLfixed -- ^ @blue@.
      -> GLfixed -- ^ @alpha@.
      -> m ()
    glColor4x :: forall (m :: * -> *).
    MonadIO m =>
    GLfixed -> GLfixed -> GLfixed -> GLfixed -> m ()
    glColor4x GLfixed
    v1 GLfixed
    v2 GLfixed
    v3 GLfixed
    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 (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    -> GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()
    dyn53 FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4x GLfixed
    v1 GLfixed
    v2 GLfixed
    v3 GLfixed
    v4

    {-# NOINLINE ptr_glColor4x #-}
    ptr_glColor4x :: FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4x :: FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4x = IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
     -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4x"

    -- glColor4xOES ----------------------------------------------------------------

    glColor4xOES
      :: MonadIO m
      => GLfixed -- ^ @red@.
      -> GLfixed -- ^ @green@.
      -> GLfixed -- ^ @blue@.
      -> GLfixed -- ^ @alpha@.
      -> m ()
    glColor4xOES :: forall (m :: * -> *).
    MonadIO m =>
    GLfixed -> GLfixed -> GLfixed -> GLfixed -> m ()
    glColor4xOES GLfixed
    v1 GLfixed
    v2 GLfixed
    v3 GLfixed
    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 (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    -> GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()
    dyn53 FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4xOES GLfixed
    v1 GLfixed
    v2 GLfixed
    v3 GLfixed
    v4

    {-# NOINLINE ptr_glColor4xOES #-}
    ptr_glColor4xOES :: FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4xOES :: FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    ptr_glColor4xOES = IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
     -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    -> FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLfixed -> GLfixed -> GLfixed -> GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4xOES"

    -- glColor4xvOES ---------------------------------------------------------------

    glColor4xvOES
      :: MonadIO m
      => Ptr GLfixed -- ^ @components@ pointing to @4@ elements of type @GLfixed@.
      -> m ()
    glColor4xvOES :: forall (m :: * -> *). MonadIO m => Ptr GLfixed -> m ()
    glColor4xvOES Ptr GLfixed
    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 GLfixed -> IO ()) -> Ptr GLfixed -> IO ()
    dyn114 FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor4xvOES Ptr GLfixed
    v1

    {-# NOINLINE ptr_glColor4xvOES #-}
    ptr_glColor4xvOES :: FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor4xvOES :: FunPtr (Ptr GLfixed -> IO ())
    ptr_glColor4xvOES = IO (FunPtr (Ptr GLfixed -> IO ())) -> FunPtr (Ptr GLfixed -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (Ptr GLfixed -> IO ()))
     -> FunPtr (Ptr GLfixed -> IO ()))
    -> IO (FunPtr (Ptr GLfixed -> IO ()))
    -> FunPtr (Ptr GLfixed -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (Ptr GLfixed -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColor4xvOES"

    -- glColorFormatNV -------------------------------------------------------------

    glColorFormatNV
      :: MonadIO m
      => GLint -- ^ @size@.
      -> GLenum -- ^ @type@.
      -> GLsizei -- ^ @stride@.
      -> m ()
    glColorFormatNV :: forall (m :: * -> *). MonadIO m => GLint -> GLuint -> GLint -> m ()
    glColorFormatNV GLint
    v1 GLuint
    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 (GLint -> GLuint -> GLint -> IO ())
    -> GLint -> GLuint -> GLint -> IO ()
    dyn126 FunPtr (GLint -> GLuint -> GLint -> IO ())
    ptr_glColorFormatNV GLint
    v1 GLuint
    v2 GLint
    v3

    {-# NOINLINE ptr_glColorFormatNV #-}
    ptr_glColorFormatNV :: FunPtr (GLint -> GLenum -> GLsizei -> IO ())
    ptr_glColorFormatNV :: FunPtr (GLint -> GLuint -> GLint -> IO ())
    ptr_glColorFormatNV = IO (FunPtr (GLint -> GLuint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLuint -> GLint -> IO ()))
     -> FunPtr (GLint -> GLuint -> GLint -> IO ()))
    -> IO (FunPtr (GLint -> GLuint -> GLint -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLuint -> GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorFormatNV"

    -- glColorFragmentOp1ATI -------------------------------------------------------

    glColorFragmentOp1ATI
      :: MonadIO m
      => GLenum -- ^ @op@ of type [FragmentOpATI](Graphics-GL-Groups.html#FragmentOpATI).
      -> GLuint -- ^ @dst@.
      -> GLuint -- ^ @dstMask@.
      -> GLuint -- ^ @dstMod@.
      -> GLuint -- ^ @arg1@.
      -> GLuint -- ^ @arg1Rep@.
      -> GLuint -- ^ @arg1Mod@.
      -> m ()
    glColorFragmentOp1ATI :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glColorFragmentOp1ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> IO ()
    dyn127 FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp1ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7

    {-# NOINLINE ptr_glColorFragmentOp1ATI #-}
    ptr_glColorFragmentOp1ATI :: FunPtr (GLenum -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColorFragmentOp1ATI :: FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp1ATI = IO
      (FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorFragmentOp1ATI"

    -- glColorFragmentOp2ATI -------------------------------------------------------

    glColorFragmentOp2ATI
      :: MonadIO m
      => GLenum -- ^ @op@ of type [FragmentOpATI](Graphics-GL-Groups.html#FragmentOpATI).
      -> GLuint -- ^ @dst@.
      -> GLuint -- ^ @dstMask@.
      -> GLuint -- ^ @dstMod@.
      -> GLuint -- ^ @arg1@.
      -> GLuint -- ^ @arg1Rep@.
      -> GLuint -- ^ @arg1Mod@.
      -> GLuint -- ^ @arg2@.
      -> GLuint -- ^ @arg2Rep@.
      -> GLuint -- ^ @arg2Mod@.
      -> m ()
    glColorFragmentOp2ATI :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> m ()
    glColorFragmentOp2ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7 GLuint
    v8 GLuint
    v9 GLuint
    v10 = 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
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> IO ()
    dyn128 FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp2ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7 GLuint
    v8 GLuint
    v9 GLuint
    v10

    {-# NOINLINE ptr_glColorFragmentOp2ATI #-}
    ptr_glColorFragmentOp2ATI :: FunPtr (GLenum -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColorFragmentOp2ATI :: FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp2ATI = IO
      (FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorFragmentOp2ATI"

    -- glColorFragmentOp3ATI -------------------------------------------------------

    glColorFragmentOp3ATI
      :: MonadIO m
      => GLenum -- ^ @op@ of type [FragmentOpATI](Graphics-GL-Groups.html#FragmentOpATI).
      -> GLuint -- ^ @dst@.
      -> GLuint -- ^ @dstMask@.
      -> GLuint -- ^ @dstMod@.
      -> GLuint -- ^ @arg1@.
      -> GLuint -- ^ @arg1Rep@.
      -> GLuint -- ^ @arg1Mod@.
      -> GLuint -- ^ @arg2@.
      -> GLuint -- ^ @arg2Rep@.
      -> GLuint -- ^ @arg2Mod@.
      -> GLuint -- ^ @arg3@.
      -> GLuint -- ^ @arg3Rep@.
      -> GLuint -- ^ @arg3Mod@.
      -> m ()
    glColorFragmentOp3ATI :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> m ()
    glColorFragmentOp3ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7 GLuint
    v8 GLuint
    v9 GLuint
    v10 GLuint
    v11 GLuint
    v12 GLuint
    v13 = 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
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> GLuint
    -> IO ()
    dyn129 FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp3ATI GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5 GLuint
    v6 GLuint
    v7 GLuint
    v8 GLuint
    v9 GLuint
    v10 GLuint
    v11 GLuint
    v12 GLuint
    v13

    {-# NOINLINE ptr_glColorFragmentOp3ATI #-}
    ptr_glColorFragmentOp3ATI :: FunPtr (GLenum -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glColorFragmentOp3ATI :: FunPtr
      (GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glColorFragmentOp3ATI = IO
      (FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
     -> FunPtr
          (GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> GLuint
           -> IO ()))
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    -> FunPtr
         (GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> GLuint
          -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> GLuint
             -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorFragmentOp3ATI"

    -- glColorMask -----------------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glColorMask.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glColorMask.xhtml OpenGL 4.x>.
    glColorMask
      :: MonadIO m
      => GLboolean -- ^ @red@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @green@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @blue@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @alpha@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> m ()
    glColorMask :: forall (m :: * -> *).
    MonadIO m =>
    GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColorMask GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    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 (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn130 FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMask GLubyte
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4

    {-# NOINLINE ptr_glColorMask #-}
    ptr_glColorMask :: FunPtr (GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ())
    ptr_glColorMask :: FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMask = IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO (FunPtr (GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMask"

    -- glColorMaskIndexedEXT -------------------------------------------------------

    -- | This command is an alias for 'glColorMaski'.
    glColorMaskIndexedEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLboolean -- ^ @r@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @g@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @b@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @a@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> m ()
    glColorMaskIndexedEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColorMaskIndexedEXT GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn131 FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskIndexedEXT GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

    {-# NOINLINE ptr_glColorMaskIndexedEXT #-}
    ptr_glColorMaskIndexedEXT :: FunPtr (GLuint -> GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ())
    ptr_glColorMaskIndexedEXT :: FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskIndexedEXT = IO
      (FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMaskIndexedEXT"

    -- glColorMaski ----------------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glColorMask.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glColorMask.xhtml OpenGL 4.x>.
    glColorMaski
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLboolean -- ^ @r@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @g@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @b@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @a@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> m ()
    glColorMaski :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColorMaski GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn131 FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaski GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

    {-# NOINLINE ptr_glColorMaski #-}
    ptr_glColorMaski :: FunPtr (GLuint -> GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ())
    ptr_glColorMaski :: FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaski = IO
      (FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMaski"

    -- glColorMaskiEXT -------------------------------------------------------------

    -- | This command is an alias for 'glColorMaski'.
    glColorMaskiEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLboolean -- ^ @r@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @g@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @b@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @a@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> m ()
    glColorMaskiEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColorMaskiEXT GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn131 FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskiEXT GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

    {-# NOINLINE ptr_glColorMaskiEXT #-}
    ptr_glColorMaskiEXT :: FunPtr (GLuint -> GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ())
    ptr_glColorMaskiEXT :: FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskiEXT = IO
      (FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMaskiEXT"

    -- glColorMaskiOES -------------------------------------------------------------

    -- | This command is an alias for 'glColorMaski'.
    glColorMaskiOES
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLboolean -- ^ @r@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @g@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @b@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLboolean -- ^ @a@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> m ()
    glColorMaskiOES :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glColorMaskiOES GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    -> GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()
    dyn131 FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskiOES GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

    {-# NOINLINE ptr_glColorMaskiOES #-}
    ptr_glColorMaskiOES :: FunPtr (GLuint -> GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ())
    ptr_glColorMaskiOES :: FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glColorMaskiOES = IO
      (FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
     -> FunPtr
          (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    -> FunPtr
         (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMaskiOES"

    -- glColorMaterial -------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColorMaterial.xml OpenGL 2.x>.
    glColorMaterial
      :: MonadIO m
      => GLenum -- ^ @face@ of type [MaterialFace](Graphics-GL-Groups.html#MaterialFace).
      -> GLenum -- ^ @mode@ of type [ColorMaterialParameter](Graphics-GL-Groups.html#ColorMaterialParameter).
      -> m ()
    glColorMaterial :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glColorMaterial GLuint
    v1 GLuint
    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 (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
    dyn54 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorMaterial GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glColorMaterial #-}
    ptr_glColorMaterial :: FunPtr (GLenum -> GLenum -> IO ())
    ptr_glColorMaterial :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorMaterial = IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorMaterial"

    -- glColorP3ui -----------------------------------------------------------------

    glColorP3ui
      :: MonadIO m
      => GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> GLuint -- ^ @color@.
      -> m ()
    glColorP3ui :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glColorP3ui GLuint
    v1 GLuint
    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 (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
    dyn19 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorP3ui GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glColorP3ui #-}
    ptr_glColorP3ui :: FunPtr (GLenum -> GLuint -> IO ())
    ptr_glColorP3ui :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorP3ui = IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorP3ui"

    -- glColorP3uiv ----------------------------------------------------------------

    glColorP3uiv
      :: MonadIO m
      => GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> Ptr GLuint -- ^ @color@ pointing to @1@ element of type @GLuint@.
      -> m ()
    glColorP3uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glColorP3uiv GLuint
    v1 Ptr GLuint
    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 (GLuint -> Ptr GLuint -> IO ())
    -> GLuint -> Ptr GLuint -> IO ()
    dyn132 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glColorP3uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glColorP3uiv #-}
    ptr_glColorP3uiv :: FunPtr (GLenum -> Ptr GLuint -> IO ())
    ptr_glColorP3uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glColorP3uiv = IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
     -> FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorP3uiv"

    -- glColorP4ui -----------------------------------------------------------------

    glColorP4ui
      :: MonadIO m
      => GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> GLuint -- ^ @color@.
      -> m ()
    glColorP4ui :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glColorP4ui GLuint
    v1 GLuint
    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 (GLuint -> GLuint -> IO ()) -> GLuint -> GLuint -> IO ()
    dyn19 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorP4ui GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glColorP4ui #-}
    ptr_glColorP4ui :: FunPtr (GLenum -> GLuint -> IO ())
    ptr_glColorP4ui :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glColorP4ui = IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> GLuint -> IO ()))
     -> FunPtr (GLuint -> GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    -> FunPtr (GLuint -> GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorP4ui"

    -- glColorP4uiv ----------------------------------------------------------------

    glColorP4uiv
      :: MonadIO m
      => GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> Ptr GLuint -- ^ @color@ pointing to @1@ element of type @GLuint@.
      -> m ()
    glColorP4uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glColorP4uiv GLuint
    v1 Ptr GLuint
    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 (GLuint -> Ptr GLuint -> IO ())
    -> GLuint -> Ptr GLuint -> IO ()
    dyn132 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glColorP4uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glColorP4uiv #-}
    ptr_glColorP4uiv :: FunPtr (GLenum -> Ptr GLuint -> IO ())
    ptr_glColorP4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glColorP4uiv = IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> Ptr GLuint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
     -> FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    -> FunPtr (GLuint -> Ptr GLuint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLuint -> Ptr GLuint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorP4uiv"

    -- glColorPointer --------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColorPointer.xml OpenGL 2.x>.
    glColorPointer
      :: MonadIO m
      => GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> GLsizei -- ^ @stride@.
      -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @a@.
      -> m ()
    glColorPointer :: forall (m :: * -> *) a.
    MonadIO m =>
    GLint -> GLuint -> GLint -> Ptr a -> m ()
    glColorPointer GLint
    v1 GLuint
    v2 GLint
    v3 Ptr a
    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 (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    dyn133 FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a. FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    ptr_glColorPointer GLint
    v1 GLuint
    v2 GLint
    v3 Ptr a
    v4

    {-# NOINLINE ptr_glColorPointer #-}
    ptr_glColorPointer :: FunPtr (GLint -> GLenum -> GLsizei -> Ptr a -> IO ())
    ptr_glColorPointer :: forall a. FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    ptr_glColorPointer = IO (FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ()))
     -> FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ()))
    -> IO (FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLuint -> GLint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorPointer"

    -- glColorPointerEXT -----------------------------------------------------------

    glColorPointerEXT
      :: MonadIO m
      => GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> GLsizei -- ^ @stride@.
      -> GLsizei -- ^ @count@.
      -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride,count)@ elements of type @a@.
      -> m ()
    glColorPointerEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLint -> GLuint -> GLint -> GLint -> Ptr a -> m ()
    glColorPointerEXT GLint
    v1 GLuint
    v2 GLint
    v3 GLint
    v4 Ptr a
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    -> GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    -> GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()
    dyn134 FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    ptr_glColorPointerEXT GLint
    v1 GLuint
    v2 GLint
    v3 GLint
    v4 Ptr a
    v5

    {-# NOINLINE ptr_glColorPointerEXT #-}
    ptr_glColorPointerEXT :: FunPtr (GLint -> GLenum -> GLsizei -> GLsizei -> Ptr a -> IO ())
    ptr_glColorPointerEXT :: forall a.
    FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    ptr_glColorPointerEXT = IO (FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()))
     -> FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()))
    -> IO
         (FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()))
    -> FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr (GLint -> GLuint -> GLint -> GLint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorPointerEXT"

    -- glColorPointerListIBM -------------------------------------------------------

    glColorPointerListIBM
      :: MonadIO m
      => GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [ColorPointerType](Graphics-GL-Groups.html#ColorPointerType).
      -> GLint -- ^ @stride@.
      -> Ptr (Ptr a) -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @Ptr a@.
      -> GLint -- ^ @ptrstride@.
      -> m ()
    glColorPointerListIBM :: forall (m :: * -> *) a.
    MonadIO m =>
    GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> m ()
    glColorPointerListIBM GLint
    v1 GLuint
    v2 GLint
    v3 Ptr (Ptr a)
    v4 GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    -> GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()
    forall a.
    FunPtr (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    -> GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()
    dyn135 FunPtr (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    forall a.
    FunPtr (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    ptr_glColorPointerListIBM GLint
    v1 GLuint
    v2 GLint
    v3 Ptr (Ptr a)
    v4 GLint
    v5

    {-# NOINLINE ptr_glColorPointerListIBM #-}
    ptr_glColorPointerListIBM :: FunPtr (GLint -> GLenum -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    ptr_glColorPointerListIBM :: forall a.
    FunPtr (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    ptr_glColorPointerListIBM = IO
      (FunPtr
         (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()))
    -> FunPtr
         (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()))
     -> FunPtr
          (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()))
    -> IO
         (FunPtr
            (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()))
    -> FunPtr
         (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLint -> GLuint -> GLint -> Ptr (Ptr a) -> GLint -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorPointerListIBM"

    -- glColorPointervINTEL --------------------------------------------------------

    glColorPointervINTEL
      :: MonadIO m
      => GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexPointerType](Graphics-GL-Groups.html#VertexPointerType).
      -> Ptr (Ptr a) -- ^ @pointer@ pointing to @4@ elements of type @Ptr a@.
      -> m ()
    glColorPointervINTEL :: forall (m :: * -> *) a.
    MonadIO m =>
    GLint -> GLuint -> Ptr (Ptr a) -> m ()
    glColorPointervINTEL GLint
    v1 GLuint
    v2 Ptr (Ptr a)
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    -> GLint -> GLuint -> Ptr (Ptr a) -> IO ()
    forall a.
    FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    -> GLint -> GLuint -> Ptr (Ptr a) -> IO ()
    dyn136 FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    forall a. FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    ptr_glColorPointervINTEL GLint
    v1 GLuint
    v2 Ptr (Ptr a)
    v3

    {-# NOINLINE ptr_glColorPointervINTEL #-}
    ptr_glColorPointervINTEL :: FunPtr (GLint -> GLenum -> Ptr (Ptr a) -> IO ())
    ptr_glColorPointervINTEL :: forall a. FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    ptr_glColorPointervINTEL = IO (FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ()))
    -> FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO (FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ()))
     -> FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ()))
    -> IO (FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ()))
    -> FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String -> IO (FunPtr (GLint -> GLuint -> Ptr (Ptr a) -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorPointervINTEL"

    -- glColorSubTable -------------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man2/xhtml/glColorSubTable.xml OpenGL 2.x>.
    glColorSubTable
      :: MonadIO m
      => GLenum -- ^ @target@ of type [ColorTableTarget](Graphics-GL-Groups.html#ColorTableTarget).
      -> GLsizei -- ^ @start@.
      -> GLsizei -- ^ @count@.
      -> GLenum -- ^ @format@ of type [PixelFormat](Graphics-GL-Groups.html#PixelFormat).
      -> GLenum -- ^ @type@ of type [PixelType](Graphics-GL-Groups.html#PixelType).
      -> Ptr a -- ^ @data@ pointing to @COMPSIZE(format,type,count)@ elements of type @a@.
      -> m ()
    glColorSubTable :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> m ()
    glColorSubTable GLuint
    v1 GLint
    v2 GLint
    v3 GLuint
    v4 GLuint
    v5 Ptr a
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    forall a.
    FunPtr
      (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()
    dyn137 FunPtr
      (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a.
    FunPtr
      (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glColorSubTable GLuint
    v1 GLint
    v2 GLint
    v3 GLuint
    v4 GLuint
    v5 Ptr a
    v6

    {-# NOINLINE ptr_glColorSubTable #-}
    ptr_glColorSubTable :: FunPtr (GLenum -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ())
    ptr_glColorSubTable :: forall a.
    FunPtr
      (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    ptr_glColorSubTable = IO
      (FunPtr
         (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr
         (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
     -> FunPtr
          (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    -> FunPtr
         (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLint -> GLint -> GLuint -> GLuint -> Ptr a -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glColorSubTable"