    {-# OPTIONS_HADDOCK hide #-}
    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.GL.Functions.F31
    -- 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.F31 (
      glVertexAttrib4svARB,
      glVertexAttrib4svNV,
      glVertexAttrib4ubNV,
      glVertexAttrib4ubv,
      glVertexAttrib4ubvARB,
      glVertexAttrib4ubvNV,
      glVertexAttrib4uiv,
      glVertexAttrib4uivARB,
      glVertexAttrib4usv,
      glVertexAttrib4usvARB,
      glVertexAttribArrayObjectATI,
      glVertexAttribBinding,
      glVertexAttribDivisor,
      glVertexAttribDivisorANGLE,
      glVertexAttribDivisorARB,
      glVertexAttribDivisorEXT,
      glVertexAttribDivisorNV,
      glVertexAttribFormat,
      glVertexAttribFormatNV,
      glVertexAttribI1i,
      glVertexAttribI1iEXT,
      glVertexAttribI1iv,
      glVertexAttribI1ivEXT,
      glVertexAttribI1ui,
      glVertexAttribI1uiEXT,
      glVertexAttribI1uiv,
      glVertexAttribI1uivEXT,
      glVertexAttribI2i,
      glVertexAttribI2iEXT,
      glVertexAttribI2iv,
      glVertexAttribI2ivEXT,
      glVertexAttribI2ui,
      glVertexAttribI2uiEXT,
      glVertexAttribI2uiv,
      glVertexAttribI2uivEXT,
      glVertexAttribI3i,
      glVertexAttribI3iEXT,
      glVertexAttribI3iv,
      glVertexAttribI3ivEXT,
      glVertexAttribI3ui,
      glVertexAttribI3uiEXT,
      glVertexAttribI3uiv,
      glVertexAttribI3uivEXT,
      glVertexAttribI4bv,
      glVertexAttribI4bvEXT,
      glVertexAttribI4i,
      glVertexAttribI4iEXT,
      glVertexAttribI4iv,
      glVertexAttribI4ivEXT,
      glVertexAttribI4sv,
      glVertexAttribI4svEXT,
      glVertexAttribI4ubv,
      glVertexAttribI4ubvEXT,
      glVertexAttribI4ui,
      glVertexAttribI4uiEXT,
      glVertexAttribI4uiv,
      glVertexAttribI4uivEXT,
      glVertexAttribI4usv,
      glVertexAttribI4usvEXT,
      glVertexAttribIFormat,
      glVertexAttribIFormatNV,
      glVertexAttribIPointer,
      glVertexAttribIPointerEXT,
      glVertexAttribL1d,
      glVertexAttribL1dEXT,
      glVertexAttribL1dv,
      glVertexAttribL1dvEXT,
      glVertexAttribL1i64NV,
      glVertexAttribL1i64vNV,
      glVertexAttribL1ui64ARB,
      glVertexAttribL1ui64NV,
      glVertexAttribL1ui64vARB,
      glVertexAttribL1ui64vNV,
      glVertexAttribL2d,
      glVertexAttribL2dEXT,
      glVertexAttribL2dv,
      glVertexAttribL2dvEXT,
      glVertexAttribL2i64NV,
      glVertexAttribL2i64vNV,
      glVertexAttribL2ui64NV,
      glVertexAttribL2ui64vNV,
      glVertexAttribL3d,
      glVertexAttribL3dEXT,
      glVertexAttribL3dv,
      glVertexAttribL3dvEXT,
      glVertexAttribL3i64NV,
      glVertexAttribL3i64vNV,
      glVertexAttribL3ui64NV,
      glVertexAttribL3ui64vNV,
      glVertexAttribL4d,
      glVertexAttribL4dEXT,
      glVertexAttribL4dv,
      glVertexAttribL4dvEXT,
      glVertexAttribL4i64NV,
      glVertexAttribL4i64vNV,
      glVertexAttribL4ui64NV,
      glVertexAttribL4ui64vNV,
      glVertexAttribLFormat,
      glVertexAttribLFormatNV,
      glVertexAttribLPointer
    ) where

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

    -- glVertexAttrib4svARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4sv'.
    glVertexAttrib4svARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib4svARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib4svARB GLuint
    v1 Ptr GLshort
    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 GLshort -> IO ())
    -> GLuint -> Ptr GLshort -> IO ()
    dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
    ptr_glVertexAttrib4svARB GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib4svNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4sv'.
    glVertexAttrib4svNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib4svNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib4svNV GLuint
    v1 Ptr GLshort
    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 GLshort -> IO ())
    -> GLuint -> Ptr GLshort -> IO ()
    dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
    ptr_glVertexAttrib4svNV GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib4ubNV ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib4ubvNV'. This command is an alias for 'glVertexAttrib4Nub'.
    glVertexAttrib4ubNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLubyte -- ^ @x@ of type @ColorUB@.
      -> GLubyte -- ^ @y@ of type @ColorUB@.
      -> GLubyte -- ^ @z@ of type @ColorUB@.
      -> GLubyte -- ^ @w@ of type @ColorUB@.
      -> m ()
    glVertexAttrib4ubNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glVertexAttrib4ubNV 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 ()
    dyn905 FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glVertexAttrib4ubNV GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

    {-# NOINLINE ptr_glVertexAttrib4ubNV #-}
    ptr_glVertexAttrib4ubNV :: FunPtr (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glVertexAttrib4ubNV :: FunPtr
      (GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ())
    ptr_glVertexAttrib4ubNV = 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
    "glVertexAttrib4ubNV"

    -- glVertexAttrib4ubv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttrib4ubv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttrib4ubv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttrib4ubv GLuint
    v1 Ptr GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLubyte -> IO ())
    -> GLuint -> Ptr GLubyte -> IO ()
    dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
    ptr_glVertexAttrib4ubv GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttrib4ubvARB -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4ubv'.
    glVertexAttrib4ubvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttrib4ubvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttrib4ubvARB GLuint
    v1 Ptr GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLubyte -> IO ())
    -> GLuint -> Ptr GLubyte -> IO ()
    dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
    ptr_glVertexAttrib4ubvARB GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttrib4ubvNV --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4Nubv'.
    glVertexAttrib4ubvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @ColorUB@.
      -> m ()
    glVertexAttrib4ubvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttrib4ubvNV GLuint
    v1 Ptr GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLubyte -> IO ())
    -> GLuint -> Ptr GLubyte -> IO ()
    dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
    ptr_glVertexAttrib4ubvNV GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttrib4uiv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttrib4uiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
      -> m ()
    glVertexAttrib4uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttrib4uiv 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttrib4uiv #-}
    ptr_glVertexAttrib4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uiv = 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
    "glVertexAttrib4uiv"

    -- glVertexAttrib4uivARB -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4uiv'.
    glVertexAttrib4uivARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
      -> m ()
    glVertexAttrib4uivARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttrib4uivARB 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uivARB GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttrib4uivARB #-}
    ptr_glVertexAttrib4uivARB :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uivARB :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttrib4uivARB = 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
    "glVertexAttrib4uivARB"

    -- glVertexAttrib4usv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man2/xhtml/glVertexAttrib.xml OpenGL 2.x> or <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttrib4usv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
      -> m ()
    glVertexAttrib4usv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
    glVertexAttrib4usv GLuint
    v1 Ptr GLushort
    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 GLushort -> IO ())
    -> GLuint -> Ptr GLushort -> IO ()
    dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
    ptr_glVertexAttrib4usv GLuint
    v1 Ptr GLushort
    v2

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

    -- glVertexAttrib4usvARB -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4usv'.
    glVertexAttrib4usvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
      -> m ()
    glVertexAttrib4usvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
    glVertexAttrib4usvARB GLuint
    v1 Ptr GLushort
    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 GLushort -> IO ())
    -> GLuint -> Ptr GLushort -> IO ()
    dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
    ptr_glVertexAttrib4usvARB GLuint
    v1 Ptr GLushort
    v2

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

    -- glVertexAttribArrayObjectATI ------------------------------------------------

    glVertexAttribArrayObjectATI
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
      -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLsizei -- ^ @stride@.
      -> GLuint -- ^ @buffer@.
      -> GLuint -- ^ @offset@.
      -> m ()
    glVertexAttribArrayObjectATI :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLint -> GLuint -> GLubyte -> GLint -> GLuint -> GLuint -> m ()
    glVertexAttribArrayObjectATI GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    v4 GLint
    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
       -> GLint
       -> GLuint
       -> GLubyte
       -> GLint
       -> GLuint
       -> GLuint
       -> IO ())
    -> GLuint
    -> GLint
    -> GLuint
    -> GLubyte
    -> GLint
    -> GLuint
    -> GLuint
    -> IO ()
    dyn910 FunPtr
      (GLuint
       -> GLint
       -> GLuint
       -> GLubyte
       -> GLint
       -> GLuint
       -> GLuint
       -> IO ())
    ptr_glVertexAttribArrayObjectATI GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    v4 GLint
    v5 GLuint
    v6 GLuint
    v7

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

    -- glVertexAttribBinding -------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribBinding.xhtml OpenGL 4.x>.
    glVertexAttribBinding
      :: MonadIO m
      => GLuint -- ^ @attribindex@.
      -> GLuint -- ^ @bindingindex@.
      -> m ()
    glVertexAttribBinding :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribBinding 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribBinding GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribBinding #-}
    ptr_glVertexAttribBinding :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribBinding :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribBinding = 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
    "glVertexAttribBinding"

    -- glVertexAttribDivisor -------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribDivisor.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribDivisor.xhtml OpenGL 4.x>.
    glVertexAttribDivisor
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexAttribDivisor :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribDivisor 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisor GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribDivisor #-}
    ptr_glVertexAttribDivisor :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisor :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisor = 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
    "glVertexAttribDivisor"

    -- glVertexAttribDivisorANGLE --------------------------------------------------

    -- | This command is an alias for 'glVertexAttribDivisor'.
    glVertexAttribDivisorANGLE
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexAttribDivisorANGLE :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribDivisorANGLE 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorANGLE GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribDivisorANGLE #-}
    ptr_glVertexAttribDivisorANGLE :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorANGLE :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorANGLE = 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
    "glVertexAttribDivisorANGLE"

    -- glVertexAttribDivisorARB ----------------------------------------------------

    -- | This command is an alias for 'glVertexAttribDivisor'.
    glVertexAttribDivisorARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexAttribDivisorARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribDivisorARB 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorARB GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribDivisorARB #-}
    ptr_glVertexAttribDivisorARB :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorARB :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorARB = 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
    "glVertexAttribDivisorARB"

    -- glVertexAttribDivisorEXT ----------------------------------------------------

    -- | This command is an alias for 'glVertexAttribDivisor'.
    glVertexAttribDivisorEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexAttribDivisorEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribDivisorEXT 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorEXT GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribDivisorEXT #-}
    ptr_glVertexAttribDivisorEXT :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorEXT :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorEXT = 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
    "glVertexAttribDivisorEXT"

    -- glVertexAttribDivisorNV -----------------------------------------------------

    -- | This command is an alias for 'glVertexAttribDivisor'.
    glVertexAttribDivisorNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexAttribDivisorNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribDivisorNV 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorNV GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribDivisorNV #-}
    ptr_glVertexAttribDivisorNV :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorNV :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribDivisorNV = 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
    "glVertexAttribDivisorNV"

    -- glVertexAttribFormat --------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
    glVertexAttribFormat
      :: MonadIO m
      => GLuint -- ^ @attribindex@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribType](Graphics-GL-Groups.html#VertexAttribType).
      -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLuint -- ^ @relativeoffset@.
      -> m ()
    glVertexAttribFormat :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> m ()
    glVertexAttribFormat GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    v4 GLuint
    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 -> GLubyte -> GLuint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ()
    dyn911 FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLuint -> IO ())
    ptr_glVertexAttribFormat GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    v4 GLuint
    v5

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

    -- glVertexAttribFormatNV ------------------------------------------------------

    glVertexAttribFormatNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribType](Graphics-GL-Groups.html#VertexAttribType).
      -> GLboolean -- ^ @normalized@ of type [Boolean](Graphics-GL-Groups.html#Boolean).
      -> GLsizei -- ^ @stride@.
      -> m ()
    glVertexAttribFormatNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLubyte -> GLint -> m ()
    glVertexAttribFormatNV GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    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 -> GLint -> GLuint -> GLubyte -> GLint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ()
    dyn912 FunPtr (GLuint -> GLint -> GLuint -> GLubyte -> GLint -> IO ())
    ptr_glVertexAttribFormatNV GLuint
    v1 GLint
    v2 GLuint
    v3 GLubyte
    v4 GLint
    v5

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

    -- glVertexAttribI1i -----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI1iv'.
    glVertexAttribI1i
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> m ()
    glVertexAttribI1i :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> m ()
    glVertexAttribI1i GLuint
    v1 GLint
    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 -> GLint -> IO ()) -> GLuint -> GLint -> IO ()
    dyn499 FunPtr (GLuint -> GLint -> IO ())
    ptr_glVertexAttribI1i GLuint
    v1 GLint
    v2

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

    -- glVertexAttribI1iEXT --------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI1ivEXT'. This command is an alias for 'glVertexAttribI1i'.
    glVertexAttribI1iEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> m ()
    glVertexAttribI1iEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> m ()
    glVertexAttribI1iEXT GLuint
    v1 GLint
    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 -> GLint -> IO ()) -> GLuint -> GLint -> IO ()
    dyn499 FunPtr (GLuint -> GLint -> IO ())
    ptr_glVertexAttribI1iEXT GLuint
    v1 GLint
    v2

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

    -- glVertexAttribI1iv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI1iv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @1@ element of type @GLint@.
      -> m ()
    glVertexAttribI1iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI1iv GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI1iv GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI1ivEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI1iv'.
    glVertexAttribI1ivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @1@ element of type @GLint@.
      -> m ()
    glVertexAttribI1ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI1ivEXT GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI1ivEXT GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI1ui ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI1uiv'.
    glVertexAttribI1ui
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> m ()
    glVertexAttribI1ui :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribI1ui 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1ui GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI1ui #-}
    ptr_glVertexAttribI1ui :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1ui :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1ui = 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
    "glVertexAttribI1ui"

    -- glVertexAttribI1uiEXT -------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI1uivEXT'. This command is an alias for 'glVertexAttribI1ui'.
    glVertexAttribI1uiEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> m ()
    glVertexAttribI1uiEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
    glVertexAttribI1uiEXT 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 ()
    dyn4 FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1uiEXT GLuint
    v1 GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI1uiEXT #-}
    ptr_glVertexAttribI1uiEXT :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1uiEXT :: FunPtr (GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI1uiEXT = 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
    "glVertexAttribI1uiEXT"

    -- glVertexAttribI1uiv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI1uiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @1@ element of type @GLuint@.
      -> m ()
    glVertexAttribI1uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI1uiv 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI1uiv #-}
    ptr_glVertexAttribI1uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uiv = 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
    "glVertexAttribI1uiv"

    -- glVertexAttribI1uivEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI1uiv'.
    glVertexAttribI1uivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @1@ element of type @GLuint@.
      -> m ()
    glVertexAttribI1uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI1uivEXT 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uivEXT GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI1uivEXT #-}
    ptr_glVertexAttribI1uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI1uivEXT = 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
    "glVertexAttribI1uivEXT"

    -- glVertexAttribI2i -----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI2iv'.
    glVertexAttribI2i
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> m ()
    glVertexAttribI2i :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> GLint -> m ()
    glVertexAttribI2i GLuint
    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 (GLuint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> IO ()
    dyn672 FunPtr (GLuint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI2i GLuint
    v1 GLint
    v2 GLint
    v3

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

    -- glVertexAttribI2iEXT --------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI2ivEXT'. This command is an alias for 'glVertexAttribI2i'.
    glVertexAttribI2iEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> m ()
    glVertexAttribI2iEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLint -> GLint -> m ()
    glVertexAttribI2iEXT GLuint
    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 (GLuint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> IO ()
    dyn672 FunPtr (GLuint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI2iEXT GLuint
    v1 GLint
    v2 GLint
    v3

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

    -- glVertexAttribI2iv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI2iv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @2@ elements of type @GLint@.
      -> m ()
    glVertexAttribI2iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI2iv GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI2iv GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI2ivEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI2iv'.
    glVertexAttribI2ivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @2@ elements of type @GLint@.
      -> m ()
    glVertexAttribI2ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI2ivEXT GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI2ivEXT GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI2ui ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI2uiv'.
    glVertexAttribI2ui
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> m ()
    glVertexAttribI2ui :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI2ui 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_glVertexAttribI2ui GLuint
    v1 GLuint
    v2 GLuint
    v3

    {-# NOINLINE ptr_glVertexAttribI2ui #-}
    ptr_glVertexAttribI2ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI2ui :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI2ui = 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
    "glVertexAttribI2ui"

    -- glVertexAttribI2uiEXT -------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI2uivEXT'. This command is an alias for 'glVertexAttribI2ui'.
    glVertexAttribI2uiEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> m ()
    glVertexAttribI2uiEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI2uiEXT 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_glVertexAttribI2uiEXT GLuint
    v1 GLuint
    v2 GLuint
    v3

    {-# NOINLINE ptr_glVertexAttribI2uiEXT #-}
    ptr_glVertexAttribI2uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI2uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI2uiEXT = 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
    "glVertexAttribI2uiEXT"

    -- glVertexAttribI2uiv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI2uiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @2@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI2uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI2uiv 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI2uiv #-}
    ptr_glVertexAttribI2uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uiv = 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
    "glVertexAttribI2uiv"

    -- glVertexAttribI2uivEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI2uiv'.
    glVertexAttribI2uivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @2@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI2uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI2uivEXT 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uivEXT GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI2uivEXT #-}
    ptr_glVertexAttribI2uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI2uivEXT = 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
    "glVertexAttribI2uivEXT"

    -- glVertexAttribI3i -----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI3iv'.
    glVertexAttribI3i
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> GLint -- ^ @z@.
      -> m ()
    glVertexAttribI3i :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLint -> GLint -> m ()
    glVertexAttribI3i GLuint
    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 (GLuint -> GLint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> GLint -> IO ()
    dyn682 FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI3i GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4

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

    -- glVertexAttribI3iEXT --------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI3ivEXT'. This command is an alias for 'glVertexAttribI3i'.
    glVertexAttribI3iEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> GLint -- ^ @z@.
      -> m ()
    glVertexAttribI3iEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLint -> GLint -> m ()
    glVertexAttribI3iEXT GLuint
    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 (GLuint -> GLint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> GLint -> IO ()
    dyn682 FunPtr (GLuint -> GLint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI3iEXT GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4

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

    -- glVertexAttribI3iv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI3iv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @3@ elements of type @GLint@.
      -> m ()
    glVertexAttribI3iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI3iv GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI3iv GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI3ivEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI3iv'.
    glVertexAttribI3ivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @3@ elements of type @GLint@.
      -> m ()
    glVertexAttribI3ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI3ivEXT GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI3ivEXT GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI3ui ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI3uiv'.
    glVertexAttribI3ui
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> GLuint -- ^ @z@.
      -> m ()
    glVertexAttribI3ui :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI3ui 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_glVertexAttribI3ui GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4

    {-# NOINLINE ptr_glVertexAttribI3ui #-}
    ptr_glVertexAttribI3ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI3ui :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI3ui = 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
    "glVertexAttribI3ui"

    -- glVertexAttribI3uiEXT -------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI3uivEXT'. This command is an alias for 'glVertexAttribI3ui'.
    glVertexAttribI3uiEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> GLuint -- ^ @z@.
      -> m ()
    glVertexAttribI3uiEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI3uiEXT 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_glVertexAttribI3uiEXT GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4

    {-# NOINLINE ptr_glVertexAttribI3uiEXT #-}
    ptr_glVertexAttribI3uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI3uiEXT :: FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI3uiEXT = 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
    "glVertexAttribI3uiEXT"

    -- glVertexAttribI3uiv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI3uiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @3@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI3uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI3uiv 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI3uiv #-}
    ptr_glVertexAttribI3uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uiv = 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
    "glVertexAttribI3uiv"

    -- glVertexAttribI3uivEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI3uiv'.
    glVertexAttribI3uivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @3@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI3uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI3uivEXT 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uivEXT GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI3uivEXT #-}
    ptr_glVertexAttribI3uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI3uivEXT = 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
    "glVertexAttribI3uivEXT"

    -- glVertexAttribI4bv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4bv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
      -> m ()
    glVertexAttribI4bv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
    glVertexAttribI4bv GLuint
    v1 Ptr GLbyte
    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 GLbyte -> IO ())
    -> GLuint -> Ptr GLbyte -> IO ()
    dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
    ptr_glVertexAttribI4bv GLuint
    v1 Ptr GLbyte
    v2

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

    -- glVertexAttribI4bvEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4bv'.
    glVertexAttribI4bvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
      -> m ()
    glVertexAttribI4bvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
    glVertexAttribI4bvEXT GLuint
    v1 Ptr GLbyte
    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 GLbyte -> IO ())
    -> GLuint -> Ptr GLbyte -> IO ()
    dyn881 FunPtr (GLuint -> Ptr GLbyte -> IO ())
    ptr_glVertexAttribI4bvEXT GLuint
    v1 Ptr GLbyte
    v2

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

    -- glVertexAttribI4i -----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI4iv'.
    glVertexAttribI4i
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> GLint -- ^ @z@.
      -> GLint -- ^ @w@.
      -> m ()
    glVertexAttribI4i :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLint -> GLint -> GLint -> m ()
    glVertexAttribI4i GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()
    dyn690 FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI4i GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5

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

    -- glVertexAttribI4iEXT --------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI4ivEXT'. This command is an alias for 'glVertexAttribI4i'.
    glVertexAttribI4iEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @x@.
      -> GLint -- ^ @y@.
      -> GLint -- ^ @z@.
      -> GLint -- ^ @w@.
      -> m ()
    glVertexAttribI4iEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLint -> GLint -> GLint -> m ()
    glVertexAttribI4iEXT GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
    -> GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()
    dyn690 FunPtr (GLuint -> GLint -> GLint -> GLint -> GLint -> IO ())
    ptr_glVertexAttribI4iEXT GLuint
    v1 GLint
    v2 GLint
    v3 GLint
    v4 GLint
    v5

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

    -- glVertexAttribI4iv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4iv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
      -> m ()
    glVertexAttribI4iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI4iv GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI4iv GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI4ivEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4iv'.
    glVertexAttribI4ivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
      -> m ()
    glVertexAttribI4ivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint -> m ()
    glVertexAttribI4ivEXT GLuint
    v1 Ptr GLint
    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 GLint -> IO ())
    -> GLuint -> Ptr GLint -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLint -> IO ())
    ptr_glVertexAttribI4ivEXT GLuint
    v1 Ptr GLint
    v2

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

    -- glVertexAttribI4sv ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4sv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttribI4sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttribI4sv GLuint
    v1 Ptr GLshort
    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 GLshort -> IO ())
    -> GLuint -> Ptr GLshort -> IO ()
    dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
    ptr_glVertexAttribI4sv GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttribI4svEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4sv'.
    glVertexAttribI4svEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttribI4svEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttribI4svEXT GLuint
    v1 Ptr GLshort
    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 GLshort -> IO ())
    -> GLuint -> Ptr GLshort -> IO ()
    dyn883 FunPtr (GLuint -> Ptr GLshort -> IO ())
    ptr_glVertexAttribI4svEXT GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttribI4ubv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4ubv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttribI4ubv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttribI4ubv GLuint
    v1 Ptr GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLubyte -> IO ())
    -> GLuint -> Ptr GLubyte -> IO ()
    dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
    ptr_glVertexAttribI4ubv GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttribI4ubvEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4ubv'.
    glVertexAttribI4ubvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttribI4ubvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttribI4ubvEXT GLuint
    v1 Ptr GLubyte
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLubyte -> IO ())
    -> GLuint -> Ptr GLubyte -> IO ()
    dyn393 FunPtr (GLuint -> Ptr GLubyte -> IO ())
    ptr_glVertexAttribI4ubvEXT GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttribI4ui ----------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>. The vector equivalent of this command is 'glVertexAttribI4uiv'.
    glVertexAttribI4ui
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> GLuint -- ^ @z@.
      -> GLuint -- ^ @w@.
      -> m ()
    glVertexAttribI4ui :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI4ui GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    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 -> GLuint -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
    dyn913 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI4ui GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5

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

    -- glVertexAttribI4uiEXT -------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttribI4uivEXT'. This command is an alias for 'glVertexAttribI4ui'.
    glVertexAttribI4uiEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint -- ^ @x@.
      -> GLuint -- ^ @y@.
      -> GLuint -- ^ @z@.
      -> GLuint -- ^ @w@.
      -> m ()
    glVertexAttribI4uiEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> m ()
    glVertexAttribI4uiEXT GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    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 -> GLuint -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()
    dyn913 FunPtr (GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribI4uiEXT GLuint
    v1 GLuint
    v2 GLuint
    v3 GLuint
    v4 GLuint
    v5

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

    -- glVertexAttribI4uiv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4uiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI4uiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI4uiv 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uiv GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI4uiv #-}
    ptr_glVertexAttribI4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uiv :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uiv = 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
    "glVertexAttribI4uiv"

    -- glVertexAttribI4uivEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4uiv'.
    glVertexAttribI4uivEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
      -> m ()
    glVertexAttribI4uivEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttribI4uivEXT 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 ()
    dyn201 FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uivEXT GLuint
    v1 Ptr GLuint
    v2

    {-# NOINLINE ptr_glVertexAttribI4uivEXT #-}
    ptr_glVertexAttribI4uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uivEXT :: FunPtr (GLuint -> Ptr GLuint -> IO ())
    ptr_glVertexAttribI4uivEXT = 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
    "glVertexAttribI4uivEXT"

    -- glVertexAttribI4usv ---------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttrib.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribI4usv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
      -> m ()
    glVertexAttribI4usv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
    glVertexAttribI4usv GLuint
    v1 Ptr GLushort
    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 GLushort -> IO ())
    -> GLuint -> Ptr GLushort -> IO ()
    dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
    ptr_glVertexAttribI4usv GLuint
    v1 Ptr GLushort
    v2

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

    -- glVertexAttribI4usvEXT ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribI4usv'.
    glVertexAttribI4usvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
      -> m ()
    glVertexAttribI4usvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
    glVertexAttribI4usvEXT GLuint
    v1 Ptr GLushort
    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 GLushort -> IO ())
    -> GLuint -> Ptr GLushort -> IO ()
    dyn884 FunPtr (GLuint -> Ptr GLushort -> IO ())
    ptr_glVertexAttribI4usvEXT GLuint
    v1 Ptr GLushort
    v2

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

    -- glVertexAttribIFormat -------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
    glVertexAttribIFormat
      :: MonadIO m
      => GLuint -- ^ @attribindex@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribIType](Graphics-GL-Groups.html#VertexAttribIType).
      -> GLuint -- ^ @relativeoffset@.
      -> m ()
    glVertexAttribIFormat :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLuint -> m ()
    glVertexAttribIFormat GLuint
    v1 GLint
    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 -> GLint -> GLuint -> GLuint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> IO ()
    dyn914 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribIFormat GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4

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

    -- glVertexAttribIFormatNV -----------------------------------------------------

    glVertexAttribIFormatNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribIType](Graphics-GL-Groups.html#VertexAttribIType).
      -> GLsizei -- ^ @stride@.
      -> m ()
    glVertexAttribIFormatNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLint -> m ()
    glVertexAttribIFormatNV GLuint
    v1 GLint
    v2 GLuint
    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 (GLuint -> GLint -> GLuint -> GLint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> IO ()
    dyn915 FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
    ptr_glVertexAttribIFormatNV GLuint
    v1 GLint
    v2 GLuint
    v3 GLint
    v4

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

    -- glVertexAttribIPointer ------------------------------------------------------

    -- | Manual pages for <https://www.opengl.org/sdk/docs/man3/xhtml/glVertexAttribPointer.xml OpenGL 3.x> or <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribPointer.xhtml OpenGL 4.x>.
    glVertexAttribIPointer
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
      -> GLsizei -- ^ @stride@.
      -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @a@.
      -> m ()
    glVertexAttribIPointer :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
    glVertexAttribIPointer GLuint
    v1 GLint
    v2 GLuint
    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 (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    dyn916 FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    ptr_glVertexAttribIPointer GLuint
    v1 GLint
    v2 GLuint
    v3 GLint
    v4 Ptr a
    v5

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

    -- glVertexAttribIPointerEXT ---------------------------------------------------

    -- | This command is an alias for 'glVertexAttribIPointer'.
    glVertexAttribIPointerEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
      -> GLsizei -- ^ @stride@.
      -> Ptr a -- ^ @pointer@ pointing to @COMPSIZE(size,type,stride)@ elements of type @a@.
      -> m ()
    glVertexAttribIPointerEXT :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
    glVertexAttribIPointerEXT GLuint
    v1 GLint
    v2 GLuint
    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 (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    dyn916 FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    ptr_glVertexAttribIPointerEXT GLuint
    v1 GLint
    v2 GLuint
    v3 GLint
    v4 Ptr a
    v5

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

    -- glVertexAttribL1d -----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL1d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> m ()
    glVertexAttribL1d :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
    glVertexAttribL1d GLuint
    v1 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 -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
    dyn895 FunPtr (GLuint -> GLdouble -> IO ())
    ptr_glVertexAttribL1d GLuint
    v1 GLdouble
    v2

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

    -- glVertexAttribL1dEXT --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL1d'.
    glVertexAttribL1dEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> m ()
    glVertexAttribL1dEXT :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
    glVertexAttribL1dEXT GLuint
    v1 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 -> GLdouble -> IO ()) -> GLuint -> GLdouble -> IO ()
    dyn895 FunPtr (GLuint -> GLdouble -> IO ())
    ptr_glVertexAttribL1dEXT GLuint
    v1 GLdouble
    v2

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

    -- glVertexAttribL1dv ----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL1dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
      -> m ()
    glVertexAttribL1dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL1dv 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dv GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL1dv #-}
    ptr_glVertexAttribL1dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dv = 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
    "glVertexAttribL1dv"

    -- glVertexAttribL1dvEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL1dv'.
    glVertexAttribL1dvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
      -> m ()
    glVertexAttribL1dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL1dvEXT 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dvEXT GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL1dvEXT #-}
    ptr_glVertexAttribL1dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL1dvEXT = 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
    "glVertexAttribL1dvEXT"

    -- glVertexAttribL1i64NV -------------------------------------------------------

    glVertexAttribL1i64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint64EXT -- ^ @x@.
      -> m ()
    glVertexAttribL1i64NV :: forall (m :: * -> *). MonadIO m => GLuint -> GLint64EXT -> m ()
    glVertexAttribL1i64NV GLuint
    v1 GLint64EXT
    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 -> GLint64EXT -> IO ())
    -> GLuint -> GLint64EXT -> IO ()
    dyn917 FunPtr (GLuint -> GLint64EXT -> IO ())
    ptr_glVertexAttribL1i64NV GLuint
    v1 GLint64EXT
    v2

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

    -- glVertexAttribL1i64vNV ------------------------------------------------------

    glVertexAttribL1i64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint64EXT -- ^ @v@ pointing to @1@ element of type @GLint64EXT@.
      -> m ()
    glVertexAttribL1i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
    glVertexAttribL1i64vNV GLuint
    v1 Ptr GLint64EXT
    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 GLint64EXT -> IO ())
    -> GLuint -> Ptr GLint64EXT -> IO ()
    dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
    ptr_glVertexAttribL1i64vNV GLuint
    v1 Ptr GLint64EXT
    v2

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

    -- glVertexAttribL1ui64ARB -----------------------------------------------------

    glVertexAttribL1ui64ARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint64EXT -- ^ @x@.
      -> m ()
    glVertexAttribL1ui64ARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint64EXT -> m ()
    glVertexAttribL1ui64ARB GLuint
    v1 GLuint64EXT
    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 -> GLuint64EXT -> IO ())
    -> GLuint -> GLuint64EXT -> IO ()
    dyn919 FunPtr (GLuint -> GLuint64EXT -> IO ())
    ptr_glVertexAttribL1ui64ARB GLuint
    v1 GLuint64EXT
    v2

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

    -- glVertexAttribL1ui64NV ------------------------------------------------------

    glVertexAttribL1ui64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint64EXT -- ^ @x@.
      -> m ()
    glVertexAttribL1ui64NV :: forall (m :: * -> *). MonadIO m => GLuint -> GLuint64EXT -> m ()
    glVertexAttribL1ui64NV GLuint
    v1 GLuint64EXT
    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 -> GLuint64EXT -> IO ())
    -> GLuint -> GLuint64EXT -> IO ()
    dyn919 FunPtr (GLuint -> GLuint64EXT -> IO ())
    ptr_glVertexAttribL1ui64NV GLuint
    v1 GLuint64EXT
    v2

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

    -- glVertexAttribL1ui64vARB ----------------------------------------------------

    glVertexAttribL1ui64vARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint64EXT -- ^ @v@.
      -> m ()
    glVertexAttribL1ui64vARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> Ptr GLuint64EXT -> m ()
    glVertexAttribL1ui64vARB GLuint
    v1 Ptr GLuint64EXT
    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 GLuint64EXT -> IO ())
    -> GLuint -> Ptr GLuint64EXT -> IO ()
    dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
    ptr_glVertexAttribL1ui64vARB GLuint
    v1 Ptr GLuint64EXT
    v2

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

    -- glVertexAttribL1ui64vNV -----------------------------------------------------

    glVertexAttribL1ui64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint64EXT -- ^ @v@ pointing to @1@ element of type @GLuint64EXT@.
      -> m ()
    glVertexAttribL1ui64vNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> Ptr GLuint64EXT -> m ()
    glVertexAttribL1ui64vNV GLuint
    v1 Ptr GLuint64EXT
    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 GLuint64EXT -> IO ())
    -> GLuint -> Ptr GLuint64EXT -> IO ()
    dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
    ptr_glVertexAttribL1ui64vNV GLuint
    v1 Ptr GLuint64EXT
    v2

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

    -- glVertexAttribL2d -----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL2d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> m ()
    glVertexAttribL2d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> m ()
    glVertexAttribL2d GLuint
    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 (GLuint -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> IO ()
    dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL2d GLuint
    v1 GLdouble
    v2 GLdouble
    v3

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

    -- glVertexAttribL2dEXT --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL2d'.
    glVertexAttribL2dEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> m ()
    glVertexAttribL2dEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> m ()
    glVertexAttribL2dEXT GLuint
    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 (GLuint -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> IO ()
    dyn228 FunPtr (GLuint -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL2dEXT GLuint
    v1 GLdouble
    v2 GLdouble
    v3

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

    -- glVertexAttribL2dv ----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL2dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL2dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL2dv 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dv GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL2dv #-}
    ptr_glVertexAttribL2dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dv = 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
    "glVertexAttribL2dv"

    -- glVertexAttribL2dvEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL2dv'.
    glVertexAttribL2dvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL2dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL2dvEXT 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dvEXT GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL2dvEXT #-}
    ptr_glVertexAttribL2dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL2dvEXT = 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
    "glVertexAttribL2dvEXT"

    -- glVertexAttribL2i64NV -------------------------------------------------------

    glVertexAttribL2i64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint64EXT -- ^ @x@.
      -> GLint64EXT -- ^ @y@.
      -> m ()
    glVertexAttribL2i64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint64EXT -> GLint64EXT -> m ()
    glVertexAttribL2i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    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 -> GLint64EXT -> GLint64EXT -> IO ())
    -> GLuint -> GLint64EXT -> GLint64EXT -> IO ()
    dyn921 FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> IO ())
    ptr_glVertexAttribL2i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    v3

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

    -- glVertexAttribL2i64vNV ------------------------------------------------------

    glVertexAttribL2i64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint64EXT -- ^ @v@ pointing to @2@ elements of type @GLint64EXT@.
      -> m ()
    glVertexAttribL2i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
    glVertexAttribL2i64vNV GLuint
    v1 Ptr GLint64EXT
    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 GLint64EXT -> IO ())
    -> GLuint -> Ptr GLint64EXT -> IO ()
    dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
    ptr_glVertexAttribL2i64vNV GLuint
    v1 Ptr GLint64EXT
    v2

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

    -- glVertexAttribL2ui64NV ------------------------------------------------------

    glVertexAttribL2ui64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint64EXT -- ^ @x@.
      -> GLuint64EXT -- ^ @y@.
      -> m ()
    glVertexAttribL2ui64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint64EXT -> GLuint64EXT -> m ()
    glVertexAttribL2ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    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 -> GLuint64EXT -> GLuint64EXT -> IO ())
    -> GLuint -> GLuint64EXT -> GLuint64EXT -> IO ()
    dyn922 FunPtr (GLuint -> GLuint64EXT -> GLuint64EXT -> IO ())
    ptr_glVertexAttribL2ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    v3

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

    -- glVertexAttribL2ui64vNV -----------------------------------------------------

    glVertexAttribL2ui64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint64EXT -- ^ @v@ pointing to @2@ elements of type @GLuint64EXT@.
      -> m ()
    glVertexAttribL2ui64vNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> Ptr GLuint64EXT -> m ()
    glVertexAttribL2ui64vNV GLuint
    v1 Ptr GLuint64EXT
    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 GLuint64EXT -> IO ())
    -> GLuint -> Ptr GLuint64EXT -> IO ()
    dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
    ptr_glVertexAttribL2ui64vNV GLuint
    v1 Ptr GLuint64EXT
    v2

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

    -- glVertexAttribL3d -----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL3d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> m ()
    glVertexAttribL3d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttribL3d GLuint
    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 (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn902 FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL3d GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

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

    -- glVertexAttribL3dEXT --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL3d'.
    glVertexAttribL3dEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> m ()
    glVertexAttribL3dEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttribL3dEXT GLuint
    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 (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn902 FunPtr (GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL3dEXT GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

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

    -- glVertexAttribL3dv ----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL3dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL3dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL3dv 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dv GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL3dv #-}
    ptr_glVertexAttribL3dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dv = 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
    "glVertexAttribL3dv"

    -- glVertexAttribL3dvEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL3dv'.
    glVertexAttribL3dvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL3dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL3dvEXT 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dvEXT GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL3dvEXT #-}
    ptr_glVertexAttribL3dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL3dvEXT = 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
    "glVertexAttribL3dvEXT"

    -- glVertexAttribL3i64NV -------------------------------------------------------

    glVertexAttribL3i64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint64EXT -- ^ @x@.
      -> GLint64EXT -- ^ @y@.
      -> GLint64EXT -- ^ @z@.
      -> m ()
    glVertexAttribL3i64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> m ()
    glVertexAttribL3i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    v3 GLint64EXT
    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 -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
    -> GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ()
    dyn923 FunPtr (GLuint -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
    ptr_glVertexAttribL3i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    v3 GLint64EXT
    v4

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

    -- glVertexAttribL3i64vNV ------------------------------------------------------

    glVertexAttribL3i64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint64EXT -- ^ @v@ pointing to @3@ elements of type @GLint64EXT@.
      -> m ()
    glVertexAttribL3i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
    glVertexAttribL3i64vNV GLuint
    v1 Ptr GLint64EXT
    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 GLint64EXT -> IO ())
    -> GLuint -> Ptr GLint64EXT -> IO ()
    dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
    ptr_glVertexAttribL3i64vNV GLuint
    v1 Ptr GLint64EXT
    v2

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

    -- glVertexAttribL3ui64NV ------------------------------------------------------

    glVertexAttribL3ui64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint64EXT -- ^ @x@.
      -> GLuint64EXT -- ^ @y@.
      -> GLuint64EXT -- ^ @z@.
      -> m ()
    glVertexAttribL3ui64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> m ()
    glVertexAttribL3ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    v3 GLuint64EXT
    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 -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
    -> GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ()
    dyn924 FunPtr
      (GLuint -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> IO ())
    ptr_glVertexAttribL3ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    v3 GLuint64EXT
    v4

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

    -- glVertexAttribL3ui64vNV -----------------------------------------------------

    glVertexAttribL3ui64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint64EXT -- ^ @v@ pointing to @3@ elements of type @GLuint64EXT@.
      -> m ()
    glVertexAttribL3ui64vNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> Ptr GLuint64EXT -> m ()
    glVertexAttribL3ui64vNV GLuint
    v1 Ptr GLuint64EXT
    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 GLuint64EXT -> IO ())
    -> GLuint -> Ptr GLuint64EXT -> IO ()
    dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
    ptr_glVertexAttribL3ui64vNV GLuint
    v1 Ptr GLuint64EXT
    v2

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

    -- glVertexAttribL4d -----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL4d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> GLdouble -- ^ @w@.
      -> m ()
    glVertexAttribL4d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttribL4d GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    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 -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn906 FunPtr
      (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL4d GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5

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

    -- glVertexAttribL4dEXT --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL4d'.
    glVertexAttribL4dEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> GLdouble -- ^ @w@.
      -> m ()
    glVertexAttribL4dEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttribL4dEXT GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    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 -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    -> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
    dyn906 FunPtr
      (GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
    ptr_glVertexAttribL4dEXT GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5

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

    -- glVertexAttribL4dv ----------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttrib.xhtml OpenGL 4.x>.
    glVertexAttribL4dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL4dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL4dv 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dv GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL4dv #-}
    ptr_glVertexAttribL4dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dv :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dv = 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
    "glVertexAttribL4dv"

    -- glVertexAttribL4dvEXT -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttribL4dv'.
    glVertexAttribL4dvEXT
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
      -> m ()
    glVertexAttribL4dvEXT :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttribL4dvEXT 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 ()
    dyn882 FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dvEXT GLuint
    v1 Ptr GLdouble
    v2

    {-# NOINLINE ptr_glVertexAttribL4dvEXT #-}
    ptr_glVertexAttribL4dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dvEXT :: FunPtr (GLuint -> Ptr GLdouble -> IO ())
    ptr_glVertexAttribL4dvEXT = 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
    "glVertexAttribL4dvEXT"

    -- glVertexAttribL4i64NV -------------------------------------------------------

    glVertexAttribL4i64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint64EXT -- ^ @x@.
      -> GLint64EXT -- ^ @y@.
      -> GLint64EXT -- ^ @z@.
      -> GLint64EXT -- ^ @w@.
      -> m ()
    glVertexAttribL4i64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> m ()
    glVertexAttribL4i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    v3 GLint64EXT
    v4 GLint64EXT
    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
       -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
    -> GLuint
    -> GLint64EXT
    -> GLint64EXT
    -> GLint64EXT
    -> GLint64EXT
    -> IO ()
    dyn925 FunPtr
      (GLuint
       -> GLint64EXT -> GLint64EXT -> GLint64EXT -> GLint64EXT -> IO ())
    ptr_glVertexAttribL4i64NV GLuint
    v1 GLint64EXT
    v2 GLint64EXT
    v3 GLint64EXT
    v4 GLint64EXT
    v5

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

    -- glVertexAttribL4i64vNV ------------------------------------------------------

    glVertexAttribL4i64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint64EXT -- ^ @v@ pointing to @4@ elements of type @GLint64EXT@.
      -> m ()
    glVertexAttribL4i64vNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLint64EXT -> m ()
    glVertexAttribL4i64vNV GLuint
    v1 Ptr GLint64EXT
    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 GLint64EXT -> IO ())
    -> GLuint -> Ptr GLint64EXT -> IO ()
    dyn918 FunPtr (GLuint -> Ptr GLint64EXT -> IO ())
    ptr_glVertexAttribL4i64vNV GLuint
    v1 Ptr GLint64EXT
    v2

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

    -- glVertexAttribL4ui64NV ------------------------------------------------------

    glVertexAttribL4ui64NV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLuint64EXT -- ^ @x@.
      -> GLuint64EXT -- ^ @y@.
      -> GLuint64EXT -- ^ @z@.
      -> GLuint64EXT -- ^ @w@.
      -> m ()
    glVertexAttribL4ui64NV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> GLuint64EXT -> m ()
    glVertexAttribL4ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    v3 GLuint64EXT
    v4 GLuint64EXT
    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
       -> GLuint64EXT
       -> GLuint64EXT
       -> GLuint64EXT
       -> GLuint64EXT
       -> IO ())
    -> GLuint
    -> GLuint64EXT
    -> GLuint64EXT
    -> GLuint64EXT
    -> GLuint64EXT
    -> IO ()
    dyn926 FunPtr
      (GLuint
       -> GLuint64EXT
       -> GLuint64EXT
       -> GLuint64EXT
       -> GLuint64EXT
       -> IO ())
    ptr_glVertexAttribL4ui64NV GLuint
    v1 GLuint64EXT
    v2 GLuint64EXT
    v3 GLuint64EXT
    v4 GLuint64EXT
    v5

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

    -- glVertexAttribL4ui64vNV -----------------------------------------------------

    glVertexAttribL4ui64vNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint64EXT -- ^ @v@ pointing to @4@ elements of type @GLuint64EXT@.
      -> m ()
    glVertexAttribL4ui64vNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> Ptr GLuint64EXT -> m ()
    glVertexAttribL4ui64vNV GLuint
    v1 Ptr GLuint64EXT
    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 GLuint64EXT -> IO ())
    -> GLuint -> Ptr GLuint64EXT -> IO ()
    dyn920 FunPtr (GLuint -> Ptr GLuint64EXT -> IO ())
    ptr_glVertexAttribL4ui64vNV GLuint
    v1 Ptr GLuint64EXT
    v2

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

    -- glVertexAttribLFormat -------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribFormat.xhtml OpenGL 4.x>.
    glVertexAttribLFormat
      :: MonadIO m
      => GLuint -- ^ @attribindex@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribLType](Graphics-GL-Groups.html#VertexAttribLType).
      -> GLuint -- ^ @relativeoffset@.
      -> m ()
    glVertexAttribLFormat :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLuint -> m ()
    glVertexAttribLFormat GLuint
    v1 GLint
    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 -> GLint -> GLuint -> GLuint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLuint -> IO ()
    dyn914 FunPtr (GLuint -> GLint -> GLuint -> GLuint -> IO ())
    ptr_glVertexAttribLFormat GLuint
    v1 GLint
    v2 GLuint
    v3 GLuint
    v4

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

    -- glVertexAttribLFormatNV -----------------------------------------------------

    glVertexAttribLFormatNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribLType](Graphics-GL-Groups.html#VertexAttribLType).
      -> GLsizei -- ^ @stride@.
      -> m ()
    glVertexAttribLFormatNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLint -> m ()
    glVertexAttribLFormatNV GLuint
    v1 GLint
    v2 GLuint
    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 (GLuint -> GLint -> GLuint -> GLint -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> IO ()
    dyn915 FunPtr (GLuint -> GLint -> GLuint -> GLint -> IO ())
    ptr_glVertexAttribLFormatNV GLuint
    v1 GLint
    v2 GLuint
    v3 GLint
    v4

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

    -- glVertexAttribLPointer ------------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glVertexAttribPointer.xhtml OpenGL 4.x>.
    glVertexAttribLPointer
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexAttribPointerType](Graphics-GL-Groups.html#VertexAttribPointerType).
      -> GLsizei -- ^ @stride@.
      -> Ptr a -- ^ @pointer@ pointing to @size@ elements of type @a@.
      -> m ()
    glVertexAttribLPointer :: forall (m :: * -> *) a.
    MonadIO m =>
    GLuint -> GLint -> GLuint -> GLint -> Ptr a -> m ()
    glVertexAttribLPointer GLuint
    v1 GLint
    v2 GLuint
    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 (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    -> GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ()
    dyn916 FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    forall a.
    FunPtr (GLuint -> GLint -> GLuint -> GLint -> Ptr a -> IO ())
    ptr_glVertexAttribLPointer GLuint
    v1 GLint
    v2 GLuint
    v3 GLint
    v4 Ptr a
    v5

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