    {-# OPTIONS_HADDOCK hide #-}
    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.GL.Functions.F30
    -- 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.F30 (
      glVertexArrayVertexBindingDivisorEXT,
      glVertexArrayVertexBuffer,
      glVertexArrayVertexBuffers,
      glVertexArrayVertexOffsetEXT,
      glVertexAttrib1d,
      glVertexAttrib1dARB,
      glVertexAttrib1dNV,
      glVertexAttrib1dv,
      glVertexAttrib1dvARB,
      glVertexAttrib1dvNV,
      glVertexAttrib1f,
      glVertexAttrib1fARB,
      glVertexAttrib1fNV,
      glVertexAttrib1fv,
      glVertexAttrib1fvARB,
      glVertexAttrib1fvNV,
      glVertexAttrib1hNV,
      glVertexAttrib1hvNV,
      glVertexAttrib1s,
      glVertexAttrib1sARB,
      glVertexAttrib1sNV,
      glVertexAttrib1sv,
      glVertexAttrib1svARB,
      glVertexAttrib1svNV,
      glVertexAttrib2d,
      glVertexAttrib2dARB,
      glVertexAttrib2dNV,
      glVertexAttrib2dv,
      glVertexAttrib2dvARB,
      glVertexAttrib2dvNV,
      glVertexAttrib2f,
      glVertexAttrib2fARB,
      glVertexAttrib2fNV,
      glVertexAttrib2fv,
      glVertexAttrib2fvARB,
      glVertexAttrib2fvNV,
      glVertexAttrib2hNV,
      glVertexAttrib2hvNV,
      glVertexAttrib2s,
      glVertexAttrib2sARB,
      glVertexAttrib2sNV,
      glVertexAttrib2sv,
      glVertexAttrib2svARB,
      glVertexAttrib2svNV,
      glVertexAttrib3d,
      glVertexAttrib3dARB,
      glVertexAttrib3dNV,
      glVertexAttrib3dv,
      glVertexAttrib3dvARB,
      glVertexAttrib3dvNV,
      glVertexAttrib3f,
      glVertexAttrib3fARB,
      glVertexAttrib3fNV,
      glVertexAttrib3fv,
      glVertexAttrib3fvARB,
      glVertexAttrib3fvNV,
      glVertexAttrib3hNV,
      glVertexAttrib3hvNV,
      glVertexAttrib3s,
      glVertexAttrib3sARB,
      glVertexAttrib3sNV,
      glVertexAttrib3sv,
      glVertexAttrib3svARB,
      glVertexAttrib3svNV,
      glVertexAttrib4Nbv,
      glVertexAttrib4NbvARB,
      glVertexAttrib4Niv,
      glVertexAttrib4NivARB,
      glVertexAttrib4Nsv,
      glVertexAttrib4NsvARB,
      glVertexAttrib4Nub,
      glVertexAttrib4NubARB,
      glVertexAttrib4Nubv,
      glVertexAttrib4NubvARB,
      glVertexAttrib4Nuiv,
      glVertexAttrib4NuivARB,
      glVertexAttrib4Nusv,
      glVertexAttrib4NusvARB,
      glVertexAttrib4bv,
      glVertexAttrib4bvARB,
      glVertexAttrib4d,
      glVertexAttrib4dARB,
      glVertexAttrib4dNV,
      glVertexAttrib4dv,
      glVertexAttrib4dvARB,
      glVertexAttrib4dvNV,
      glVertexAttrib4f,
      glVertexAttrib4fARB,
      glVertexAttrib4fNV,
      glVertexAttrib4fv,
      glVertexAttrib4fvARB,
      glVertexAttrib4fvNV,
      glVertexAttrib4hNV,
      glVertexAttrib4hvNV,
      glVertexAttrib4iv,
      glVertexAttrib4ivARB,
      glVertexAttrib4s,
      glVertexAttrib4sARB,
      glVertexAttrib4sNV,
      glVertexAttrib4sv
    ) where

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

    -- glVertexArrayVertexBindingDivisorEXT ----------------------------------------

    glVertexArrayVertexBindingDivisorEXT
      :: MonadIO m
      => GLuint -- ^ @vaobj@.
      -> GLuint -- ^ @bindingindex@.
      -> GLuint -- ^ @divisor@.
      -> m ()
    glVertexArrayVertexBindingDivisorEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> m ()
    glVertexArrayVertexBindingDivisorEXT 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_glVertexArrayVertexBindingDivisorEXT GLuint
    v1 GLuint
    v2 GLuint
    v3

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

    -- glVertexArrayVertexBuffer ---------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glBindVertexBuffer.xhtml OpenGL 4.x>.
    glVertexArrayVertexBuffer
      :: MonadIO m
      => GLuint -- ^ @vaobj@.
      -> GLuint -- ^ @bindingindex@.
      -> GLuint -- ^ @buffer@.
      -> GLintptr -- ^ @offset@.
      -> GLsizei -- ^ @stride@.
      -> m ()
    glVertexArrayVertexBuffer :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> m ()
    glVertexArrayVertexBuffer GLuint
    v1 GLuint
    v2 GLuint
    v3 GLintptr
    v4 GLsizei
    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 -> GLintptr -> GLsizei -> IO ())
    -> GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()
    dyn887 FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
    ptr_glVertexArrayVertexBuffer GLuint
    v1 GLuint
    v2 GLuint
    v3 GLintptr
    v4 GLsizei
    v5

    {-# NOINLINE ptr_glVertexArrayVertexBuffer #-}
    ptr_glVertexArrayVertexBuffer :: FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
    ptr_glVertexArrayVertexBuffer :: FunPtr (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
    ptr_glVertexArrayVertexBuffer = IO
      (FunPtr
         (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
    -> FunPtr
         (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
    forall a. IO a -> a
    unsafePerformIO (IO
       (FunPtr
          (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
     -> FunPtr
          (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
    -> IO
         (FunPtr
            (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
    -> FunPtr
         (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ())
    forall a b. (a -> b) -> a -> b
    $ String
    -> IO
         (FunPtr
            (GLuint -> GLuint -> GLuint -> GLintptr -> GLsizei -> IO ()))
    forall a. String -> IO (FunPtr a)
    getCommand String
    "glVertexArrayVertexBuffer"

    -- glVertexArrayVertexBuffers --------------------------------------------------

    -- | Manual page for <https://www.opengl.org/sdk/docs/man4/html/glBindVertexBuffers.xhtml OpenGL 4.x>.
    glVertexArrayVertexBuffers
      :: MonadIO m
      => GLuint -- ^ @vaobj@.
      -> GLuint -- ^ @first@.
      -> GLsizei -- ^ @count@.
      -> Ptr GLuint -- ^ @buffers@.
      -> Ptr GLintptr -- ^ @offsets@.
      -> Ptr GLsizei -- ^ @strides@.
      -> m ()
    glVertexArrayVertexBuffers :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint
    -> GLsizei
    -> Ptr GLuint
    -> Ptr GLintptr
    -> Ptr GLsizei
    -> m ()
    glVertexArrayVertexBuffers GLuint
    v1 GLuint
    v2 GLsizei
    v3 Ptr GLuint
    v4 Ptr GLintptr
    v5 Ptr GLsizei
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLuint
       -> GLsizei
       -> Ptr GLuint
       -> Ptr GLintptr
       -> Ptr GLsizei
       -> IO ())
    -> GLuint
    -> GLuint
    -> GLsizei
    -> Ptr GLuint
    -> Ptr GLintptr
    -> Ptr GLsizei
    -> IO ()
    dyn894 FunPtr
      (GLuint
       -> GLuint
       -> GLsizei
       -> Ptr GLuint
       -> Ptr GLintptr
       -> Ptr GLsizei
       -> IO ())
    ptr_glVertexArrayVertexBuffers GLuint
    v1 GLuint
    v2 GLsizei
    v3 Ptr GLuint
    v4 Ptr GLintptr
    v5 Ptr GLsizei
    v6

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

    -- glVertexArrayVertexOffsetEXT ------------------------------------------------

    glVertexArrayVertexOffsetEXT
      :: MonadIO m
      => GLuint -- ^ @vaobj@.
      -> GLuint -- ^ @buffer@.
      -> GLint -- ^ @size@.
      -> GLenum -- ^ @type@ of type [VertexPointerType](Graphics-GL-Groups.html#VertexPointerType).
      -> GLsizei -- ^ @stride@.
      -> GLintptr -- ^ @offset@.
      -> m ()
    glVertexArrayVertexOffsetEXT :: forall (m :: * -> *).
    MonadIO m =>
    GLuint
    -> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> m ()
    glVertexArrayVertexOffsetEXT GLuint
    v1 GLuint
    v2 GLsizei
    v3 GLuint
    v4 GLsizei
    v5 GLintptr
    v6 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr
      (GLuint
       -> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> IO ())
    -> GLuint
    -> GLuint
    -> GLsizei
    -> GLuint
    -> GLsizei
    -> GLintptr
    -> IO ()
    dyn888 FunPtr
      (GLuint
       -> GLuint -> GLsizei -> GLuint -> GLsizei -> GLintptr -> IO ())
    ptr_glVertexArrayVertexOffsetEXT GLuint
    v1 GLuint
    v2 GLsizei
    v3 GLuint
    v4 GLsizei
    v5 GLintptr
    v6

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

    -- glVertexAttrib1d ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib1dv'.
    glVertexAttrib1d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> m ()
    glVertexAttrib1d :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
    glVertexAttrib1d 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_glVertexAttrib1d GLuint
    v1 GLdouble
    v2

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

    -- glVertexAttrib1dARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1dvARB'. This command is an alias for 'glVertexAttrib1d'.
    glVertexAttrib1dARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> m ()
    glVertexAttrib1dARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
    glVertexAttrib1dARB 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_glVertexAttrib1dARB GLuint
    v1 GLdouble
    v2

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

    -- glVertexAttrib1dNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1dvNV'. This command is an alias for 'glVertexAttrib1d'.
    glVertexAttrib1dNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> m ()
    glVertexAttrib1dNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLdouble -> m ()
    glVertexAttrib1dNV 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_glVertexAttrib1dNV GLuint
    v1 GLdouble
    v2

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

    -- glVertexAttrib1dv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib1dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @1@ element of type @GLdouble@.
      -> m ()
    glVertexAttrib1dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttrib1dv 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_glVertexAttrib1dv GLuint
    v1 Ptr GLdouble
    v2

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

    -- glVertexAttrib1dvARB --------------------------------------------------------

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

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

    -- glVertexAttrib1dvNV ---------------------------------------------------------

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

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

    -- glVertexAttrib1f ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib1fv'.
    glVertexAttrib1f
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> m ()
    glVertexAttrib1f :: forall (m :: * -> *). MonadIO m => GLuint -> GLfloat -> m ()
    glVertexAttrib1f GLuint
    v1 GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
    dyn896 FunPtr (GLuint -> GLfloat -> IO ())
    ptr_glVertexAttrib1f GLuint
    v1 GLfloat
    v2

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

    -- glVertexAttrib1fARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1fvARB'. This command is an alias for 'glVertexAttrib1f'.
    glVertexAttrib1fARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> m ()
    glVertexAttrib1fARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLfloat -> m ()
    glVertexAttrib1fARB GLuint
    v1 GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
    dyn896 FunPtr (GLuint -> GLfloat -> IO ())
    ptr_glVertexAttrib1fARB GLuint
    v1 GLfloat
    v2

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

    -- glVertexAttrib1fNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1fvNV'. This command is an alias for 'glVertexAttrib1f'.
    glVertexAttrib1fNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> m ()
    glVertexAttrib1fNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLfloat -> m ()
    glVertexAttrib1fNV GLuint
    v1 GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> IO ()) -> GLuint -> GLfloat -> IO ()
    dyn896 FunPtr (GLuint -> GLfloat -> IO ())
    ptr_glVertexAttrib1fNV GLuint
    v1 GLfloat
    v2

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

    -- glVertexAttrib1fv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib1fv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @1@ element of type @GLfloat@.
      -> m ()
    glVertexAttrib1fv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib1fv GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib1fv GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib1fvARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib1fv'.
    glVertexAttrib1fvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @1@ element of type @GLfloat@.
      -> m ()
    glVertexAttrib1fvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib1fvARB GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib1fvARB GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib1fvNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib1fv'.
    glVertexAttrib1fvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @1@ element of type @GLfloat@.
      -> m ()
    glVertexAttrib1fvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib1fvNV GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib1fvNV GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib1hNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1hvNV'.
    glVertexAttrib1hNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLhalfNV -- ^ @x@ of type @Half16NV@.
      -> m ()
    glVertexAttrib1hNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLhalfNV -> m ()
    glVertexAttrib1hNV GLuint
    v1 GLhalfNV
    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 -> GLhalfNV -> IO ()) -> GLuint -> GLhalfNV -> IO ()
    dyn897 FunPtr (GLuint -> GLhalfNV -> IO ())
    ptr_glVertexAttrib1hNV GLuint
    v1 GLhalfNV
    v2

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

    -- glVertexAttrib1hvNV ---------------------------------------------------------

    glVertexAttrib1hvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLhalfNV -- ^ @v@ pointing to @1@ element of type @Half16NV@.
      -> m ()
    glVertexAttrib1hvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
    glVertexAttrib1hvNV GLuint
    v1 Ptr GLhalfNV
    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 GLhalfNV -> IO ())
    -> GLuint -> Ptr GLhalfNV -> IO ()
    dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
    ptr_glVertexAttrib1hvNV GLuint
    v1 Ptr GLhalfNV
    v2

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

    -- glVertexAttrib1s ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib1sv'.
    glVertexAttrib1s
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> m ()
    glVertexAttrib1s :: forall (m :: * -> *). MonadIO m => GLuint -> GLshort -> m ()
    glVertexAttrib1s GLuint
    v1 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 -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
    dyn899 FunPtr (GLuint -> GLshort -> IO ())
    ptr_glVertexAttrib1s GLuint
    v1 GLshort
    v2

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

    -- glVertexAttrib1sARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1svARB'. This command is an alias for 'glVertexAttrib1s'.
    glVertexAttrib1sARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> m ()
    glVertexAttrib1sARB :: forall (m :: * -> *). MonadIO m => GLuint -> GLshort -> m ()
    glVertexAttrib1sARB GLuint
    v1 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 -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
    dyn899 FunPtr (GLuint -> GLshort -> IO ())
    ptr_glVertexAttrib1sARB GLuint
    v1 GLshort
    v2

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

    -- glVertexAttrib1sNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib1svNV'. This command is an alias for 'glVertexAttrib1s'.
    glVertexAttrib1sNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> m ()
    glVertexAttrib1sNV :: forall (m :: * -> *). MonadIO m => GLuint -> GLshort -> m ()
    glVertexAttrib1sNV GLuint
    v1 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 -> GLshort -> IO ()) -> GLuint -> GLshort -> IO ()
    dyn899 FunPtr (GLuint -> GLshort -> IO ())
    ptr_glVertexAttrib1sNV GLuint
    v1 GLshort
    v2

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

    -- glVertexAttrib1sv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib1sv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @1@ element of type @GLshort@.
      -> m ()
    glVertexAttrib1sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib1sv 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_glVertexAttrib1sv GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib1svARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib1sv'.
    glVertexAttrib1svARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @1@ element of type @GLshort@.
      -> m ()
    glVertexAttrib1svARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib1svARB 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_glVertexAttrib1svARB GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib1svNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib1sv'.
    glVertexAttrib1svNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @1@ element of type @GLshort@.
      -> m ()
    glVertexAttrib1svNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib1svNV 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_glVertexAttrib1svNV GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib2d ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib2dv'.
    glVertexAttrib2d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> m ()
    glVertexAttrib2d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> m ()
    glVertexAttrib2d 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_glVertexAttrib2d GLuint
    v1 GLdouble
    v2 GLdouble
    v3

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

    -- glVertexAttrib2dARB ---------------------------------------------------------

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

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

    -- glVertexAttrib2dNV ----------------------------------------------------------

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

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

    -- glVertexAttrib2dv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib2dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @2@ elements of type @GLdouble@.
      -> m ()
    glVertexAttrib2dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttrib2dv 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_glVertexAttrib2dv GLuint
    v1 Ptr GLdouble
    v2

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

    -- glVertexAttrib2dvARB --------------------------------------------------------

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

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

    -- glVertexAttrib2dvNV ---------------------------------------------------------

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

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

    -- glVertexAttrib2f ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib2fv'.
    glVertexAttrib2f
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> m ()
    glVertexAttrib2f :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> m ()
    glVertexAttrib2f GLuint
    v1 GLfloat
    v2 GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> IO ()
    dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib2f GLuint
    v1 GLfloat
    v2 GLfloat
    v3

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

    -- glVertexAttrib2fARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib2fvARB'. This command is an alias for 'glVertexAttrib2f'.
    glVertexAttrib2fARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> m ()
    glVertexAttrib2fARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> m ()
    glVertexAttrib2fARB GLuint
    v1 GLfloat
    v2 GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> IO ()
    dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib2fARB GLuint
    v1 GLfloat
    v2 GLfloat
    v3

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

    -- glVertexAttrib2fNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib2fvNV'. This command is an alias for 'glVertexAttrib2f'.
    glVertexAttrib2fNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> m ()
    glVertexAttrib2fNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> m ()
    glVertexAttrib2fNV GLuint
    v1 GLfloat
    v2 GLfloat
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> IO ()
    dyn229 FunPtr (GLuint -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib2fNV GLuint
    v1 GLfloat
    v2 GLfloat
    v3

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

    -- glVertexAttrib2fv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib2fv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @2@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib2fv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib2fv GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib2fv GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib2fvARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib2fv'.
    glVertexAttrib2fvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @2@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib2fvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib2fvARB GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib2fvARB GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib2fvNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib2fv'.
    glVertexAttrib2fvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @2@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib2fvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib2fvNV GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib2fvNV GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib2hNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib2hvNV'.
    glVertexAttrib2hNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLhalfNV -- ^ @x@ of type @Half16NV@.
      -> GLhalfNV -- ^ @y@ of type @Half16NV@.
      -> m ()
    glVertexAttrib2hNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLhalfNV -> GLhalfNV -> m ()
    glVertexAttrib2hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> IO ())
    -> GLuint -> GLhalfNV -> GLhalfNV -> IO ()
    dyn900 FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glVertexAttrib2hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3

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

    -- glVertexAttrib2hvNV ---------------------------------------------------------

    glVertexAttrib2hvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLhalfNV -- ^ @v@ pointing to @2@ elements of type @Half16NV@.
      -> m ()
    glVertexAttrib2hvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
    glVertexAttrib2hvNV GLuint
    v1 Ptr GLhalfNV
    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 GLhalfNV -> IO ())
    -> GLuint -> Ptr GLhalfNV -> IO ()
    dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
    ptr_glVertexAttrib2hvNV GLuint
    v1 Ptr GLhalfNV
    v2

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

    -- glVertexAttrib2s ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib2sv'.
    glVertexAttrib2s
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> m ()
    glVertexAttrib2s :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> m ()
    glVertexAttrib2s GLuint
    v1 GLshort
    v2 GLshort
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> IO ()
    dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib2s GLuint
    v1 GLshort
    v2 GLshort
    v3

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

    -- glVertexAttrib2sARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib2svARB'. This command is an alias for 'glVertexAttrib2s'.
    glVertexAttrib2sARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> m ()
    glVertexAttrib2sARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> m ()
    glVertexAttrib2sARB GLuint
    v1 GLshort
    v2 GLshort
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> IO ()
    dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib2sARB GLuint
    v1 GLshort
    v2 GLshort
    v3

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

    -- glVertexAttrib2sNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib2svNV'. This command is an alias for 'glVertexAttrib2s'.
    glVertexAttrib2sNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> m ()
    glVertexAttrib2sNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> m ()
    glVertexAttrib2sNV GLuint
    v1 GLshort
    v2 GLshort
    v3 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> IO ()
    dyn901 FunPtr (GLuint -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib2sNV GLuint
    v1 GLshort
    v2 GLshort
    v3

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

    -- glVertexAttrib2sv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib2sv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @2@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib2sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib2sv 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_glVertexAttrib2sv GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib2svARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib2sv'.
    glVertexAttrib2svARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @2@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib2svARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib2svARB 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_glVertexAttrib2svARB GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib2svNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib2sv'.
    glVertexAttrib2svNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @2@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib2svNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib2svNV 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_glVertexAttrib2svNV GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib3d ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib3dv'.
    glVertexAttrib3d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> m ()
    glVertexAttrib3d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttrib3d 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_glVertexAttrib3d GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4

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

    -- glVertexAttrib3dARB ---------------------------------------------------------

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

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

    -- glVertexAttrib3dNV ----------------------------------------------------------

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

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

    -- glVertexAttrib3dv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib3dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @3@ elements of type @GLdouble@.
      -> m ()
    glVertexAttrib3dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttrib3dv 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_glVertexAttrib3dv GLuint
    v1 Ptr GLdouble
    v2

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

    -- glVertexAttrib3dvARB --------------------------------------------------------

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

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

    -- glVertexAttrib3dvNV ---------------------------------------------------------

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

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

    -- glVertexAttrib3f ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib3fv'.
    glVertexAttrib3f
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glVertexAttrib3f :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
    glVertexAttrib3f GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib3f GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4

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

    -- glVertexAttrib3fARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib3fvARB'. This command is an alias for 'glVertexAttrib3f'.
    glVertexAttrib3fARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glVertexAttrib3fARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
    glVertexAttrib3fARB GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib3fARB GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4

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

    -- glVertexAttrib3fNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib3fvNV'. This command is an alias for 'glVertexAttrib3f'.
    glVertexAttrib3fNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> m ()
    glVertexAttrib3fNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> GLfloat -> m ()
    glVertexAttrib3fNV GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn733 FunPtr (GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib3fNV GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4

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

    -- glVertexAttrib3fv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib3fv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib3fv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib3fv GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib3fv GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib3fvARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib3fv'.
    glVertexAttrib3fvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib3fvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib3fvARB GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib3fvARB GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib3fvNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib3fv'.
    glVertexAttrib3fvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @3@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib3fvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib3fvNV GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib3fvNV GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib3hNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib3hvNV'.
    glVertexAttrib3hNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLhalfNV -- ^ @x@ of type @Half16NV@.
      -> GLhalfNV -- ^ @y@ of type @Half16NV@.
      -> GLhalfNV -- ^ @z@ of type @Half16NV@.
      -> m ()
    glVertexAttrib3hNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
    glVertexAttrib3hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    -> GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
    dyn903 FunPtr (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glVertexAttrib3hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    v4

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

    -- glVertexAttrib3hvNV ---------------------------------------------------------

    glVertexAttrib3hvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLhalfNV -- ^ @v@ pointing to @3@ elements of type @Half16NV@.
      -> m ()
    glVertexAttrib3hvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
    glVertexAttrib3hvNV GLuint
    v1 Ptr GLhalfNV
    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 GLhalfNV -> IO ())
    -> GLuint -> Ptr GLhalfNV -> IO ()
    dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
    ptr_glVertexAttrib3hvNV GLuint
    v1 Ptr GLhalfNV
    v2

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

    -- glVertexAttrib3s ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib3sv'.
    glVertexAttrib3s
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> GLshort -- ^ @z@.
      -> m ()
    glVertexAttrib3s :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> GLshort -> m ()
    glVertexAttrib3s GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
    dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib3s GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4

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

    -- glVertexAttrib3sARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib3svARB'. This command is an alias for 'glVertexAttrib3s'.
    glVertexAttrib3sARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> GLshort -- ^ @z@.
      -> m ()
    glVertexAttrib3sARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> GLshort -> m ()
    glVertexAttrib3sARB GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
    dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib3sARB GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4

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

    -- glVertexAttrib3sNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib3svNV'. This command is an alias for 'glVertexAttrib3s'.
    glVertexAttrib3sNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> GLshort -- ^ @z@.
      -> m ()
    glVertexAttrib3sNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> GLshort -> m ()
    glVertexAttrib3sNV GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> GLshort -> IO ()
    dyn904 FunPtr (GLuint -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib3sNV GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4

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

    -- glVertexAttrib3sv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib3sv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @3@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib3sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib3sv 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_glVertexAttrib3sv GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib3svARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib3sv'.
    glVertexAttrib3svARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @3@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib3svARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib3svARB 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_glVertexAttrib3svARB GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib3svNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib3sv'.
    glVertexAttrib3svNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @3@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib3svNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib3svNV 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_glVertexAttrib3svNV GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib4Nbv ----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nbv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
      -> m ()
    glVertexAttrib4Nbv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
    glVertexAttrib4Nbv 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_glVertexAttrib4Nbv GLuint
    v1 Ptr GLbyte
    v2

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

    -- glVertexAttrib4NbvARB -------------------------------------------------------

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

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

    -- glVertexAttrib4Niv ----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Niv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
      -> m ()
    glVertexAttrib4Niv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLsizei -> m ()
    glVertexAttrib4Niv GLuint
    v1 Ptr GLsizei
    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 GLsizei -> IO ())
    -> GLuint -> Ptr GLsizei -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLsizei -> IO ())
    ptr_glVertexAttrib4Niv GLuint
    v1 Ptr GLsizei
    v2

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

    -- glVertexAttrib4NivARB -------------------------------------------------------

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

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

    -- glVertexAttrib4Nsv ----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nsv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib4Nsv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib4Nsv 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_glVertexAttrib4Nsv GLuint
    v1 Ptr GLshort
    v2

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

    -- glVertexAttrib4NsvARB -------------------------------------------------------

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

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

    -- glVertexAttrib4Nub ----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nub
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLubyte -- ^ @x@.
      -> GLubyte -- ^ @y@.
      -> GLubyte -- ^ @z@.
      -> GLubyte -- ^ @w@.
      -> m ()
    glVertexAttrib4Nub :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glVertexAttrib4Nub 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_glVertexAttrib4Nub GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

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

    -- glVertexAttrib4NubARB -------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4Nub'.
    glVertexAttrib4NubARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLubyte -- ^ @x@.
      -> GLubyte -- ^ @y@.
      -> GLubyte -- ^ @z@.
      -> GLubyte -- ^ @w@.
      -> m ()
    glVertexAttrib4NubARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> m ()
    glVertexAttrib4NubARB 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_glVertexAttrib4NubARB GLuint
    v1 GLubyte
    v2 GLubyte
    v3 GLubyte
    v4 GLubyte
    v5

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

    -- glVertexAttrib4Nubv ---------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nubv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttrib4Nubv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttrib4Nubv 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_glVertexAttrib4Nubv GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttrib4NubvARB ------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4Nubv'.
    glVertexAttrib4NubvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLubyte -- ^ @v@ pointing to @4@ elements of type @GLubyte@.
      -> m ()
    glVertexAttrib4NubvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLubyte -> m ()
    glVertexAttrib4NubvARB 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_glVertexAttrib4NubvARB GLuint
    v1 Ptr GLubyte
    v2

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

    -- glVertexAttrib4Nuiv ---------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nuiv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLuint -- ^ @v@ pointing to @4@ elements of type @GLuint@.
      -> m ()
    glVertexAttrib4Nuiv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLuint -> m ()
    glVertexAttrib4Nuiv 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_glVertexAttrib4Nuiv GLuint
    v1 Ptr GLuint
    v2

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

    -- glVertexAttrib4NuivARB ------------------------------------------------------

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

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

    -- glVertexAttrib4Nusv ---------------------------------------------------------

    -- | 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>.
    glVertexAttrib4Nusv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLushort -- ^ @v@ pointing to @4@ elements of type @GLushort@.
      -> m ()
    glVertexAttrib4Nusv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLushort -> m ()
    glVertexAttrib4Nusv 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_glVertexAttrib4Nusv GLuint
    v1 Ptr GLushort
    v2

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

    -- glVertexAttrib4NusvARB ------------------------------------------------------

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

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

    -- glVertexAttrib4bv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4bv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLbyte -- ^ @v@ pointing to @4@ elements of type @GLbyte@.
      -> m ()
    glVertexAttrib4bv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLbyte -> m ()
    glVertexAttrib4bv 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_glVertexAttrib4bv GLuint
    v1 Ptr GLbyte
    v2

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

    -- glVertexAttrib4bvARB --------------------------------------------------------

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

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

    -- glVertexAttrib4d ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib4dv'.
    glVertexAttrib4d
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> GLdouble -- ^ @w@.
      -> m ()
    glVertexAttrib4d :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttrib4d 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_glVertexAttrib4d GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5

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

    -- glVertexAttrib4dARB ---------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib4dvARB'. This command is an alias for 'glVertexAttrib4d'.
    glVertexAttrib4dARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> GLdouble -- ^ @w@.
      -> m ()
    glVertexAttrib4dARB :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttrib4dARB 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_glVertexAttrib4dARB GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5

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

    -- glVertexAttrib4dNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib4dvNV'. This command is an alias for 'glVertexAttrib4d'.
    glVertexAttrib4dNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLdouble -- ^ @x@.
      -> GLdouble -- ^ @y@.
      -> GLdouble -- ^ @z@.
      -> GLdouble -- ^ @w@.
      -> m ()
    glVertexAttrib4dNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
    glVertexAttrib4dNV 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_glVertexAttrib4dNV GLuint
    v1 GLdouble
    v2 GLdouble
    v3 GLdouble
    v4 GLdouble
    v5

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

    -- glVertexAttrib4dv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4dv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLdouble -- ^ @v@ pointing to @4@ elements of type @GLdouble@.
      -> m ()
    glVertexAttrib4dv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLdouble -> m ()
    glVertexAttrib4dv 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_glVertexAttrib4dv GLuint
    v1 Ptr GLdouble
    v2

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

    -- glVertexAttrib4dvARB --------------------------------------------------------

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

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

    -- glVertexAttrib4dvNV ---------------------------------------------------------

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

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

    -- glVertexAttrib4f ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib4fv'.
    glVertexAttrib4f
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLfloat -- ^ @x@.
      -> GLfloat -- ^ @y@.
      -> GLfloat -- ^ @z@.
      -> GLfloat -- ^ @w@.
      -> m ()
    glVertexAttrib4f :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> m ()
    glVertexAttrib4f GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    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 -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    -> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()
    dyn907 FunPtr
      (GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ())
    ptr_glVertexAttrib4f GLuint
    v1 GLfloat
    v2 GLfloat
    v3 GLfloat
    v4 GLfloat
    v5

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

    -- glVertexAttrib4fARB ---------------------------------------------------------

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

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

    -- glVertexAttrib4fNV ----------------------------------------------------------

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

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

    -- glVertexAttrib4fv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4fv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib4fv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib4fv GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib4fv GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib4fvARB --------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4fv'.
    glVertexAttrib4fvARB
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib4fvARB :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib4fvARB GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib4fvARB GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib4fvNV ---------------------------------------------------------

    -- | This command is an alias for 'glVertexAttrib4fv'.
    glVertexAttrib4fvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLfloat -- ^ @v@ pointing to @4@ elements of type @GLfloat@.
      -> m ()
    glVertexAttrib4fvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLfloat -> m ()
    glVertexAttrib4fvNV GLuint
    v1 Ptr GLfloat
    v2 = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ FunPtr (GLuint -> Ptr GLfloat -> IO ())
    -> GLuint -> Ptr GLfloat -> IO ()
    dyn394 FunPtr (GLuint -> Ptr GLfloat -> IO ())
    ptr_glVertexAttrib4fvNV GLuint
    v1 Ptr GLfloat
    v2

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

    -- glVertexAttrib4hNV ----------------------------------------------------------

    -- | The vector equivalent of this command is 'glVertexAttrib4hvNV'.
    glVertexAttrib4hNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLhalfNV -- ^ @x@ of type @Half16NV@.
      -> GLhalfNV -- ^ @y@ of type @Half16NV@.
      -> GLhalfNV -- ^ @z@ of type @Half16NV@.
      -> GLhalfNV -- ^ @w@ of type @Half16NV@.
      -> m ()
    glVertexAttrib4hNV :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> m ()
    glVertexAttrib4hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    v4 GLhalfNV
    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 -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    -> GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ()
    dyn908 FunPtr
      (GLuint -> GLhalfNV -> GLhalfNV -> GLhalfNV -> GLhalfNV -> IO ())
    ptr_glVertexAttrib4hNV GLuint
    v1 GLhalfNV
    v2 GLhalfNV
    v3 GLhalfNV
    v4 GLhalfNV
    v5

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

    -- glVertexAttrib4hvNV ---------------------------------------------------------

    glVertexAttrib4hvNV
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLhalfNV -- ^ @v@ pointing to @4@ elements of type @Half16NV@.
      -> m ()
    glVertexAttrib4hvNV :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLhalfNV -> m ()
    glVertexAttrib4hvNV GLuint
    v1 Ptr GLhalfNV
    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 GLhalfNV -> IO ())
    -> GLuint -> Ptr GLhalfNV -> IO ()
    dyn898 FunPtr (GLuint -> Ptr GLhalfNV -> IO ())
    ptr_glVertexAttrib4hvNV GLuint
    v1 Ptr GLhalfNV
    v2

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

    -- glVertexAttrib4iv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4iv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLint -- ^ @v@ pointing to @4@ elements of type @GLint@.
      -> m ()
    glVertexAttrib4iv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLsizei -> m ()
    glVertexAttrib4iv GLuint
    v1 Ptr GLsizei
    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 GLsizei -> IO ())
    -> GLuint -> Ptr GLsizei -> IO ()
    dyn741 FunPtr (GLuint -> Ptr GLsizei -> IO ())
    ptr_glVertexAttrib4iv GLuint
    v1 Ptr GLsizei
    v2

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

    -- glVertexAttrib4ivARB --------------------------------------------------------

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

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

    -- glVertexAttrib4s ------------------------------------------------------------

    -- | 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>. The vector equivalent of this command is 'glVertexAttrib4sv'.
    glVertexAttrib4s
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> GLshort -- ^ @x@.
      -> GLshort -- ^ @y@.
      -> GLshort -- ^ @z@.
      -> GLshort -- ^ @w@.
      -> m ()
    glVertexAttrib4s :: forall (m :: * -> *).
    MonadIO m =>
    GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> m ()
    glVertexAttrib4s GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4 GLshort
    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 -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    -> GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()
    dyn909 FunPtr
      (GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ())
    ptr_glVertexAttrib4s GLuint
    v1 GLshort
    v2 GLshort
    v3 GLshort
    v4 GLshort
    v5

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

    -- glVertexAttrib4sARB ---------------------------------------------------------

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

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

    -- glVertexAttrib4sNV ----------------------------------------------------------

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

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

    -- glVertexAttrib4sv -----------------------------------------------------------

    -- | 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>.
    glVertexAttrib4sv
      :: MonadIO m
      => GLuint -- ^ @index@.
      -> Ptr GLshort -- ^ @v@ pointing to @4@ elements of type @GLshort@.
      -> m ()
    glVertexAttrib4sv :: forall (m :: * -> *). MonadIO m => GLuint -> Ptr GLshort -> m ()
    glVertexAttrib4sv 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_glVertexAttrib4sv GLuint
    v1 Ptr GLshort
    v2

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