caramia (empty) → 0.1.0.0

raw patch · 34 files changed

+35562/−0 lines, 34 filesdep +OpenGLRawdep +basedep +bytestringsetup-changed

Dependencies added: OpenGLRaw, base, bytestring, caramia, containers, sdl2, semigroups, text, transformers, vector

Files

• LICENSE +20/−0
• Setup.hs +2/−0
• caramia.cabal +96/−0
• demos/memory-info/Main.hs +23/−0
• demos/smoke-test/Main.hs +155/−0
• src/Caramia.hs +19/−0
• src/Caramia/Blend.hs +42/−0
• src/Caramia/Blend/Internal.hs +118/−0
• src/Caramia/Buffer.hs +411/−0
• src/Caramia/Buffer/Internal.hs +58/−0
• src/Caramia/Color.hs +100/−0
• src/Caramia/Context.hs +205/−0
• src/Caramia/Framebuffer.hs +302/−0
• src/Caramia/Framebuffer/Internal.hs +87/−0
• src/Caramia/ImageFormats.hs +18/−0
• src/Caramia/ImageFormats/Internal.hs +328/−0
• src/Caramia/Internal/ContextLocalData.hs +121/−0
• src/Caramia/Internal/FlextGL.hs +28572/−0
• src/Caramia/Internal/Lens.hs +22/−0
• src/Caramia/Internal/OpenGLCApi.hs +306/−0
• src/Caramia/Internal/OpenGLDebug.hs +116/−0
• src/Caramia/Math.hs +1647/−0
• src/Caramia/Memory.hs +64/−0
• src/Caramia/Prelude.hs +56/−0
• src/Caramia/Render.hs +455/−0
• src/Caramia/Render/Internal.hs +239/−0
• src/Caramia/Resource.hs +144/−0
• src/Caramia/Shader.hs +539/−0
• src/Caramia/Shader/Internal.hs +65/−0
• src/Caramia/Sync.hs +68/−0
• src/Caramia/Texture.hs +728/−0
• src/Caramia/Texture/Internal.hs +129/−0
• src/Caramia/VAO.hs +283/−0
• src/Caramia/VAO/Internal.hs +24/−0

@@ -0,0 +1,20 @@+Copyright (c) 2014 Mikko Juola++Permission is hereby granted, free of charge, to any person obtaining a copy+of this software and associated documentation files (the "Software"), to deal+in the Software without restriction, including without limitation the rights+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell+copies of the Software, and to permit persons to whom the Software is+furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in+all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN+THE SOFTWARE.+

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -0,0 +1,96 @@+name:                caramia+version:             0.1.0.0+synopsis:            Caramia real-time hardware-accelerated rendering library+homepage:            https://github.com/Noeda/caramia/+license:             MIT+license-file:        LICENSE+author:              Mikko Juola+copyright:           Copyright (c) 2014 Mikko Juola+maintainer:          mikjuo@gmail.com+category:            Graphics+build-type:          Simple+stability:           experimental+cabal-version:       >=1.10++description:+    (See README.md in the repository for a more comprehensive description).+    .+    These are low-level, but Haskelly bindings to OpenGL 3.3.+    .+    See 'giveContext' in "Caramia.Context" as this is the+    starting point for using this library.++source-repository head+    type:            git+    location:        https://github.com/Noeda/caramia.git++library+  exposed-modules:     Caramia+                       Caramia.Resource+                       Caramia.Context+                       Caramia.Buffer+                       Caramia.VAO+                       Caramia.Shader+                       Caramia.Math+                       Caramia.ImageFormats+                       Caramia.Render+                       Caramia.Texture+                       Caramia.Memory+                       Caramia.Framebuffer+                       Caramia.Color+                       Caramia.Blend+                       Caramia.Prelude+                       Caramia.Sync+                       Caramia.Internal.ContextLocalData+                       Caramia.Internal.OpenGLDebug+                       Caramia.Internal.OpenGLCApi+                       Caramia.Internal.Lens+                       Caramia.Internal.FlextGL+                       Caramia.Render.Internal+                       Caramia.Framebuffer.Internal+                       Caramia.Texture.Internal+                       Caramia.ImageFormats.Internal+                       Caramia.Shader.Internal+                       Caramia.Buffer.Internal+                       Caramia.Blend.Internal+                       Caramia.VAO.Internal++  ghc-options:         -Wall -fno-warn-name-shadowing++  build-depends:       base >=4.6 && <5.0.0.0+                      ,bytestring   >=0.10 && <1.0+                      ,containers   >=0.5 && <1.0+                      ,vector       >=0.10 && <1.0+                      ,text         >=0.9 && <2.0+                      ,transformers >=0.4 && <1.0+                      ,semigroups   >=0.15 && <1.0+                      ,OpenGLRaw    >=1.5 && <2.0+  hs-source-dirs:      src+  default-language:    Haskell2010++  if os(darwin)+    frameworks: OpenGL+    cpp-options:       -DMAC_OPENGL++-- This is just a dumping ground test that does stupid things. It's used to+-- check if things work at all.+test-suite smoke-test+  type:                exitcode-stdio-1.0+  main-is:             Main.hs+  ghc-options:         -Wall -fno-warn-name-shadowing -threaded+  hs-source-dirs:      demos/smoke-test+  build-depends:       base, caramia+                      ,sdl2 ==1.*+                      ,text >=0.9 && <2.0+  default-language:    Haskell2010++-- This one tests Caramia.Memory if it returns anything useful.+test-suite memory-info+  type:                exitcode-stdio-1.0+  main-is:             Main.hs+  ghc-options:         -Wall -fno-warn-name-shadowing -threaded+  hs-source-dirs:      demos/memory-info+  build-depends:       base, caramia+                      ,sdl2 ==1.*+  default-language:    Haskell2010+

@@ -0,0 +1,23 @@+module Main ( main ) where++import Caramia+import Graphics.UI.SDL+import Data.Bits+import Foreign.C.String++main :: IO ()+main = +    withCString "smoke-test" $ \cstr -> do+        _ <- glSetAttribute glAttrContextMajorVersion 3+        _ <- glSetAttribute glAttrContextMinorVersion 3+        _ <- glSetAttribute glAttrContextProfileMask glProfileCore+        _ <- glSetAttribute glAttrContextFlags glContextFlagDebug+        window <- createWindow cstr windowPosUndefined windowPosUndefined+                                    500 500+                                    (windowFlagOpenGL .|.+                                     windowFlagShown)+        _ <- glCreateContext window+        giveContext $ do+            putStrLn "Attempting to retrieve GPU memory information..."+            print =<< getMemoryInfo+

@@ -0,0 +1,155 @@+{-# LANGUAGE NoImplicitPrelude, OverloadedStrings #-}++module Main ( main ) where++import Caramia.Prelude+import Caramia+import Caramia.Math++import Graphics.UI.SDL+import qualified Graphics.UI.SDL as SDL+import Foreign.C.String+import Control.Exception+import Data.Bits+import qualified Data.Text as T+import System.Mem++main :: IO ()+main = do+    putStrLn $ "This will run the smoke test. The smoke test merely tests " <>+               "that " <>+               "things don't crash and burn when trying to heavily draw " <>+               "something."+    putStrLn $ "However with some drivers it can drive the computer to " <>+               "become unresponsive and difficult to recover without a " <>+               "reboot."+    putStrLn "Press enter to start the smoke test."+    _ <- getLine+    putStrLn "Running the smoke test..."+    bracket_ (SDL.init initFlagVideo)+             quit+             program++program :: IO ()+program =+    withCString "smoke-test" $ \cstr -> do+        _ <- glSetAttribute glAttrContextMajorVersion 3+        _ <- glSetAttribute glAttrContextMinorVersion 3+        _ <- glSetAttribute glAttrContextProfileMask glProfileCore+        _ <- glSetAttribute glAttrContextFlags glContextFlagDebug+        window <- createWindow cstr windowPosUndefined windowPosUndefined+                                    500 500+                                    (windowFlagOpenGL .|.+                                     windowFlagShown)+        _ <- glCreateContext window+        giveContext $ do+            -- Make some buffers.+            for_ [1..100 :: Integer] $ \idx -> do+                buf <- newBuffer defaultBufferCreation { size = 1024+                                                       , accessFlags =+                                                           WriteAccess }+                withMapping 0 500 WriteAccess buf $ \_ -> return ()+                runPendingFinalizers+                putStrLn $ "Buffer creation: " <> show idx <> "/100"++            -- Make some buffers but with much larger size and ReadAccess+            for_ [1..100 :: Integer] $ \idx -> do+                buf <- newBuffer defaultBufferCreation { size = 102400+                                                       , accessFlags =+                                                           ReadAccess }+                withMapping 23 50000 ReadAccess buf $ \_ -> return ()+                copy buf 100 buf 500 400+                runPendingFinalizers++                -- Compile a gazillion shaders+                sh1 <- newShader fragmentShaderSrc Fragment+                pipeline <- newPipeline [sh1]+                loc <- getUniformLocation "tutturuu" pipeline+                setUniform (transpose44 identity44)+                           loc+                           pipeline+                setUniform identity44+                           loc+                           pipeline+                setUniform identity33+                           loc+                           pipeline+                setUniform (transpose33 identity33)+                           loc+                           pipeline++                tex <- newTexture+                    textureSpecification+                    { topology = TexCube { widthCube = 299 }+                    , mipmapLevels = 5+                    , imageFormat = SRGB8_ALPHA8 }++                uploadToTexture+                    (uploading2D buf 28 28 FWord32 UBGRA)+                    {+                        cubeSide = NegativeX+                    }+                    tex++                -- Make some stupid VAOs+                vao <- newVAO+                vao2 <- newVAO+                sourceVertexData buf+                                 ((defaultSourcingType (5 :: Word16))+                                  { offset = 123+                                  , components = 3+                                  , stride = 19+                                  , attributeIndex = 3+                                  , integerMapping = True })+                                 vao2+                sourceVertexData buf+                                 ((defaultSourcingType (5 :: Word16))+                                  { offset = 123+                                  , components = 3+                                  , stride = 19+                                  , instancingDivisor = 19+                                  , attributeIndex = 3+                                  , normalize = True+                                  , integerMapping = False })+                                 vao+                draw drawCommand {+                     primitiveType = LineLoop+                   , primitivesVAO = vao2+                   , numIndices = 8+                   , numInstances = 213+                   , sourceData = PrimitivesWithIndices {+                       indexBuffer = buf+                     , indexOffset = 17+                     , indexType = IWord16 } }+                     defaultDrawParams {+                     pipeline = pipeline+                     }++                fbuf <- newFramebuffer [ (ColorAttachment 3+                                       , frontTextureTarget tex) ]+                draw drawCommand {+                     primitiveType = LineLoop+                   , primitivesVAO = vao2+                   , numIndices = 8+                   , numInstances = 999+                   , sourceData = Primitives {+                       firstIndex = 3 } }+                     defaultDrawParams {+                     pipeline = pipeline+                   , targetFramebuffer = fbuf+                     }+                putStrLn $ "Drawing: " <> show idx <> "/100"++            performGC+            runPendingFinalizers+            return ()++fragmentShaderSrc :: T.Text+fragmentShaderSrc = "" <>+    "#version 330\n" <>+    "uniform mat3 tutturuu;\n" <>+    "layout (location = 0) out vec4 colorOut;\n" <>+    "void main() {\n" <>+    "    colorOut = vec4(tutturuu[0][0]);\n" <>+    "}\n"+

@@ -0,0 +1,19 @@+-- | This module re-exports most Caramia modules.++module Caramia+    ( module Ex )+    where++import Caramia.Resource as Ex+import Caramia.Context as Ex+import Caramia.Buffer as Ex+import Caramia.VAO as Ex+import Caramia.Shader as Ex+import Caramia.Render as Ex+import Caramia.ImageFormats as Ex+import Caramia.Texture as Ex+import Caramia.Memory as Ex+import Caramia.Framebuffer as Ex+import Caramia.Color as Ex+import Caramia.Blend as Ex+

@@ -0,0 +1,42 @@+-- | Blending stuff.+--+-- <https://www.opengl.org/wiki/Blending>+--++module Caramia.Blend+    (+    -- * Data types+      BlendSpec(..)+    , BlendEquation(..)+    , BlendFunc(..)+    -- * Pre-defined blending specs+    , preMultipliedAlpha+    , nopBlend )+    where++--import Caramia.Prelude+import Caramia.Blend.Internal+import Caramia.Color++preMultipliedAlpha :: BlendSpec+preMultipliedAlpha = BlendSpec+    { srcColorFunc = BFOne+    , srcAlphaFunc = BFOne+    , dstColorFunc = BFOneMinusSrcAlpha+    , dstAlphaFunc = BFOneMinusSrcAlpha+    , colorEquation = BEAdd+    , alphaEquation = BEAdd+    , blendColor = rgba 1 1 1 1 }++-- | Blending that doesn't do anything special; just copies the source pixel to+-- destination.+nopBlend :: BlendSpec+nopBlend = BlendSpec+    { srcColorFunc = BFOne+    , srcAlphaFunc = BFOne+    , dstColorFunc = BFZero+    , dstAlphaFunc = BFZero+    , colorEquation = BEAdd+    , alphaEquation = BEAdd+    , blendColor = rgba 1 1 1 1 }+

@@ -0,0 +1,118 @@+{-# LANGUAGE RecordWildCards, NoImplicitPrelude, DeriveDataTypeable #-}++module Caramia.Blend.Internal where++import Caramia.Prelude++import Caramia.Internal.OpenGLCApi+import Caramia.Color+import Control.Exception+import Foreign+import Foreign.C.Types++-- | Describes which equation to use in blending.+--+-- See `glBlendEquation` in OpenGL documentation.+data BlendEquation =+    BEAdd+  | BESubtract+  | BEReverseSubtract+  | BEMin+  | BEMax+  deriving ( Eq, Ord, Show, Read, Typeable )++-- | Describes the arithmetic to use in blending.+--+-- See `glBlendFunc` in OpenGL documentation.+data BlendFunc =+    BFZero+  | BFOne+  | BFSrcColor+  | BFOneMinusSrcColor+  | BFDstColor+  | BFOneMinusDstColor+  | BFSrcAlpha+  | BFOneMinusSrcAlpha+  | BFDstAlpha+  | BFOneMinusDstAlpha+  | BFConstantColor+  | BFOneMinusConstantColor+  | BFConstantAlpha+  | BFOneMinusConstantAlpha+  | BFSrcAlphaSaturate+  deriving ( Eq, Ord, Show, Read, Typeable )++toConstantBE :: BlendEquation -> GLenum+toConstantBE BEAdd = gl_FUNC_ADD+toConstantBE BESubtract = gl_FUNC_SUBTRACT+toConstantBE BEReverseSubtract = gl_FUNC_REVERSE_SUBTRACT+toConstantBE BEMin = gl_MIN+toConstantBE BEMax = gl_MAX++toConstantBF :: BlendFunc -> GLenum+toConstantBF BFZero = gl_ZERO+toConstantBF BFOne = gl_ONE+toConstantBF BFSrcColor = gl_SRC_COLOR+toConstantBF BFOneMinusSrcColor = gl_ONE_MINUS_SRC_COLOR+toConstantBF BFDstColor = gl_DST_COLOR+toConstantBF BFOneMinusDstColor = gl_ONE_MINUS_DST_COLOR+toConstantBF BFSrcAlpha = gl_SRC_ALPHA+toConstantBF BFOneMinusSrcAlpha = gl_ONE_MINUS_SRC_ALPHA+toConstantBF BFDstAlpha = gl_DST_ALPHA+toConstantBF BFOneMinusDstAlpha = gl_ONE_MINUS_DST_ALPHA+toConstantBF BFConstantColor = gl_CONSTANT_COLOR+toConstantBF BFOneMinusConstantColor = gl_ONE_MINUS_CONSTANT_COLOR+toConstantBF BFConstantAlpha = gl_CONSTANT_ALPHA+toConstantBF BFOneMinusConstantAlpha = gl_ONE_MINUS_CONSTANT_ALPHA+toConstantBF BFSrcAlphaSaturate = gl_SRC_ALPHA_SATURATE++-- | Captures the blending parameters.+data BlendSpec = BlendSpec+    { alphaEquation :: !BlendEquation+    , colorEquation :: !BlendEquation+    , srcColorFunc  :: !BlendFunc+    , srcAlphaFunc  :: !BlendFunc+    , dstColorFunc  :: !BlendFunc+    , dstAlphaFunc  :: !BlendFunc+    , blendColor    :: !Color }+    deriving ( Eq, Ord, Show, Read, Typeable )++setBlendings :: BlendSpec -> IO ()+setBlendings (BlendSpec{..}) = do+    glBlendFuncSeparate (toConstantBF srcColorFunc)+                        (toConstantBF dstColorFunc)+                        (toConstantBF srcAlphaFunc)+                        (toConstantBF dstAlphaFunc)+    glBlendEquationSeparate (toConstantBE colorEquation)+                            (toConstantBE alphaEquation)+    glBlendColor (CFloat $ viewRed blendColor)+                 (CFloat $ viewGreen blendColor)+                 (CFloat $ viewBlue blendColor)+                 (CFloat $ viewAlpha blendColor)++withBlendings :: BlendSpec+              -> IO a+              -> IO a+withBlendings spec@(BlendSpec {..}) action = do+    old_be_color <- gi gl_BLEND_EQUATION_RGB+    old_be_alpha <- gi gl_BLEND_EQUATION_ALPHA+    old_src_color <- gi gl_BLEND_SRC_RGB+    old_src_alpha <- gi gl_BLEND_SRC_ALPHA+    old_dst_color <- gi gl_BLEND_DST_RGB+    old_dst_alpha <- gi gl_BLEND_DST_ALPHA+    allocaArray 4 $ \color_ptr -> do+        glGetFloatv gl_BLEND_COLOR color_ptr+        r <- peekElemOff color_ptr 0+        g <- peekElemOff color_ptr 1+        b <- peekElemOff color_ptr 2+        a <- peekElemOff color_ptr 3+        finally (setBlendings spec >> action) $ do+            glBlendColor r g b a+            glBlendFuncSeparate old_src_color+                                old_dst_color+                                old_src_alpha+                                old_dst_alpha+            glBlendEquationSeparate old_be_color+                                    old_be_alpha++

@@ -0,0 +1,411 @@+-- | Buffer objects.+--+-- These are chunks of memory (typically) kept on the GPU.+--+-- <https://www.opengl.org/wiki/Buffer_Object>+--++-- TODO: Add glBufferStorage based implementation.+-- OpenGLRaw (1.4.0.0) doesn't have this yet.++{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-}++module Caramia.Buffer+    ( -- * Creation+      newBuffer+    , Buffer()+    , AccessFrequency(..)+    , AccessNature(..)+    , AccessFlags(..)+    , MapFlag(..)+    , BufferCreation(..)+    , defaultBufferCreation+      -- * Invalidation+    , invalidateBuffer+      -- * Manipulation+    , map+    , map2+    , unmap+    , copy+    , withMapping+    , withMapping2+    , uploadVector+      -- * Views+    , viewSize+    , viewAllowedMappings+      -- * Exceptions+    , BufferCorruption(..)+    )+    where++import Caramia.Prelude hiding ( map )+import Caramia.Buffer.Internal++import Caramia.Resource+import Caramia.Internal.OpenGLCApi++import qualified Data.Vector.Storable as V+import qualified Data.Set as S++import Data.Bits+import Foreign+import Control.Exception++-- | The frequency of access to a buffer.+--+-- These correspond to the OpenGL access frequency hints. You can look for them+-- in the OpenGL specification or check this link:+--+-- <https://www.opengl.org/wiki/GLAPI/glBufferData>+data AccessFrequency =+    Stream+  | Static+  | Dynamic+  deriving ( Eq, Ord, Show, Read )++-- | The nature of access to a buffer.+--+-- These correspond to the OpenGL access nature hints. You can look for them+-- in the OpenGL specification or check this link:+--+-- <https://www.opengl.org/wiki/GLAPI/glBufferData>+data AccessNature =+    Draw+  | Read+  | Copy+  deriving ( Eq, Ord, Show, Read )++canMapWith :: AccessFlags -> AccessFlags -> Bool+canMapWith ReadWriteAccess _ = True+canMapWith WriteAccess WriteAccess = True+canMapWith WriteAccess _ = False+canMapWith ReadAccess ReadAccess = True+canMapWith ReadAccess _ = False+canMapWith NoAccess NoAccess = True+canMapWith NoAccess _ = False++toConstant :: AccessFrequency -> AccessNature -> GLuint+toConstant Stream Draw = gl_STREAM_DRAW+toConstant Stream Read = gl_STREAM_READ+toConstant Stream Copy = gl_STREAM_COPY+toConstant Static Draw = gl_STATIC_DRAW+toConstant Static Read = gl_STATIC_READ+toConstant Static Copy = gl_STATIC_COPY+toConstant Dynamic Draw = gl_DYNAMIC_DRAW+toConstant Dynamic Read = gl_DYNAMIC_READ+toConstant Dynamic Copy = gl_DYNAMIC_COPY++toConstantF :: AccessFlags -> GLbitfield+toConstantF ReadAccess      = gl_MAP_READ_BIT+toConstantF WriteAccess     = gl_MAP_WRITE_BIT+toConstantF ReadWriteAccess = gl_MAP_READ_BIT .|. gl_MAP_WRITE_BIT+toConstantF NoAccess        = 0++toConstantMF :: S.Set MapFlag -> GLbitfield+toConstantMF ss+    | S.null ss = 0+    | otherwise =+        if UnSynchronized `S.member` ss+          then gl_MAP_UNSYNCHRONIZED_BIT+          else 0++-- | This data describes how a buffer should behave and what operations can be+-- done with it.+--+-- Accurate description can improve performance.+--+-- For forwards compatibility, it is recommended to use+-- `defaultBufferCreation` and then set the fields you want to change.+data BufferCreation = BufferCreation+    { accessHints :: !(AccessFrequency, AccessNature) -- ^ Hints on how the+                                                      --   buffer will be used.++    , size        :: !Int               -- ^ How large the buffer should be, in+                                        --   bytes.+    , initialData ::+        !(Maybe (Ptr ()))               -- ^ The initial data to be copied to+                                        -- the buffer. Can be `Nothing` in+                                        -- which case the initial contents are+                                        -- undefined.++    , accessFlags :: !AccessFlags       -- ^ What kind of mapping access is+                                        --   allowed. See `map`.+    }++-- | The default buffer creation flags.+--+-- The default attempts to give you the most general (and possibly slowest)+-- buffer. Both read and write access are allowed.+--+-- Default size is 0 which will make `newBuffer` fail if you don't set it.+defaultBufferCreation :: BufferCreation+defaultBufferCreation = BufferCreation {+    accessHints = (Dynamic, Draw)+  , size        = 0+  , initialData = Nothing+  , accessFlags = ReadWriteAccess }++-- | Creates a new buffer according to `BufferCreation` specification.+newBuffer :: BufferCreation+          -> IO Buffer+newBuffer creation+    | size creation <= 0 =+        error "newBuffer: size must be positive."+    | otherwise = mask_ $ do+        resource <-+            newResource createBuffer+                        (\(Buffer_ bufname) -> mglDeleteBuffer bufname)+                        (return ())+        initial_status <- newIORef BufferStatus { mapped = False }+        oi <- atomicModifyIORef' bufferOrdIndex $ \old -> ( old+1, old )+        return Buffer { resource = resource+                      , status = initial_status+                      , viewAllowedMappings = accessFlags creation+                      , viewSize = size creation+                      , ordIndex = oi }+  where+    initial_data = fromMaybe nullPtr (assertNotNull <$> initialData creation)+    safe_size = safeFromIntegral $ size creation+    (usage, access) = accessHints creation++    createBuffer = do+        buf <- mglGenBuffer+        mglNamedBufferData buf+                           safe_size+                           (castPtr initial_data)+                           (toConstant usage access)+        return (Buffer_ buf)++    assertNotNull ptr+        | ptr == nullPtr = error "newBuffer: initial data is a null pointer."+        | otherwise = ptr++-- | Same as `map` but allows more control over mapping.+--+-- @ map = map2 [] @+map2 :: S.Set MapFlag+     -> Int+     -> Int+     -> AccessFlags+     -> Buffer+     -> IO (Ptr ())+map2 map_flags offset num_bytes access_flags buffer+    -- a lot of this implementation is just error checking...++    -- check that offset/num_bytes makes sense+    | offset < 0 || offset >= viewSize buffer ||+      num_bytes <= 0 ||+      offset + num_bytes > viewSize buffer =+          error $ "map: requested mapping has invalid offset " <>+                  "and/or range. " <>+                  "Buffer size is " <> show (viewSize buffer) <> ", " <>+                  "requested mapping was [" <> show offset <> ".." <>+                  show (offset + num_bytes - 1) <> "]."+    | otherwise =+    withResource (resource buffer) $ \(Buffer_ buf) -> mask_ $ do+        bufstatus <- readIORef (status buffer)+        -- make sure buffer has not been alreayd mapped+        when (mapped bufstatus) $+            error "map: buffer is already mapped."+        -- can we really map with these access flags+        unless (canMapWith (viewAllowedMappings buffer) access_flags) $+            error $ "map: attempted to map buffer with " <> show access_flags+                 <> ", allowed mappings are: " <>+                 show (viewAllowedMappings buffer)++        ptr <- mglMapNamedBufferRange+            buf+            (safeFromIntegral offset)+            (safeFromIntegral num_bytes)+            (toConstantF access_flags .|. toConstantMF map_flags)++        -- what if it just mysteriously fails? I think we caught most, if not+        -- all user errors so any other error should be some rare condition+        -- depending on external factors. I hope.+        when (ptr == nullPtr) $+            -- I am so sorry for any user who sees this error message.+            error $ "map: for some reason, mapping a buffer failed. " <>+                    "You might want to check OpenGL debug log."++        atomicModifyIORef' (status buffer) $ \old ->+            ( old { mapped = True }, () )++        return ptr++-- | Maps (part) of a buffer to system memory space.+--+-- The mapping is valid until the buffer is garbage collected (in which case+-- the mapping is automatically unmapped) or when `unmap` is called on the+-- buffer.+--+-- You can not have two mappings going on at the same time.+map :: Int         -- ^ Offset, in bytes, from start of the buffer from where+                   --   to map.+    -> Int         -- ^ How many bytes to map.+    -> AccessFlags -- ^ What access is allowed in the mapping.+    -> Buffer+    -> IO (Ptr ())+map = map2 S.empty++-- | Exception that is thrown from `unmap` when buffer corruption is detected.+--+-- Corruption can happen due to external factors and is system-specific.+data BufferCorruption = BufferCorruption Buffer+                        deriving ( Eq, Typeable )++instance Show BufferCorruption where+    show _ = "BufferCorruption <#Buffer>"++instance Exception BufferCorruption++-- | Unmaps a buffer.+--+-- Does nothing if the buffer was not mapped.+--+-- It is possible that the mapping become corrupt during the time it was+-- mapped. If there was corruption, `BufferCorruption` is thrown in this call.+--+-- Corruption means that the contents of the buffer are now undefined.+unmap :: Buffer -> IO ()+unmap buffer = do+    bufstatus <- readIORef (status buffer)+    when (mapped bufstatus) $+        withResource (resource buffer) $ \(Buffer_ buf) -> mask_ $ do+            result <- mglUnmapNamedBuffer buf+            when (fromIntegral result == gl_FALSE) $+                throwIO $ BufferCorruption buffer+            atomicModifyIORef' (status buffer) $ \old ->+                ( old { mapped = False }, () )++-- | Same as `withMapping` but with map flags.+--+-- See `map2`.+withMapping2 :: S.Set MapFlag+             -> Int+             -> Int+             -> AccessFlags+             -> Buffer+             -> (Ptr () -> IO a)+             -> IO a+withMapping2 map_flags offset num_bytes access_flags buffer action =+    mask $ \restore -> do+        ptr <- map2 map_flags offset num_bytes access_flags buffer+        did_it_work <- try $ restore $ action ptr+        did_unmapping_work <- try $ unmap buffer+        case did_it_work of+            Left exc -> throwIO (exc :: SomeException)+            Right result ->+                case did_unmapping_work of+                    Left no -> throwIO (no :: BufferCorruption)+                    Right () -> return result++-- | A convenience function over map/unmap that automatically unmaps the buffer+-- when done (even in the case of exceptions).+--+-- The arguments to this function are the same as for `map`, except for extra+-- action argument.+--+-- This calls `unmap` which means it can throw `BufferCorruption` when the+-- action is done.+--+-- There is a rare case that can happen if your action throws an exception AND+-- the unmapping throws an exception. Which exception is propagated upwards?+-- If this happens, this call silences `BufferCorruption` exception and+-- re-throws the user exception. This unfortunately means there is no way to+-- know if the buffer was corrupted if you threw an exception inside the+-- action.+withMapping :: Int+            -> Int+            -> AccessFlags+            -> Buffer+            -> (Ptr () -> IO a)   -- ^ The pointer is valid during this action.+            -> IO a+withMapping = withMapping2 S.empty++-- | A convenience function to upload a storable vector to a buffer.+--+-- The buffer must be in an unmapped state and must be write-mappable.+uploadVector :: V.Storable a+             => V.Vector a    -- ^ The vector from which to pull data.+             -> Int           -- ^ Offset, in bytes, to which point in the+                              --   buffer to copy the data.+             -> Buffer+             -> IO ()+uploadVector vec offset buffer =+    V.unsafeWith vec $ \src_ptr ->+        withMapping offset byte_size WriteAccess buffer $ \tgt_ptr ->+            copyBytes tgt_ptr (castPtr src_ptr) byte_size+  where+    byte_size = V.length vec * sizeOf (undefined `asTypeOf` (vec V.! 0))++-- | Copies bytes from one buffer to another.+--+-- The buffers must not be mapped; however this call can bypass the access+-- flags set in `newBuffer`. That is, you can copy data even to a buffer that+-- was set as not writable or copy from a buffer that was set as not readable.+--+-- This is faster than mapping both buffers and then doing a memcpy() style+-- copying in system memory because this call does not require a round-trip to+-- the driver.+--+-- You can use the same buffer for both destination and source but the copying+-- area may not overlap.+copy :: Buffer      -- ^ Destination buffer.+     -> Int         -- ^ Offset in destination buffer.+     -> Buffer      -- ^ Source buffer.+     -> Int         -- ^ Offset in source buffer.+     -> Int         -- ^ How many bytes to copy.+     -> IO ()+copy dst_buffer dst_offset src_buffer src_offset num_bytes+    | dst_offset < 0 ||+      src_offset < 0 ||+      dst_offset + num_bytes > viewSize dst_buffer ||+      src_offset + num_bytes > viewSize src_buffer ||+      num_bytes < 0 =+          error "copy: invalid offsets/byte sizes to make a buffer copy."+    | overlaps = error "copy: copying area overlaps."+    | otherwise =+        withResource (resource dst_buffer) $ \(Buffer_ dst) ->+            withResource (resource src_buffer) $ \(Buffer_ src) -> do+                dst_status <- readIORef (status dst_buffer)+                when (mapped dst_status) $+                    error "copy: destination buffer is mapped."+                src_status <- readIORef (status src_buffer)+                when (mapped src_status) $+                    error "copy: source buffer is mapped."++                when (num_bytes > 0) $+                    mglNamedCopyBufferSubData+                        src+                        dst+                        (safeFromIntegral src_offset)+                        (safeFromIntegral dst_offset)+                        (safeFromIntegral num_bytes)++  where+    overlaps+        | dst_buffer /= src_buffer = False+        | dst_offset + num_bytes - 1 < src_offset ||+          dst_offset > src_offset + num_bytes - 1 = False+        | otherwise = True++-- | Invalidates the contents of a buffer.+--+-- This is you saying: \"I don't care what's in this buffer anymore. You can do+-- whatever you want with it.\".+--+-- The data may be gone or it may not be gone. Use this as a hint to the+-- implementation that you will not use the _current_ contents of the buffer+-- anymore.+--+-- This requires the OpenGL extension \"GL_ARB_invalidate_subdata\" but if this+-- extension is not present, then this simply does nothing.+--+-- See <https://www.opengl.org/wiki/Buffer_Object#Invalidation>.+invalidateBuffer :: Buffer -> IO ()+invalidateBuffer buf = do+    has_it <- has_GL_ARB_invalidate_subdata+    when has_it $+        withResource (resource buf) $ \(Buffer_ name) ->+            glInvalidateBufferData name+

@@ -0,0 +1,58 @@+{-# LANGUAGE NoImplicitPrelude, ViewPatterns, DeriveDataTypeable #-}++module Caramia.Buffer.Internal+    ( Buffer(..)+    , Buffer_(..)+    , BufferStatus(..)+    , AccessFlags(..)+    , MapFlag(..)+    , bufferOrdIndex )+    where++import Caramia.Prelude++import Caramia.Resource+import Caramia.Internal.OpenGLCApi+import System.IO.Unsafe++-- | Buffer data type.+data Buffer = Buffer+    { resource   :: !(Resource Buffer_)+    , status     :: !(IORef BufferStatus)+    , viewAllowedMappings :: !AccessFlags -- ^ Returns the allowed mappings.+    , viewSize   :: !Int -- ^ Returns the size of the buffer, in bytes.+    , ordIndex   :: !Int+    }++bufferOrdIndex :: IORef Int+bufferOrdIndex = unsafePerformIO $ newIORef 0+{-# NOINLINE bufferOrdIndex #-}++instance Ord Buffer where+    (ordIndex -> o1) `compare` (ordIndex -> o2) = o1 `compare` o2++data BufferStatus = BufferStatus+    { mapped :: !Bool }++instance Eq Buffer where+    (resource -> res1) == (resource -> res2) = res1 == res2++newtype Buffer_ = Buffer_ GLuint++-- | Describes a style of mapping.+data AccessFlags =+    ReadAccess      -- ^ The mapping can be read from.+  | WriteAccess     -- ^ The mapping can be written to.+  | ReadWriteAccess -- ^ Both reading and writing can be done.+  | NoAccess        -- ^ No access; you cannot map the buffer at all after+                    --   creation.+  deriving ( Eq, Ord, Show, Read )++-- | Additional mapping flags.+data MapFlag =+    UnSynchronized        -- ^ Map the buffer without synchronization.+                          --   You will have to use synchronization primitives+                          --   to make sure you and OpenGL won't be using+                          --   the buffer at the same time.+  deriving ( Eq, Ord, Show, Read, Typeable )+

@@ -0,0 +1,100 @@+-- | Color handling.+--++{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-}++module Caramia.Color+    (+    -- * Types+      Color()+    -- * Constructing colors+    , rgba+    -- * Lenses+    , rgbaL+    , redL+    , greenL+    , blueL+    , alphaL+    -- * Views+    , viewRgba+    , viewRed+    , viewGreen+    , viewBlue+    , viewAlpha )+    where++import Caramia.Prelude+import Foreign.Storable+import Foreign.Ptr+import Caramia.Internal.Lens++-- | The color data type.+--+-- This data type says nothing about the color space these values are in. The+-- color space depends on the usage; for example, a framebuffer with sRGB+-- textures attached uses sRGB color space in these color values.+data Color = Color+    { viewRed   :: !Float+    , viewGreen :: !Float+    , viewBlue  :: !Float+    , viewAlpha :: !Float+    }+    deriving ( Eq, Ord, Show, Read, Typeable )++-- | Construct a color from rgba values.+rgba :: Float -> Float -> Float -> Float -> Color+rgba = Color+{-# INLINE rgba #-}++-- | View rgba in a tuple.+viewRgba :: Color -> (Float, Float, Float, Float)+viewRgba (Color r g b a) = (r, g, b, a)+{-# INLINE viewRgba #-}++-- | Lens to all components.+rgbaL :: Lens' Color (Float, Float, Float, Float)+rgbaL = lens viewRgba (\old (r, g, b, a) ->+    old { viewRed = r+        , viewGreen = g+        , viewBlue = b+        , viewAlpha = a })++-- | Lens to red component.+redL :: Lens' Color Float+redL = lens viewRed (\old new -> old { viewRed = new })++-- | Lens to green component.+greenL :: Lens' Color Float+greenL = lens viewGreen (\old new -> old { viewGreen = new })++-- | Lens to blue component.+blueL :: Lens' Color Float+blueL = lens viewBlue (\old new -> old { viewBlue = new })++-- | Lens to alpha component.+alphaL :: Lens' Color Float+alphaL = lens viewAlpha (\old new -> old { viewAlpha = new })++instance Storable Color where+    sizeOf _ = sizeOf (undefined :: Float) * 4+    alignment _ = alignment (undefined :: Float) * 4+    peek ptr = do+        r <- peekElemOff cptr 0 :: IO Float+        g <- peekElemOff cptr 1 :: IO Float+        b <- peekElemOff cptr 2 :: IO Float+        a <- peekElemOff cptr 3 :: IO Float+        return $ Color r g b a+      where+        cptr = castPtr ptr :: Ptr Float+    {-# INLINE peek #-}++    poke ptr (Color r g b a) = do+        pokeElemOff cptr 0 r+        pokeElemOff cptr 1 g+        pokeElemOff cptr 2 b+        pokeElemOff cptr 3 a+      where+        cptr = castPtr ptr :: Ptr Float+    {-# INLINE poke #-}++

@@ -0,0 +1,205 @@+-- | This module manages OpenGL contexts in Caramia.+--+-- Caramia does not actually have any functionality about creating OpenGL+-- contexts. You need to tell it about them with this module.+--+-- `giveContext` is the most important function in this module. You also want+-- to `runPendingFinalizers` regularly to make sure OpenGL resources are+-- garbage collected.+--++{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables, DeriveDataTypeable #-}+{-# LANGUAGE CPP, LambdaCase #-}++module Caramia.Context+    (+    -- * Running with an OpenGL context+      giveContext+    -- * Context IDs+    , currentContextID+    , ContextID+    -- * Finalization+    , runPendingFinalizers+    , scheduleFinalizer+    -- * Context local data+    , storeContextLocalData+    , retrieveContextLocalData+    -- * Exceptions+    , TooOldOpenGL(..) )+    where++import Caramia.Prelude+import Caramia.Internal.ContextLocalData+import Caramia.Internal.OpenGLDebug+import Caramia.Internal.FlextGL++import Control.Concurrent+import Control.Exception+import System.IO.Unsafe+import System.Environment+import Graphics.Rendering.OpenGL.Raw.GetProcAddress+import Foreign.Ptr+import Foreign.Storable+import Foreign.Marshal.Alloc++import qualified Data.Map.Strict as M+import qualified Data.IntMap.Strict as IM++-- | An exception that is thrown when the OpenGL version is too old for this+-- library.+data TooOldOpenGL = TooOldOpenGL+                    { wantedVersion :: (Int, Int) -- ^ The OpenGL version this+                                                  --   library needs.+                    , reportedVersion :: (Int, Int)+                    -- ^ The OpenGL version reported by current OpenGL+                    --   context.+                    }+                    deriving ( Eq, Show, Read, Typeable )++instance Exception TooOldOpenGL++-- | Tell Caramia the current thread has an OpenGL context active.+--+-- When the given IO action returns, Caramia will think that the OpenGL context+-- is now gone. It is probably best to actually close the context because this+-- also means OpenGL finalizers will not be run (Caramia thinks they were all+-- released when the OpenGL context went away).+--+-- The context in the IO action is referred to as \'Caramia context\' in this+-- documentation to distinguish it from OpenGL context.+--+-- If the environment variable \'CARAMIA_OPENGL_DEBUG\' is set, then, if+-- \'GL_KHR_debug\' extension is supported, OpenGL debug output is written.+-- Note that you might need a debug OpenGL context for there to be any+-- messages.+--+-- Throws `TooOldOpenGL` if the code detects a context that does not provide+-- OpenGL 3.3.+giveContext :: IO a -> IO a+giveContext action = mask $ \restore -> do+    is_bound_thread <- isCurrentThreadBound+    unless is_bound_thread $+        error $ "giveContext: current thread is not bound. How can it have " <>+                "an OpenGL context?"++    flextInit (\str -> castFunPtrToPtr <$> getProcAddress str)+              (\_ -> return True) >>= \case+        f@(Failure _) -> throwIO f+        _ -> return ()++    checkOpenGLVersion33++    cid <- atomicModifyIORef' nextContextID $ \old -> ( old+1, old )+    tid <- myThreadId+    atomicModifyIORef' runningContexts $ \old_map ->+        ( M.insert tid cid old_map, () )+    finally (restore insides) (flushDebugMessages >> scrapContext)+  where+    insides = do+        should_activate_debug_mode <- isJust <$> lookupEnv "CARAMIA_OPENGL_DEBUG"+        when should_activate_debug_mode activateDebugMode++        -- Enable sRGB framebuffers+        -- There seems to be no reason not to enable it; you can turn off sRGB+        -- handling in other ways.+        glEnable gl_FRAMEBUFFER_SRGB+        glEnable gl_BLEND++        action++checkOpenGLVersion33 :: IO ()+checkOpenGLVersion33 =+    -- You cannot trust OS X to report versions correctly :-(+#ifdef MAC_OPENGL+    return ()+#else+    alloca $ \major_ptr -> alloca $ \minor_ptr -> do+        -- in case glGetIntegerv is completely broken, set initial values for+        -- major and minor pointers+        poke major_ptr 0+        poke minor_ptr 0++        glGetIntegerv gl_MAJOR_VERSION major_ptr+        glGetIntegerv gl_MAJOR_VERSION minor_ptr+        major <- peek major_ptr+        minor <- peek minor_ptr+        unless (major > 3 ||+                (major == 3 && minor >= 3)) $+            throwIO+                TooOldOpenGL { wantedVersion = (3, 3)+                             , reportedVersion = ( fromIntegral major+                                                 , fromIntegral minor )+                             }+#endif++-- | Scraps the current context.+--+-- Not public API.+scrapContext :: IO ()+scrapContext = mask_ $ do+    maybe_cid <- currentContextID+    tid <- myThreadId+    case maybe_cid of+        Nothing -> return ()+        Just cid -> do+            atomicModifyIORef' runningContexts $ \old_map ->+                ( M.delete tid old_map, () )+            atomicModifyIORef' pendingFinalizers $ \old_map ->+                ( IM.delete cid old_map, () )+            atomicModifyIORef' contextLocalData $ \old_map ->+                ( IM.delete cid old_map, () )++-- | Run any pending finalizers in the current Caramia context.+--+-- Does nothing if current thread does not have a Caramia context or there are+-- no pending finalizers.+--+-- If any finalizer throws an exception (asynchronous or synchronous), the+-- Caramia context dies and that exception is propagated upwards.+-- `runPendingFinalizers` itself runs `mask_` to run the finalizers with+-- exceptions masked but you might still receive asynchronous exceptions with,+-- for example, the `MVar` functions.+--+-- A good place to call this is right after or before swapping buffers.+runPendingFinalizers :: IO ()+runPendingFinalizers = mask_ $ do+    maybe_cid <- currentContextID+    case maybe_cid of+        Nothing -> return ()+        Just cid -> do+            finalizers <- atomicModifyIORef' pendingFinalizers $+                IM.delete cid &&&+                IM.findWithDefault (return ())+                                   cid++            -- We scrap the Caramia context if any of these finalizers throw an+            -- exception. The reason is that we cannot expect the OpenGL state+            -- to be consistent anymore.+            result <- try finalizers+            case result of+                Left exc -> scrapContext >> throwIO (exc :: SomeException)+                Right () -> return ()+    flushDebugMessages++-- | Schedules a finalizer to be run in a Caramia context.+--+-- Does nothing if given context is not alive anymore.+--+-- This is typically called from Haskell garbage collector finalizers because+-- they cannot do finalization there (Haskell finalizers are running in the+-- wrong operating system thread).+scheduleFinalizer :: ContextID -> IO () -> IO ()+scheduleFinalizer cid finalizer =+    atomicModifyIORef' pendingFinalizers $ \old ->+        ( IM.insertWith+            (flip (>>))+            cid+            finalizer+            old, () )++-- these are the pending OpenGL finalizers that wait for a time they can be+-- safely run.+pendingFinalizers :: IORef (IM.IntMap (IO ()))+pendingFinalizers = unsafePerformIO $ newIORef IM.empty+{-# NOINLINE pendingFinalizers #-}+

@@ -0,0 +1,302 @@+-- | Framebuffers. You can render on them.+--+-- If you come from the OpenGL world, for simplicity, we have combined the+-- concept of draw buffers and color attachments. Nth color attachment is bound+-- exactly to Nth draw buffer. Caramia only talks about draw buffers.+--+-- <https://www.opengl.org/wiki/Framebuffer_Object>+--++{-# LANGUAGE NoImplicitPrelude, ViewPatterns, DeriveDataTypeable #-}++module Caramia.Framebuffer+    (+    -- * Creating framebuffers+      newFramebuffer+    , Framebuffer()+    -- * Specifying texture targets+    , frontTextureTarget+    , mipmapTextureTarget+    , layerTextureTarget+    , TextureTarget()+    , Attachment(..)+    -- * Size query+    , getDimensions+    -- * Clearing framebuffers+    , clear+    , Clearing(..)+    , clearing+    -- * Special framebuffers+    , screenFramebuffer+    -- * Hardware limits+    , getMaximumDrawBuffers+    -- * Views+    , viewTargets )+    where++import Caramia.Prelude+import Caramia.Context+import Caramia.Color+import Caramia.Resource+import Caramia.Texture+import Caramia.Framebuffer.Internal+import qualified Caramia.Texture.Internal as Tex+import Caramia.ImageFormats+import Caramia.Internal.OpenGLCApi+import Control.Exception+import Data.List ( nub )+import Data.Bits+import System.IO.Unsafe+import Foreign.Storable+import Foreign.Marshal.Alloc+import Foreign.Marshal.Array+import Foreign.C.Types+import GHC.Float+import qualified Data.IntSet as IS++-- | Returns the screen framebuffer.+--+-- Note that all `screenFramebuffer`s are equal to each other with `Eq`, even+-- those in unrelated Caramia contexts.+--+-- This makes it easy to check if any framebuffer happens to be the screen+-- framebuffer.+screenFramebuffer :: Framebuffer+screenFramebuffer = ScreenFramebuffer++-- | Make a texture target that is the \"front\" of the given texture.+--+-- This is the most common use case. \"front\" means the first texture in a+-- texture array and the base layer mipmap level.+frontTextureTarget :: Tex.Texture -> TextureTarget+frontTextureTarget tex = TextureTarget {+    attacher = \attachment ->+        withResource (Tex.resource tex) $ \(Tex.Texture_ texname) ->+            glFramebufferTexture+                gl_DRAW_FRAMEBUFFER+                attachment+                texname+                0+  , texture = tex }++-- | Map a specific mipmlayer from a texture.+mipmapTextureTarget :: Tex.Texture+                    -> Int            -- ^ Which mipmap layer?+                    -> TextureTarget+mipmapTextureTarget tex mipmap_layer = TextureTarget {+    attacher = \attachment ->+        withResource (Tex.resource tex) $ \(Tex.Texture_ texname) ->+            glFramebufferTexture+                gl_DRAW_FRAMEBUFFER+                attachment+                texname+                (safeFromIntegral mipmap_layer)+  , texture = tex }++-- | Map a specific mipmap layer of a specific layer in a 3D or array texture.+layerTextureTarget :: Tex.Texture+                   -> Int            -- ^ Which mipmap layer?+                   -> Int            -- ^ Which topological layer?+                   -> TextureTarget+layerTextureTarget tex mipmap_layer topo_layer = TextureTarget {+    attacher = \attachment ->+        withResource (Tex.resource tex) $ \(Tex.Texture_ texname) ->+            glFramebufferTextureLayer+                gl_DRAW_FRAMEBUFFER+                attachment+                texname+                (safeFromIntegral mipmap_layer)+                (safeFromIntegral topo_layer)+  , texture = tex }++runningIndices :: IORef Int+runningIndices = unsafePerformIO $ newIORef 0+{-# NOINLINE runningIndices #-}++toConstantA :: Attachment -> GLenum+toConstantA (ColorAttachment x) = gl_COLOR_ATTACHMENT0 + fromIntegral x+toConstantA DepthAttachment = gl_DEPTH_ATTACHMENT+toConstantA StencilAttachment = gl_STENCIL_ATTACHMENT++-- | Creates a new framebuffer.+newFramebuffer :: [(Attachment, TextureTarget)]+               -> IO Framebuffer+newFramebuffer targets+    | null targets =+        error "newFramebuffer: no texture targets specified."+    | nub (fmap fst targets) /= fmap fst targets =+        error "newFramebuffer: there are duplicate attachments."+    | otherwise = mask_ $ do+        max_bufs <- getMaximumDrawBuffers+        targetsSanityCheck max_bufs++        res <- newResource (creator max_bufs)+                           deleter+                           (return ())+        index <- atomicModifyIORef' runningIndices $ \old ->+            ( old+1, old )+        return Framebuffer { resource = res+                           , ordIndex = index+                           , viewTargets = targets+                           , dimensions = calculatedDimensions+                           , binder = withThisFramebuffer res+                           , setter = setThisFramebuffer res }+  where+    calculatedDimensions@(fw, fh) =+        foldl' (\(lowest_w, lowest_h) (w, h) ->+                   (min lowest_w w, min lowest_h h))+               (maxBound, maxBound)+               (fmap (\(snd -> tex) ->+                         (viewWidth $ texture tex, viewHeight $ texture tex))+                     targets)++    creator max_bufs =+        bracketOnError mglGenFramebuffer+                       mglDeleteFramebuffer $ \fbuf_name -> do+            withBoundDrawFramebuffer fbuf_name $ do+                forM_ targets $ \(index, tex) ->+                    attacher tex (toConstantA index)++                allocaArray max_bufs $ \buf_ptr -> do+                    forM_ [0..max_bufs-1] $ \bufnum ->+                        pokeElemOff buf_ptr bufnum $+                            if IS.member bufnum color_attachments+                                then gl_COLOR_ATTACHMENT0 ++                                     fromIntegral bufnum+                                else gl_NONE+                    glDrawBuffers (fromIntegral max_bufs) buf_ptr++            return $ Framebuffer_ fbuf_name++    color_attachments :: IS.IntSet+    color_attachments =+        foldl' folder IS.empty (fmap fst targets)+      where+        folder :: IS.IntSet -> Attachment -> IS.IntSet+        folder accum (ColorAttachment x) = IS.insert x accum+        folder accum _ = accum++    deleter (Framebuffer_ fbuf_name) =+        mglDeleteFramebuffer fbuf_name++    targetsSanityCheck max_bufs = forM_ targets $ \(attachment, target) -> do+        let format = Tex.imageFormat $ Tex.viewSpecification $ texture target+        unless (isRenderTargettable format) $+            error $ "newFramebuffer: cannot render to " <> show format+        case attachment of+            ColorAttachment x | x < 0 || x >= max_bufs ->+                error $ "newFramebuffer: color attachment " <> show x <>+                        " is out of range. Valid range is [0.." <>+                        show (max_bufs-1) <> "]."+            ColorAttachment _ | not (isColorFormat format) ->+                error $ "newFramebuffer: " <> show format <> " is not a " <>+                        "color format but was attempted to be attached to " <>+                        "attachment " <> show attachment <> "."+            DepthAttachment | not (hasDepthComponent format) ->+                error $ "newFramebuffer: " <> show format <> " has no " <>+                        "depth component but was attempted to be attached " <>+                        "to depth attachment."+            StencilAttachment | not (hasStencilComponent format) ->+                error $ "newFramebuffer: " <> show format <> " has no " <>+                        "stencil component but was attempted to be " <>+                        "attached to stencil attachment."+            _ -> return ()++    setThisFramebuffer res = do+        withResource res $ \(Framebuffer_ fbuf_name) ->+            glBindFramebuffer gl_FRAMEBUFFER fbuf_name+        glViewport 0 0 (fromIntegral fw) (fromIntegral fh)++    withThisFramebuffer res action = mask $ \restore -> do+        old_draw_framebuffer <- gi gl_DRAW_FRAMEBUFFER_BINDING+        old_read_framebuffer <- gi gl_READ_FRAMEBUFFER_BINDING+        allocaArray 4 $ \viewport_ptr -> do+            glGetIntegerv gl_VIEWPORT viewport_ptr+            withResource res $ \(Framebuffer_ fbuf_name) -> do+                glBindFramebuffer gl_FRAMEBUFFER fbuf_name+                x <- peekElemOff viewport_ptr 0+                y <- peekElemOff viewport_ptr 1+                w <- peekElemOff viewport_ptr 2+                h <- peekElemOff viewport_ptr 3+                glViewport 0 0 (fromIntegral fw) (fromIntegral fh)+                finally (restore action) $ do+                    glViewport x y w h+                    glBindFramebuffer gl_DRAW_FRAMEBUFFER old_draw_framebuffer+                    glBindFramebuffer gl_READ_FRAMEBUFFER old_read_framebuffer++-- | Returns the maximum number of draw buffers in the current context.+--+-- Almost all GPUs in the last few years have at least 8.+getMaximumDrawBuffers :: IO Int+getMaximumDrawBuffers = do+    _ <- currentContextID+    -- number of draw buffers+    num_drawbuffers <- gi gl_MAX_DRAW_BUFFERS+    -- number of attachments+    num_attachments <- gi gl_MAX_COLOR_ATTACHMENTS+    return (fromIntegral $ min num_drawbuffers num_attachments)++-- | Specifies what to clear in a `clear` invocation.+--+-- Use `clearing` smart constructor instead for forward-compatibility.+--+-- Each member of this data type is a `Maybe` value; if any value is `Just`+-- then that value is cleared, otherwise it is not touched.+data Clearing = Clearing+    { clearDepth :: !(Maybe Float)+    -- ^ Clear depth buffer to this value.+    , clearStencil :: !(Maybe Int32)+    -- ^ Clear stencil buffer to this value.+    , clearColor :: !(Maybe Color)+    -- ^ Clear (all) color buffers to some color.+    }+    deriving ( Eq, Ord, Show, Read, Typeable )++-- TODO: selective clearing for different color buffers.++-- | Smart constructor for `Clearing`. All members are `Nothing`.+clearing :: Clearing+clearing = Clearing { clearDepth = Nothing+                    , clearStencil = Nothing+                    , clearColor = Nothing }++-- | Clears values in a framebuffer.+clear :: Clearing -> Framebuffer -> IO ()+clear clearing fbuf = withBinding fbuf $ mask_ $+    recColor (clearColor clearing)+  where+    bits = maybe 0 (const gl_COLOR_BUFFER_BIT) (clearColor clearing) .|.+           maybe 0 (const gl_DEPTH_BUFFER_BIT) (clearDepth clearing) .|.+           maybe 0 (const gl_STENCIL_BUFFER_BIT) (clearStencil clearing)++    recColor Nothing = recDepth (clearDepth clearing)+    recColor (Just (viewRgba -> (r, g, b, a))) =+        allocaArray 4 $ \ptr -> do+            glGetFloatv gl_COLOR_CLEAR_VALUE ptr+            glClearColor (CFloat r)+                         (CFloat g)+                         (CFloat b)+                         (CFloat a)+            recDepth (clearDepth clearing)+            nr <- peekElemOff ptr 0+            ng <- peekElemOff ptr 1+            nb <- peekElemOff ptr 2+            na <- peekElemOff ptr 3+            glClearColor (nr :: CFloat) ng nb na++    recDepth Nothing = recStencil (clearStencil clearing)+    recDepth (Just depth) = do+        old_depth <- alloca $ \ptr ->+            glGetDoublev gl_DEPTH_CLEAR_VALUE ptr *> peek ptr+        glClearDepth (CDouble $ float2Double depth)+        recStencil (clearStencil clearing)+        glClearDepth old_depth++    recStencil Nothing = glClear bits+    recStencil (Just stencil) = do+        old_stencil <- alloca $ \ptr ->+            glGetIntegerv gl_STENCIL_CLEAR_VALUE ptr *> peek ptr+        glClearStencil (safeFromIntegral stencil)+        glClear bits+        glClearStencil old_stencil+

@@ -0,0 +1,87 @@+{-# LANGUAGE RankNTypes, NoImplicitPrelude, DeriveDataTypeable #-}++module Caramia.Framebuffer.Internal where++import Caramia.Prelude++import Caramia.Resource+import Caramia.Internal.OpenGLCApi+import qualified Caramia.Texture.Internal as Tex+import Control.Exception+import Foreign++data Framebuffer =+    ScreenFramebuffer+  | Framebuffer {+        resource :: !(Resource Framebuffer_)+      , ordIndex :: !Int+      , viewTargets :: [(Attachment, TextureTarget)]+      , dimensions :: !(Int, Int)+      , binder :: forall a. IO a -> IO a+      , setter :: IO ()+    }+    deriving ( Typeable )++data Attachment = ColorAttachment !Int+                | DepthAttachment+                | StencilAttachment+                deriving ( Eq, Ord, Show, Read, Typeable )++instance Eq Framebuffer where+    ScreenFramebuffer == ScreenFramebuffer = True+    ScreenFramebuffer == _ = False+    _ == ScreenFramebuffer = False+    fbuf1 == fbuf2 = resource fbuf1 == resource fbuf2++instance Ord Framebuffer where+    ScreenFramebuffer `compare` ScreenFramebuffer = EQ+    ScreenFramebuffer `compare` _ = LT+    _ `compare` ScreenFramebuffer = GT+    fbuf1 `compare` fbuf2 = ordIndex fbuf1 `compare` ordIndex fbuf2++newtype Framebuffer_ = Framebuffer_ GLuint++data TextureTarget = TextureTarget+    { attacher :: GLuint -> IO ()+    , texture :: Tex.Texture }++setBinding :: Framebuffer -> IO ()+setBinding ScreenFramebuffer = do+    (w, h) <- getDimensions ScreenFramebuffer+    glBindFramebuffer gl_FRAMEBUFFER 0+    glViewport 0 0 (fromIntegral w) (fromIntegral h)+setBinding fbuf = setter fbuf++withBinding :: Framebuffer -> IO a -> IO a+withBinding ScreenFramebuffer action =+    allocaArray 4 $ \viewport_ptr -> do+        glGetIntegerv gl_VIEWPORT viewport_ptr+        ox <- peekElemOff viewport_ptr 0+        oy <- peekElemOff viewport_ptr 1+        ow <- peekElemOff viewport_ptr 2+        oh <- peekElemOff viewport_ptr 3+        (w, h) <- getDimensions ScreenFramebuffer+        old_draw <- gi gl_DRAW_FRAMEBUFFER_BINDING+        old_read <- gi gl_READ_FRAMEBUFFER_BINDING+        finally (glBindFramebuffer gl_FRAMEBUFFER 0 >>+                 glViewport 0 0 (fromIntegral w) (fromIntegral h) >>+                 action) $ do+            glViewport ox oy ow oh+            glBindFramebuffer gl_DRAW_FRAMEBUFFER old_draw+            glBindFramebuffer gl_READ_FRAMEBUFFER old_read+withBinding fbuf action = binder fbuf action++-- | Returns the size of a framebuffer.+--+-- This is an `IO` action because it can change for the screen framebuffer.+getDimensions :: Framebuffer -> IO (Int, Int)+getDimensions ScreenFramebuffer =+    allocaArray 4 $ \vptr -> do+        glGetIntegerv gl_VIEWPORT vptr+        w <- peekElemOff vptr 2+        h <- peekElemOff vptr 3+        return (fromIntegral w, fromIntegral h)+getDimensions fbuf = return $ dimensions fbuf+{-# INLINE getDimensions #-}++

@@ -0,0 +1,18 @@+module Caramia.ImageFormats+    (+    -- * Image formats+      ImageFormat(..)+    , isRenderTargettable+    , isCompressed+    , isColorFormat+    , isSRGBFormat+    , hasDepthComponent+    , hasStencilComponent+    -- * Specification types+    , SpecificationType(..)+    , sizeOfSpecificationType+    , SpecificationTypeable(..) )+    where++import Caramia.ImageFormats.Internal+

@@ -0,0 +1,328 @@+-- | This module contains data types that describe the data formats of images.+--+-- <https://www.opengl.org/wiki/Image_Format>+--++{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-}++module Caramia.ImageFormats.Internal where++import Caramia.Prelude++import Caramia.Internal.OpenGLCApi+import Foreign.C.Types++-- | Given a format, returns `True` if that format can be rendered to. That is,+-- if it can be one of the targets in a framebuffer.+--+-- This is conservative. Sometimes you may be able to render anyway; however+-- this is not guaranteed by the OpenGL specification.+isRenderTargettable :: ImageFormat -> Bool+isRenderTargettable R8 = True+isRenderTargettable R8I = True+isRenderTargettable R8UI = True+isRenderTargettable R16 = True+isRenderTargettable R16I = True+isRenderTargettable R16UI = True+isRenderTargettable R16F = True+isRenderTargettable R32F = True+isRenderTargettable R32I = True+isRenderTargettable R32UI = True+isRenderTargettable RG8 = True+isRenderTargettable RG8I = True+isRenderTargettable RG8UI = True+isRenderTargettable RG16 = True+isRenderTargettable RG16I = True+isRenderTargettable RG16UI = True+isRenderTargettable RG16F = True+isRenderTargettable RG32F = True+isRenderTargettable RG32I = True+isRenderTargettable RG32UI = True+isRenderTargettable R11F_G11F_B10F = True+isRenderTargettable RGB8 = True+isRenderTargettable RGBA32F = True+isRenderTargettable RGBA32I = True+isRenderTargettable RGBA32UI = True+isRenderTargettable RGBA16 = True+isRenderTargettable RGBA16F = True+isRenderTargettable RGBA16I = True+isRenderTargettable RGBA16UI = True+isRenderTargettable RGBA8 = True+isRenderTargettable RGBA8UI = True+isRenderTargettable SRGB8_ALPHA8 = True+isRenderTargettable RGB10_A2 = True+isRenderTargettable DEPTH_COMPONENT32 = True+isRenderTargettable DEPTH_COMPONENT32F = True+isRenderTargettable DEPTH_COMPONENT24 = True+isRenderTargettable DEPTH_COMPONENT16 = True+isRenderTargettable DEPTH32F_STENCIL8 = True+isRenderTargettable DEPTH24_STENCIL8 = True+isRenderTargettable _ = False++-- | Returns true if the given format is a compressed format.+isCompressed :: ImageFormat -> Bool+isCompressed COMPRESSED_RG_RGTC2 = True+isCompressed COMPRESSED_SIGNED_RG_RGTC2 = True+isCompressed COMPRESSED_RED_RGTC1 = True+isCompressed COMPRESSED_SIGNED_RED_RGTC1 = True+isCompressed COMPRESSED_RGB_S3TC_DXT1 = True+isCompressed COMPRESSED_RGBA_S3TC_DXT1 = True+isCompressed COMPRESSED_RGBA_S3TC_DXT3 = True+isCompressed COMPRESSED_RGBA_S3TC_DXT5 = True+isCompressed COMPRESSED_SRGB_S3TC_DXT1 = True+isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = True+isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = True+isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = True+isCompressed _ = False++-- | Returns true if the given format is a color format.+isColorFormat :: ImageFormat -> Bool+isColorFormat DEPTH_COMPONENT32 = False+isColorFormat DEPTH_COMPONENT32F = False+isColorFormat DEPTH_COMPONENT24 = False+isColorFormat DEPTH_COMPONENT16 = False+isColorFormat DEPTH32F_STENCIL8 = False+isColorFormat DEPTH24_STENCIL8 = False+isColorFormat _ = True++-- | Returns true if the given format has a depth component.+hasDepthComponent :: ImageFormat -> Bool+hasDepthComponent DEPTH_COMPONENT32 = True+hasDepthComponent DEPTH_COMPONENT32F = True+hasDepthComponent DEPTH_COMPONENT24 = True+hasDepthComponent DEPTH_COMPONENT16 = True+hasDepthComponent DEPTH32F_STENCIL8 = True+hasDepthComponent DEPTH24_STENCIL8 = True+hasDepthComponent _ = False++-- | Returns true if the given format has a stencil component.+hasStencilComponent :: ImageFormat -> Bool+hasStencilComponent DEPTH32F_STENCIL8 = True+hasStencilComponent DEPTH24_STENCIL8 = True+hasStencilComponent _ = False++-- | Returns true if the given format uses the sRGB color space.+--+-- If the format is not a color format, returns `False`.+isSRGBFormat :: ImageFormat -> Bool+isSRGBFormat SRGB8_ALPHA8 = True+isSRGBFormat SRGB8 = True+isSRGBFormat COMPRESSED_SRGB_S3TC_DXT1 = True+isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = True+isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = True+isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = True+isSRGBFormat _ = False++-- | All the various internal formats.+--+-- This list corresponds to the OpenGL specification of 3.3, required texture+-- formats (+ S3TC compressed formats). Check the OpenGL specification for+-- explanations on how these formats work.+data ImageFormat =+    R8+  | R8I+  | R8UI+  | R16+  | R16I+  | R16UI+  | R16F+  | R32F+  | R32I+  | R32UI+  | RG8+  | RG8I+  | RG8UI+  | RG16+  | RG16I+  | RG16UI+  | RG16F+  | RG32F+  | RG32I+  | RG32UI+  | R11F_G11F_B10F+  | RGBA32F+  | RGBA32I+  | RGBA32UI+  | RGBA16+  | RGBA16F+  | RGBA16I+  | RGBA16UI+  | RGBA8+  | RGBA8UI+  | SRGB8_ALPHA8+  | RGB10_A2+  | RGB32F+  | RGB32I+  | RGB32UI+  | RGB16F+  | RGB16I+  | RGB16UI+  | RGB16+  | RGB8+  | RGB8I+  | RGB8UI+  | SRGB8+  | RGB9_E5+  | COMPRESSED_RG_RGTC2+  | COMPRESSED_SIGNED_RG_RGTC2+  | COMPRESSED_RED_RGTC1+  | COMPRESSED_SIGNED_RED_RGTC1+  | COMPRESSED_RGB_S3TC_DXT1+  | COMPRESSED_RGBA_S3TC_DXT1+  | COMPRESSED_RGBA_S3TC_DXT3+  | COMPRESSED_RGBA_S3TC_DXT5+  | COMPRESSED_SRGB_S3TC_DXT1+  | COMPRESSED_SRGB_ALPHA_S3TC_DXT1+  | COMPRESSED_SRGB_ALPHA_S3TC_DXT3+  | COMPRESSED_SRGB_ALPHA_S3TC_DXT5+  | DEPTH_COMPONENT32+  | DEPTH_COMPONENT32F+  | DEPTH_COMPONENT24+  | DEPTH_COMPONENT16+  | DEPTH32F_STENCIL8+  | DEPTH24_STENCIL8+  deriving ( Eq, Ord, Show, Read, Typeable )++toConstantIF :: ImageFormat -> GLenum+toConstantIF R8 = gl_R8+toConstantIF R8I = gl_R8I+toConstantIF R8UI = gl_R8UI+toConstantIF R16 = gl_R16+toConstantIF R16I = gl_R16I+toConstantIF R16UI = gl_R16UI+toConstantIF R16F = gl_R16F+toConstantIF R32F = gl_R32F+toConstantIF R32I = gl_R32I+toConstantIF R32UI = gl_R32UI+toConstantIF RG8 = gl_RG8+toConstantIF RG8I = gl_RG8I+toConstantIF RG8UI = gl_RG8UI+toConstantIF RG16 = gl_RG16+toConstantIF RG16I = gl_RG16I+toConstantIF RG16UI = gl_RG16UI+toConstantIF RG16F = gl_RG16F+toConstantIF RG32F = gl_RG32F+toConstantIF RG32I = gl_RG32I+toConstantIF RG32UI = gl_RG32UI+toConstantIF R11F_G11F_B10F = gl_R11F_G11F_B10F+toConstantIF RGBA32F = gl_RGBA32F+toConstantIF RGBA32I = gl_RGBA32I+toConstantIF RGBA32UI = gl_RGBA32UI+toConstantIF RGBA16 = gl_RGBA16+toConstantIF RGBA16F = gl_RGBA16F+toConstantIF RGBA16I = gl_RGBA16I+toConstantIF RGBA16UI = gl_RGBA16UI+toConstantIF RGBA8 = gl_RGBA8+toConstantIF RGBA8UI = gl_RGBA8UI+toConstantIF SRGB8_ALPHA8 = gl_SRGB8_ALPHA8+toConstantIF RGB10_A2 = gl_RGB10_A2+toConstantIF RGB32F = gl_RGB32F+toConstantIF RGB32I = gl_RGB32I+toConstantIF RGB32UI = gl_RGB32UI+toConstantIF RGB16F = gl_RGB16F+toConstantIF RGB16I = gl_RGB16I+toConstantIF RGB16UI = gl_RGB16UI+toConstantIF RGB16 = gl_RGB16+toConstantIF RGB8 = gl_RGB8+toConstantIF RGB8I = gl_RGB8I+toConstantIF RGB8UI = gl_RGB8UI+toConstantIF SRGB8 = gl_SRGB8+toConstantIF RGB9_E5 = gl_RGB9_E5+toConstantIF COMPRESSED_RG_RGTC2 = gl_COMPRESSED_RG_RGTC2+toConstantIF COMPRESSED_SIGNED_RG_RGTC2 = gl_COMPRESSED_SIGNED_RG_RGTC2+toConstantIF COMPRESSED_RED_RGTC1 = gl_COMPRESSED_RED_RGTC1+toConstantIF COMPRESSED_SIGNED_RED_RGTC1 = gl_COMPRESSED_SIGNED_RED_RGTC1+toConstantIF COMPRESSED_RGB_S3TC_DXT1 = gl_COMPRESSED_RGB_S3TC_DXT1_EXT+toConstantIF COMPRESSED_RGBA_S3TC_DXT1 = gl_COMPRESSED_RGBA_S3TC_DXT1_EXT+toConstantIF COMPRESSED_RGBA_S3TC_DXT3 = gl_COMPRESSED_RGBA_S3TC_DXT3_EXT+toConstantIF COMPRESSED_RGBA_S3TC_DXT5 = gl_COMPRESSED_RGBA_S3TC_DXT5_EXT+toConstantIF COMPRESSED_SRGB_S3TC_DXT1 = gl_COMPRESSED_SRGB_S3TC_DXT1_EXT+toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT1 =+    gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT+toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT3 =+    gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT+toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT5 =+    gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT+toConstantIF DEPTH_COMPONENT32 = gl_DEPTH_COMPONENT32+toConstantIF DEPTH_COMPONENT32F = gl_DEPTH_COMPONENT32F+toConstantIF DEPTH_COMPONENT24 = gl_DEPTH_COMPONENT24+toConstantIF DEPTH_COMPONENT16 = gl_DEPTH_COMPONENT16+toConstantIF DEPTH32F_STENCIL8 = gl_DEPTH32F_STENCIL8+toConstantIF DEPTH24_STENCIL8 = gl_DEPTH24_STENCIL8++-- | Specification formats.+--+-- These formats specify the type of the data passed from Haskell to GPU.+data SpecificationType =+    FWord8+  | FWord16+  | FWord32+  | FInt8+  | FInt16+  | FInt32+  | FFloat+  | FHalfFloat+  deriving ( Eq, Ord, Show, Read, Typeable )++toConstantST :: SpecificationType -> GLenum+toConstantST FWord8 = gl_UNSIGNED_BYTE+toConstantST FWord16 = gl_UNSIGNED_SHORT+toConstantST FWord32 = gl_UNSIGNED_INT+toConstantST FInt8 = gl_BYTE+toConstantST FInt16 = gl_SHORT+toConstantST FInt32 = gl_INT+toConstantST FFloat = gl_FLOAT+toConstantST FHalfFloat = gl_HALF_FLOAT++-- TODO: add special interpretation formats to `SpecificationType`.+--++-- | Given a specification format, returns the number of bytes one element+-- uses.+sizeOfSpecificationType :: SpecificationType -> Int+sizeOfSpecificationType FWord8 = 1+sizeOfSpecificationType FWord16 = 2+sizeOfSpecificationType FWord32 = 2+sizeOfSpecificationType FInt8 = 1+sizeOfSpecificationType FInt16 = 2+sizeOfSpecificationType FInt32 = 4+sizeOfSpecificationType FFloat = 4+sizeOfSpecificationType FHalfFloat = 2++-- | Class that turns Haskell types into `SpecificationType`.+class SpecificationTypeable a where+    -- | Returns the corresponding `SpecificationType` for a Haskell type.+    toSpecificationType :: a  -- ^ Used to pass the type; not evaluated.+                        -> SpecificationType++instance SpecificationTypeable Word8 where+    toSpecificationType _ = FWord8++instance SpecificationTypeable Word16 where+    toSpecificationType _ = FWord16++instance SpecificationTypeable Word32 where+    toSpecificationType _ = FWord32++instance SpecificationTypeable Int8 where+    toSpecificationType _ = FInt8++instance SpecificationTypeable Int16 where+    toSpecificationType _ = FInt16++instance SpecificationTypeable Int32 where+    toSpecificationType _ = FInt32++instance SpecificationTypeable CInt where+    toSpecificationType _ = FInt32++instance SpecificationTypeable CUInt where+    toSpecificationType _ = FWord32++instance SpecificationTypeable Float where+    toSpecificationType _ = FFloat++instance SpecificationTypeable CFloat where+    toSpecificationType _ = FFloat++

@@ -0,0 +1,121 @@+{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables #-}++module Caramia.Internal.ContextLocalData+    ( storeContextLocalData+    , retrieveContextLocalData+    , currentContextID+    , nextContextID+    , runningContexts+    , contextLocalData+    , ContextID )+    where++import Caramia.Prelude+import qualified Data.IntMap.Strict as IM+import qualified Data.Map.Strict as M+import System.IO.Unsafe+import Data.Dynamic+import Control.Concurrent++-- | The type of a Caramia context ID.+type ContextID = Int++-- currently running contexts, map from thread IDs to context IDs+runningContexts :: IORef (M.Map ThreadId ContextID)+runningContexts = unsafePerformIO $ newIORef M.empty+{-# NOINLINE runningContexts #-}++-- used to give out new unique context IDs+nextContextID :: IORef ContextID+nextContextID = unsafePerformIO $ newIORef 0+{-# NOINLINE nextContextID #-}++-- context local data. This is like poor man's thread local storage but for+-- contexts.+--+-- The `TypeRep` and `Dynamic` lets this module be agnostic to what other+-- modules hang on to thread local data.+--+-- Other modules can specify a type that there should be only one per context.+-- And this type's TypeRep is stored/queried from the map below.+contextLocalData :: IORef (IM.IntMap (M.Map TypeRep Dynamic))+contextLocalData = unsafePerformIO $ newIORef IM.empty+{-# NOINLINE contextLocalData #-}++-- | Returns the current Caramia context ID.+--+-- The context ID is unique between different calls to `giveContext`.+--+-- Returns `Nothing` if there is no context active.+currentContextID :: IO (Maybe ContextID)+currentContextID =+    M.lookup <$> myThreadId <*> readIORef runningContexts+{-# INLINE currentContextID #-}++-- | Stores a context local value.+--+-- The type of the given value is used as a key. This means that if a value of+-- the same type was stored before, that value is thrown away and replaced with+-- this new value you just gave.+--+-- The value is evaluated to WHNF.+--+-- You don't need this function to work with context local data.+-- `retrieveContextLocalData` is sufficient as it also lets you set a default+-- value in case a value was not already set.+--+-- Context local data is wiped to oblivion once `giveContext` ends.+storeContextLocalData :: Typeable a => a -> IO ()+storeContextLocalData value =+    maybe (error "storeContextLocalData: not in a context.")+          (\cid ->+              atomicModifyIORef' contextLocalData $ \old ->+                  ( IM.alter (Just . maybe (M.singleton+                                            (typeOf value)+                                            (toDyn value))+                                           (M.insert (typeOf value)+                                                     (toDyn value)))+                              cid+                              old+                  , () ) )+          =<< currentContextID+{-# INLINE storeContextLocalData #-}++-- | Retrieves a context local value.+--+-- See `storeContextLocalData`.+retrieveContextLocalData :: forall a. Typeable a+                         => IO a  -- ^ Default value generating action; not+                                  -- evaluated if there was already a value+                                  -- stored.+                         -> IO a+retrieveContextLocalData defvalue =+    maybe (error "retrieveContextLocalData: not in a context.")+          (\cid -> do+              -- No need to care about IORef race conditions because all+              -- functions operating on a certain context ID will be+              -- run in the same thread, sequentially.+              snapshot <- readIORef contextLocalData+              case IM.lookup cid snapshot of+                  Nothing -> do+                      val <- dyndefvalue+                      atomicModifyIORef' contextLocalData $ \old ->+                          ( IM.insert cid (M.singleton typ val) old+                          , fromDyn val undefined )+                  Just old_map ->+                      case M.lookup typ old_map of+                          Nothing -> do+                              val <- dyndefvalue+                              atomicModifyIORef' contextLocalData $ \old ->+                                  ( IM.adjust (M.insert typ val)+                                              cid+                                              old+                                  , fromDyn val undefined )+                          Just value -> return (fromDyn value undefined))+          =<< currentContextID+  where+    typ = typeOf (undefined :: a)+    dyndefvalue = toDyn <$> defvalue+{-# INLINEABLE retrieveContextLocalData #-}++

@@ -0,0 +1,28572 @@+{-# LANGUAGE CPP, ForeignFunctionInterface, EmptyDataDecls #-}+#ifdef __GLASGOW_HASKELL__+{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}+#endif+-- WARNING: This file was automatically generated+-- Do not edit.++++module Caramia.Internal.FlextGL+    ( flextInit+    , FlextInitResult(..)+    , has_GL_ARB_texture_storage+    , has_GL_KHR_debug+    , has_GL_EXT_direct_state_access+    , has_GL_ARB_buffer_storage+    , has_GL_ARB_separate_shader_objects+    , has_GL_ATI_meminfo+    , has_GL_NVX_gpu_memory_info+    , has_GL_ARB_invalidate_subdata+    , glCullFace+    , glFrontFace+    , glHint+    , glLineWidth+    , glPointSize+    , glPolygonMode+    , glScissor+    , glTexParameterf+    , glTexParameterfv+    , glTexParameteri+    , glTexParameteriv+    , glTexImage1D+    , glTexImage2D+    , glDrawBuffer+    , glClear+    , glClearColor+    , glClearStencil+    , glClearDepth+    , glStencilMask+    , glColorMask+    , glDepthMask+    , glDisable+    , glEnable+    , glFinish+    , glFlush+    , glBlendFunc+    , glLogicOp+    , glStencilFunc+    , glStencilOp+    , glDepthFunc+    , glPixelStoref+    , glPixelStorei+    , glReadBuffer+    , glReadPixels+    , glGetBooleanv+    , glGetDoublev+    , glGetError+    , glGetFloatv+    , glGetIntegerv+    , glGetString+    , glGetTexImage+    , glGetTexParameterfv+    , glGetTexParameteriv+    , glGetTexLevelParameterfv+    , glGetTexLevelParameteriv+    , glIsEnabled+    , glDepthRange+    , glViewport+    , glDrawArrays+    , glDrawElements+    , glPolygonOffset+    , glCopyTexImage1D+    , glCopyTexImage2D+    , glCopyTexSubImage1D+    , glCopyTexSubImage2D+    , glTexSubImage1D+    , glTexSubImage2D+    , glBindTexture+    , glDeleteTextures+    , glGenTextures+    , glIsTexture+    , glDrawRangeElements+    , glTexImage3D+    , glTexSubImage3D+    , glCopyTexSubImage3D+    , glActiveTexture+    , glSampleCoverage+    , glCompressedTexImage3D+    , glCompressedTexImage2D+    , glCompressedTexImage1D+    , glCompressedTexSubImage3D+    , glCompressedTexSubImage2D+    , glCompressedTexSubImage1D+    , glGetCompressedTexImage+    , glBlendFuncSeparate+    , glMultiDrawArrays+    , glMultiDrawElements+    , glPointParameterf+    , glPointParameterfv+    , glPointParameteri+    , glPointParameteriv+    , glBlendColor+    , glBlendEquation+    , glGenQueries+    , glDeleteQueries+    , glIsQuery+    , glBeginQuery+    , glEndQuery+    , glGetQueryiv+    , glGetQueryObjectiv+    , glGetQueryObjectuiv+    , glBindBuffer+    , glDeleteBuffers+    , glGenBuffers+    , glIsBuffer+    , glBufferData+    , glBufferSubData+    , glGetBufferSubData+    , glMapBuffer+    , glUnmapBuffer+    , glGetBufferParameteriv+    , glGetBufferPointerv+    , glBlendEquationSeparate+    , glDrawBuffers+    , glStencilOpSeparate+    , glStencilFuncSeparate+    , glStencilMaskSeparate+    , glAttachShader+    , glBindAttribLocation+    , glCompileShader+    , glCreateProgram+    , glCreateShader+    , glDeleteProgram+    , glDeleteShader+    , glDetachShader+    , glDisableVertexAttribArray+    , glEnableVertexAttribArray+    , glGetActiveAttrib+    , glGetActiveUniform+    , glGetAttachedShaders+    , glGetAttribLocation+    , glGetProgramiv+    , glGetProgramInfoLog+    , glGetShaderiv+    , glGetShaderInfoLog+    , glGetShaderSource+    , glGetUniformLocation+    , glGetUniformfv+    , glGetUniformiv+    , glGetVertexAttribdv+    , glGetVertexAttribfv+    , glGetVertexAttribiv+    , glGetVertexAttribPointerv+    , glIsProgram+    , glIsShader+    , glLinkProgram+    , glShaderSource+    , glUseProgram+    , glUniform1f+    , glUniform2f+    , glUniform3f+    , glUniform4f+    , glUniform1i+    , glUniform2i+    , glUniform3i+    , glUniform4i+    , glUniform1fv+    , glUniform2fv+    , glUniform3fv+    , glUniform4fv+    , glUniform1iv+    , glUniform2iv+    , glUniform3iv+    , glUniform4iv+    , glUniformMatrix2fv+    , glUniformMatrix3fv+    , glUniformMatrix4fv+    , glValidateProgram+    , glVertexAttrib1d+    , glVertexAttrib1dv+    , glVertexAttrib1f+    , glVertexAttrib1fv+    , glVertexAttrib1s+    , glVertexAttrib1sv+    , glVertexAttrib2d+    , glVertexAttrib2dv+    , glVertexAttrib2f+    , glVertexAttrib2fv+    , glVertexAttrib2s+    , glVertexAttrib2sv+    , glVertexAttrib3d+    , glVertexAttrib3dv+    , glVertexAttrib3f+    , glVertexAttrib3fv+    , glVertexAttrib3s+    , glVertexAttrib3sv+    , glVertexAttrib4Nbv+    , glVertexAttrib4Niv+    , glVertexAttrib4Nsv+    , glVertexAttrib4Nub+    , glVertexAttrib4Nubv+    , glVertexAttrib4Nuiv+    , glVertexAttrib4Nusv+    , glVertexAttrib4bv+    , glVertexAttrib4d+    , glVertexAttrib4dv+    , glVertexAttrib4f+    , glVertexAttrib4fv+    , glVertexAttrib4iv+    , glVertexAttrib4s+    , glVertexAttrib4sv+    , glVertexAttrib4ubv+    , glVertexAttrib4uiv+    , glVertexAttrib4usv+    , glVertexAttribPointer+    , glUniformMatrix2x3fv+    , glUniformMatrix3x2fv+    , glUniformMatrix2x4fv+    , glUniformMatrix4x2fv+    , glUniformMatrix3x4fv+    , glUniformMatrix4x3fv+    , glColorMaski+    , glGetBooleani_v+    , glGetIntegeri_v+    , glEnablei+    , glDisablei+    , glIsEnabledi+    , glBeginTransformFeedback+    , glEndTransformFeedback+    , glBindBufferRange+    , glBindBufferBase+    , glTransformFeedbackVaryings+    , glGetTransformFeedbackVarying+    , glClampColor+    , glBeginConditionalRender+    , glEndConditionalRender+    , glVertexAttribIPointer+    , glGetVertexAttribIiv+    , glGetVertexAttribIuiv+    , glVertexAttribI1i+    , glVertexAttribI2i+    , glVertexAttribI3i+    , glVertexAttribI4i+    , glVertexAttribI1ui+    , glVertexAttribI2ui+    , glVertexAttribI3ui+    , glVertexAttribI4ui+    , glVertexAttribI1iv+    , glVertexAttribI2iv+    , glVertexAttribI3iv+    , glVertexAttribI4iv+    , glVertexAttribI1uiv+    , glVertexAttribI2uiv+    , glVertexAttribI3uiv+    , glVertexAttribI4uiv+    , glVertexAttribI4bv+    , glVertexAttribI4sv+    , glVertexAttribI4ubv+    , glVertexAttribI4usv+    , glGetUniformuiv+    , glBindFragDataLocation+    , glGetFragDataLocation+    , glUniform1ui+    , glUniform2ui+    , glUniform3ui+    , glUniform4ui+    , glUniform1uiv+    , glUniform2uiv+    , glUniform3uiv+    , glUniform4uiv+    , glTexParameterIiv+    , glTexParameterIuiv+    , glGetTexParameterIiv+    , glGetTexParameterIuiv+    , glClearBufferiv+    , glClearBufferuiv+    , glClearBufferfv+    , glClearBufferfi+    , glGetStringi+    , glIsRenderbuffer+    , glBindRenderbuffer+    , glDeleteRenderbuffers+    , glGenRenderbuffers+    , glRenderbufferStorage+    , glGetRenderbufferParameteriv+    , glIsFramebuffer+    , glBindFramebuffer+    , glDeleteFramebuffers+    , glGenFramebuffers+    , glCheckFramebufferStatus+    , glFramebufferTexture1D+    , glFramebufferTexture2D+    , glFramebufferTexture3D+    , glFramebufferRenderbuffer+    , glGetFramebufferAttachmentParameteriv+    , glGenerateMipmap+    , glBlitFramebuffer+    , glRenderbufferStorageMultisample+    , glFramebufferTextureLayer+    , glMapBufferRange+    , glFlushMappedBufferRange+    , glBindVertexArray+    , glDeleteVertexArrays+    , glGenVertexArrays+    , glIsVertexArray+    , glDrawArraysInstanced+    , glDrawElementsInstanced+    , glTexBuffer+    , glPrimitiveRestartIndex+    , glCopyBufferSubData+    , glGetUniformIndices+    , glGetActiveUniformsiv+    , glGetActiveUniformName+    , glGetUniformBlockIndex+    , glGetActiveUniformBlockiv+    , glGetActiveUniformBlockName+    , glUniformBlockBinding+    , glDrawElementsBaseVertex+    , glDrawRangeElementsBaseVertex+    , glDrawElementsInstancedBaseVertex+    , glMultiDrawElementsBaseVertex+    , glProvokingVertex+    , glFenceSync+    , glIsSync+    , glDeleteSync+    , glClientWaitSync+    , glWaitSync+    , glGetInteger64v+    , glGetSynciv+    , glGetInteger64i_v+    , glGetBufferParameteri64v+    , glFramebufferTexture+    , glTexImage2DMultisample+    , glTexImage3DMultisample+    , glGetMultisamplefv+    , glSampleMaski+    , glBindFragDataLocationIndexed+    , glGetFragDataIndex+    , glGenSamplers+    , glDeleteSamplers+    , glIsSampler+    , glBindSampler+    , glSamplerParameteri+    , glSamplerParameteriv+    , glSamplerParameterf+    , glSamplerParameterfv+    , glSamplerParameterIiv+    , glSamplerParameterIuiv+    , glGetSamplerParameteriv+    , glGetSamplerParameterIiv+    , glGetSamplerParameterfv+    , glGetSamplerParameterIuiv+    , glQueryCounter+    , glGetQueryObjecti64v+    , glGetQueryObjectui64v+    , glVertexAttribDivisor+    , glVertexAttribP1ui+    , glVertexAttribP1uiv+    , glVertexAttribP2ui+    , glVertexAttribP2uiv+    , glVertexAttribP3ui+    , glVertexAttribP3uiv+    , glVertexAttribP4ui+    , glVertexAttribP4uiv+    , glTexStorage1D+    , glTexStorage2D+    , glTexStorage3D+    , glDebugMessageControl+    , glDebugMessageInsert+    , glDebugMessageCallback+    , glGetDebugMessageLog+    , glPushDebugGroup+    , glPopDebugGroup+    , glObjectLabel+    , glGetObjectLabel+    , glObjectPtrLabel+    , glGetObjectPtrLabel+    , glGetPointerv+    , glDebugMessageControlKHR+    , glDebugMessageInsertKHR+    , glDebugMessageCallbackKHR+    , glGetDebugMessageLogKHR+    , glPushDebugGroupKHR+    , glPopDebugGroupKHR+    , glObjectLabelKHR+    , glGetObjectLabelKHR+    , glObjectPtrLabelKHR+    , glGetObjectPtrLabelKHR+    , glGetPointervKHR+    , glMatrixLoadfEXT+    , glMatrixLoaddEXT+    , glMatrixMultfEXT+    , glMatrixMultdEXT+    , glMatrixLoadIdentityEXT+    , glMatrixRotatefEXT+    , glMatrixRotatedEXT+    , glMatrixScalefEXT+    , glMatrixScaledEXT+    , glMatrixTranslatefEXT+    , glMatrixTranslatedEXT+    , glMatrixFrustumEXT+    , glMatrixOrthoEXT+    , glMatrixPopEXT+    , glMatrixPushEXT+    , glClientAttribDefaultEXT+    , glPushClientAttribDefaultEXT+    , glTextureParameterfEXT+    , glTextureParameterfvEXT+    , glTextureParameteriEXT+    , glTextureParameterivEXT+    , glTextureImage1DEXT+    , glTextureImage2DEXT+    , glTextureSubImage1DEXT+    , glTextureSubImage2DEXT+    , glCopyTextureImage1DEXT+    , glCopyTextureImage2DEXT+    , glCopyTextureSubImage1DEXT+    , glCopyTextureSubImage2DEXT+    , glGetTextureImageEXT+    , glGetTextureParameterfvEXT+    , glGetTextureParameterivEXT+    , glGetTextureLevelParameterfvEXT+    , glGetTextureLevelParameterivEXT+    , glTextureImage3DEXT+    , glTextureSubImage3DEXT+    , glCopyTextureSubImage3DEXT+    , glBindMultiTextureEXT+    , glMultiTexCoordPointerEXT+    , glMultiTexEnvfEXT+    , glMultiTexEnvfvEXT+    , glMultiTexEnviEXT+    , glMultiTexEnvivEXT+    , glMultiTexGendEXT+    , glMultiTexGendvEXT+    , glMultiTexGenfEXT+    , glMultiTexGenfvEXT+    , glMultiTexGeniEXT+    , glMultiTexGenivEXT+    , glGetMultiTexEnvfvEXT+    , glGetMultiTexEnvivEXT+    , glGetMultiTexGendvEXT+    , glGetMultiTexGenfvEXT+    , glGetMultiTexGenivEXT+    , glMultiTexParameteriEXT+    , glMultiTexParameterivEXT+    , glMultiTexParameterfEXT+    , glMultiTexParameterfvEXT+    , glMultiTexImage1DEXT+    , glMultiTexImage2DEXT+    , glMultiTexSubImage1DEXT+    , glMultiTexSubImage2DEXT+    , glCopyMultiTexImage1DEXT+    , glCopyMultiTexImage2DEXT+    , glCopyMultiTexSubImage1DEXT+    , glCopyMultiTexSubImage2DEXT+    , glGetMultiTexImageEXT+    , glGetMultiTexParameterfvEXT+    , glGetMultiTexParameterivEXT+    , glGetMultiTexLevelParameterfvEXT+    , glGetMultiTexLevelParameterivEXT+    , glMultiTexImage3DEXT+    , glMultiTexSubImage3DEXT+    , glCopyMultiTexSubImage3DEXT+    , glEnableClientStateIndexedEXT+    , glDisableClientStateIndexedEXT+    , glGetFloatIndexedvEXT+    , glGetDoubleIndexedvEXT+    , glGetPointerIndexedvEXT+    , glEnableIndexedEXT+    , glDisableIndexedEXT+    , glIsEnabledIndexedEXT+    , glGetIntegerIndexedvEXT+    , glGetBooleanIndexedvEXT+    , glCompressedTextureImage3DEXT+    , glCompressedTextureImage2DEXT+    , glCompressedTextureImage1DEXT+    , glCompressedTextureSubImage3DEXT+    , glCompressedTextureSubImage2DEXT+    , glCompressedTextureSubImage1DEXT+    , glGetCompressedTextureImageEXT+    , glCompressedMultiTexImage3DEXT+    , glCompressedMultiTexImage2DEXT+    , glCompressedMultiTexImage1DEXT+    , glCompressedMultiTexSubImage3DEXT+    , glCompressedMultiTexSubImage2DEXT+    , glCompressedMultiTexSubImage1DEXT+    , glGetCompressedMultiTexImageEXT+    , glMatrixLoadTransposefEXT+    , glMatrixLoadTransposedEXT+    , glMatrixMultTransposefEXT+    , glMatrixMultTransposedEXT+    , glNamedBufferDataEXT+    , glNamedBufferSubDataEXT+    , glMapNamedBufferEXT+    , glUnmapNamedBufferEXT+    , glGetNamedBufferParameterivEXT+    , glGetNamedBufferPointervEXT+    , glGetNamedBufferSubDataEXT+    , glProgramUniform1fEXT+    , glProgramUniform2fEXT+    , glProgramUniform3fEXT+    , glProgramUniform4fEXT+    , glProgramUniform1iEXT+    , glProgramUniform2iEXT+    , glProgramUniform3iEXT+    , glProgramUniform4iEXT+    , glProgramUniform1fvEXT+    , glProgramUniform2fvEXT+    , glProgramUniform3fvEXT+    , glProgramUniform4fvEXT+    , glProgramUniform1ivEXT+    , glProgramUniform2ivEXT+    , glProgramUniform3ivEXT+    , glProgramUniform4ivEXT+    , glProgramUniformMatrix2fvEXT+    , glProgramUniformMatrix3fvEXT+    , glProgramUniformMatrix4fvEXT+    , glProgramUniformMatrix2x3fvEXT+    , glProgramUniformMatrix3x2fvEXT+    , glProgramUniformMatrix2x4fvEXT+    , glProgramUniformMatrix4x2fvEXT+    , glProgramUniformMatrix3x4fvEXT+    , glProgramUniformMatrix4x3fvEXT+    , glTextureBufferEXT+    , glMultiTexBufferEXT+    , glTextureParameterIivEXT+    , glTextureParameterIuivEXT+    , glGetTextureParameterIivEXT+    , glGetTextureParameterIuivEXT+    , glMultiTexParameterIivEXT+    , glMultiTexParameterIuivEXT+    , glGetMultiTexParameterIivEXT+    , glGetMultiTexParameterIuivEXT+    , glProgramUniform1uiEXT+    , glProgramUniform2uiEXT+    , glProgramUniform3uiEXT+    , glProgramUniform4uiEXT+    , glProgramUniform1uivEXT+    , glProgramUniform2uivEXT+    , glProgramUniform3uivEXT+    , glProgramUniform4uivEXT+    , glNamedProgramLocalParameters4fvEXT+    , glNamedProgramLocalParameterI4iEXT+    , glNamedProgramLocalParameterI4ivEXT+    , glNamedProgramLocalParametersI4ivEXT+    , glNamedProgramLocalParameterI4uiEXT+    , glNamedProgramLocalParameterI4uivEXT+    , glNamedProgramLocalParametersI4uivEXT+    , glGetNamedProgramLocalParameterIivEXT+    , glGetNamedProgramLocalParameterIuivEXT+    , glEnableClientStateiEXT+    , glDisableClientStateiEXT+    , glGetFloati_vEXT+    , glGetDoublei_vEXT+    , glGetPointeri_vEXT+    , glNamedProgramStringEXT+    , glNamedProgramLocalParameter4dEXT+    , glNamedProgramLocalParameter4dvEXT+    , glNamedProgramLocalParameter4fEXT+    , glNamedProgramLocalParameter4fvEXT+    , glGetNamedProgramLocalParameterdvEXT+    , glGetNamedProgramLocalParameterfvEXT+    , glGetNamedProgramivEXT+    , glGetNamedProgramStringEXT+    , glNamedRenderbufferStorageEXT+    , glGetNamedRenderbufferParameterivEXT+    , glNamedRenderbufferStorageMultisampleEXT+    , glNamedRenderbufferStorageMultisampleCoverageEXT+    , glCheckNamedFramebufferStatusEXT+    , glNamedFramebufferTexture1DEXT+    , glNamedFramebufferTexture2DEXT+    , glNamedFramebufferTexture3DEXT+    , glNamedFramebufferRenderbufferEXT+    , glGetNamedFramebufferAttachmentParameterivEXT+    , glGenerateTextureMipmapEXT+    , glGenerateMultiTexMipmapEXT+    , glFramebufferDrawBufferEXT+    , glFramebufferDrawBuffersEXT+    , glFramebufferReadBufferEXT+    , glGetFramebufferParameterivEXT+    , glNamedCopyBufferSubDataEXT+    , glNamedFramebufferTextureEXT+    , glNamedFramebufferTextureLayerEXT+    , glNamedFramebufferTextureFaceEXT+    , glTextureRenderbufferEXT+    , glMultiTexRenderbufferEXT+    , glVertexArrayVertexOffsetEXT+    , glVertexArrayColorOffsetEXT+    , glVertexArrayEdgeFlagOffsetEXT+    , glVertexArrayIndexOffsetEXT+    , glVertexArrayNormalOffsetEXT+    , glVertexArrayTexCoordOffsetEXT+    , glVertexArrayMultiTexCoordOffsetEXT+    , glVertexArrayFogCoordOffsetEXT+    , glVertexArraySecondaryColorOffsetEXT+    , glVertexArrayVertexAttribOffsetEXT+    , glVertexArrayVertexAttribIOffsetEXT+    , glEnableVertexArrayEXT+    , glDisableVertexArrayEXT+    , glEnableVertexArrayAttribEXT+    , glDisableVertexArrayAttribEXT+    , glGetVertexArrayIntegervEXT+    , glGetVertexArrayPointervEXT+    , glGetVertexArrayIntegeri_vEXT+    , glGetVertexArrayPointeri_vEXT+    , glMapNamedBufferRangeEXT+    , glFlushMappedNamedBufferRangeEXT+    , glNamedBufferStorageEXT+    , glClearNamedBufferDataEXT+    , glClearNamedBufferSubDataEXT+    , glNamedFramebufferParameteriEXT+    , glGetNamedFramebufferParameterivEXT+    , glProgramUniform1dEXT+    , glProgramUniform2dEXT+    , glProgramUniform3dEXT+    , glProgramUniform4dEXT+    , glProgramUniform1dvEXT+    , glProgramUniform2dvEXT+    , glProgramUniform3dvEXT+    , glProgramUniform4dvEXT+    , glProgramUniformMatrix2dvEXT+    , glProgramUniformMatrix3dvEXT+    , glProgramUniformMatrix4dvEXT+    , glProgramUniformMatrix2x3dvEXT+    , glProgramUniformMatrix2x4dvEXT+    , glProgramUniformMatrix3x2dvEXT+    , glProgramUniformMatrix3x4dvEXT+    , glProgramUniformMatrix4x2dvEXT+    , glProgramUniformMatrix4x3dvEXT+    , glTextureBufferRangeEXT+    , glTextureStorage1DEXT+    , glTextureStorage2DEXT+    , glTextureStorage3DEXT+    , glTextureStorage2DMultisampleEXT+    , glTextureStorage3DMultisampleEXT+    , glVertexArrayBindVertexBufferEXT+    , glVertexArrayVertexAttribFormatEXT+    , glVertexArrayVertexAttribIFormatEXT+    , glVertexArrayVertexAttribLFormatEXT+    , glVertexArrayVertexAttribBindingEXT+    , glVertexArrayVertexBindingDivisorEXT+    , glVertexArrayVertexAttribLOffsetEXT+    , glTexturePageCommitmentEXT+    , glVertexArrayVertexAttribDivisorEXT+    , glBufferStorage+    , glUseProgramStages+    , glActiveShaderProgram+    , glCreateShaderProgramv+    , glBindProgramPipeline+    , glDeleteProgramPipelines+    , glGenProgramPipelines+    , glIsProgramPipeline+    , glGetProgramPipelineiv+    , glProgramUniform1i+    , glProgramUniform1iv+    , glProgramUniform1f+    , glProgramUniform1fv+    , glProgramUniform1d+    , glProgramUniform1dv+    , glProgramUniform1ui+    , glProgramUniform1uiv+    , glProgramUniform2i+    , glProgramUniform2iv+    , glProgramUniform2f+    , glProgramUniform2fv+    , glProgramUniform2d+    , glProgramUniform2dv+    , glProgramUniform2ui+    , glProgramUniform2uiv+    , glProgramUniform3i+    , glProgramUniform3iv+    , glProgramUniform3f+    , glProgramUniform3fv+    , glProgramUniform3d+    , glProgramUniform3dv+    , glProgramUniform3ui+    , glProgramUniform3uiv+    , glProgramUniform4i+    , glProgramUniform4iv+    , glProgramUniform4f+    , glProgramUniform4fv+    , glProgramUniform4d+    , glProgramUniform4dv+    , glProgramUniform4ui+    , glProgramUniform4uiv+    , glProgramUniformMatrix2fv+    , glProgramUniformMatrix3fv+    , glProgramUniformMatrix4fv+    , glProgramUniformMatrix2dv+    , glProgramUniformMatrix3dv+    , glProgramUniformMatrix4dv+    , glProgramUniformMatrix2x3fv+    , glProgramUniformMatrix3x2fv+    , glProgramUniformMatrix2x4fv+    , glProgramUniformMatrix4x2fv+    , glProgramUniformMatrix3x4fv+    , glProgramUniformMatrix4x3fv+    , glProgramUniformMatrix2x3dv+    , glProgramUniformMatrix3x2dv+    , glProgramUniformMatrix2x4dv+    , glProgramUniformMatrix4x2dv+    , glProgramUniformMatrix3x4dv+    , glProgramUniformMatrix4x3dv+    , glValidateProgramPipeline+    , glGetProgramPipelineInfoLog+    , glInvalidateTexSubImage+    , glInvalidateTexImage+    , glInvalidateBufferSubData+    , glInvalidateBufferData+    , glInvalidateFramebuffer+    , glInvalidateSubFramebuffer+    , gl_UNSIGNED_INT_10_10_10_2_EXT+    , gl_ACTIVE_RESOURCES+    , gl_MAX_GEOMETRY_SHADER_INVOCATIONS+    , gl_RESTART_PATH_NV+    , gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV+    , gl_PACK_SKIP_IMAGES+    , gl_IMAGE_CLASS_2_X_16+    , gl_FRAMEBUFFER_COMPLETE+    , gl_HSL_LUMINOSITY_NV+    , gl_IMAGE_BINDING_LAYERED_EXT+    , gl_ZOOM_Y+    , gl_TEXTURE_LUMINANCE_TYPE_ARB+    , gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB+    , gl_TEXTURE_HEIGHT+    , gl_OUTPUT_TEXTURE_COORD0_EXT+    , gl_FLOAT_CLEAR_COLOR_VALUE_NV+    , gl_LIGHT_MODEL_AMBIENT+    , gl_INT16_VEC3_NV+    , gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV+    , gl_MATRIX6_NV+    , gl_COMPUTE_PROGRAM_NV+    , gl_SCALED_RESOLVE_FASTEST_EXT+    , gl_REPLACEMENT_CODE_ARRAY_SUN+    , gl_TEXTURE_DT_SIZE_NV+    , gl_NUM_SPARSE_LEVELS_ARB+    , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR+    , gl_NO_ERROR+    , gl_INTERNALFORMAT_ALPHA_TYPE+    , gl_FONT_HEIGHT_BIT_NV+    , gl_TANGENT_ARRAY_POINTER_EXT+    , gl_LOCAL_CONSTANT_VALUE_EXT+    , gl_READ_WRITE+    , gl_TEXTURE_2D+    , gl_UNSIGNED_INT_2_10_10_10_REV_EXT+    , gl_TEXTURE_WRAP_R+    , gl_FLOAT_MAT4x2+    , gl_MAX_COMPUTE_WORK_GROUP_SIZE+    , gl_POLYGON_OFFSET_CLAMP_EXT+    , gl_SYNC_FLUSH_COMMANDS_BIT+    , gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB+    , gl_INT_IMAGE_BUFFER+    , gl_VERTEX_ATTRIB_ARRAY_TYPE+    , gl_ONE+    , gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI+    , gl_TRANSLATE_X_NV+    , gl_HI_SCALE_NV+    , gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT+    , gl_HILO_NV+    , gl_TRIANGLES+    , gl_LINEARLIGHT_NV+    , gl_MAX_3D_TEXTURE_SIZE_OES+    , gl_ANY_SAMPLES_PASSED_CONSERVATIVE+    , gl_UNIFORM_BLOCK_BINDING+    , gl_MAX_TESS_CONTROL_INPUT_COMPONENTS+    , gl_TEXTURE_ALPHA_TYPE_ARB+    , gl_MAX_CONVOLUTION_HEIGHT+    , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS+    , gl_DEPTH_BUFFER_BIT5_QCOM+    , gl_PROGRAM_TEX_INDIRECTIONS_ARB+    , gl_BLUE+    , gl_RGBA_S3TC+    , gl_DECR+    , gl_MAJOR_VERSION+    , gl_ARRAY_STRIDE+    , gl_CONSTANT_COLOR1_NV+    , gl_SAMPLES_EXT+    , gl_MAX_SAMPLES_APPLE+    , gl_COLOR_ARRAY_SIZE+    , gl_SAMPLE_ALPHA_TO_MASK_SGIS+    , gl_DUP_LAST_CUBIC_CURVE_TO_NV+    , gl_TEXTURE10+    , gl_R1UI_T2F_C4F_N3F_V3F_SUN+    , gl_MAX_VARYING_COMPONENTS+    , gl_DRAW_BUFFER7_EXT+    , gl_MAX_COMBINED_ATOMIC_COUNTERS+    , gl_PROGRAM_ERROR_STRING_ARB+    , gl_TRACE_ALL_BITS_MESA+    , gl_DEPTH_CLAMP_NV+    , gl_REDUCE+    , gl_UNSIGNED_SHORT_4_4_4_4+    , gl_SKIP_COMPONENTS1_NV+    , gl_PIXEL_TILE_CACHE_INCREMENT_SGIX+    , gl_COLOR_ARRAY+    , gl_STATIC_VERTEX_ARRAY_IBM+    , gl_INDEX_BIT_PGI+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT+    , gl_ETC1_SRGB8_NV+    , gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS+    , gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT+    , gl_LIGHT_MODEL_COLOR_CONTROL_EXT+    , gl_PATCH_DEFAULT_OUTER_LEVEL_EXT+    , gl_SAMPLER_CUBE_ARB+    , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT+    , gl_STORAGE_PRIVATE_APPLE+    , gl_MAP1_TEXTURE_COORD_2+    , gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN+    , gl_VERTEX_ATTRIB_ARRAY8_NV+    , gl_LUMINANCE16F_ARB+    , gl_DEPTH_COMPONENT32F_NV+    , gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT+    , gl_MATRIX28_ARB+    , gl_SYNC_FLUSH_COMMANDS_BIT_APPLE+    , gl_READ_FRAMEBUFFER_BINDING_ANGLE+    , gl_FOG_COORDINATE_ARRAY_TYPE+    , gl_RGBA32UI_EXT+    , gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG+    , gl_2_BYTES_NV+    , gl_TEXTURE_HI_SIZE_NV+    , gl_PACK_SWAP_BYTES+    , gl_EVAL_FRACTIONAL_TESSELLATION_NV+    , gl_RG16+    , gl_SWIZZLE_STR_ATI+    , gl_CON_6_ATI+    , gl_PATH_FOG_GEN_MODE_NV+    , gl_SRGB8_ALPHA8_EXT+    , gl_COMPRESSED_SLUMINANCE_ALPHA_EXT+    , gl_TEXTURE_COMPARE_FUNC_EXT+    , gl_UNIFORM_MATRIX_STRIDE+    , gl_INVALID_OPERATION+    , gl_DRAW_BUFFER4_ATI+    , gl_BYTE+    , gl_SECONDARY_COLOR_ARRAY_POINTER+    , gl_TEXTURE_CUBE_MAP_POSITIVE_X+    , gl_TEXTURE_2D_ARRAY+    , gl_OFFSET_TEXTURE_MATRIX_NV+    , gl_FLOAT_MAT2x4+    , gl_REG_31_ATI+    , gl_DEBUG_TYPE_PORTABILITY+    , gl_SAMPLER_2D_ARB+    , gl_DRAW_BUFFER11+    , gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS+    , gl_TEXTURE5_ARB+    , gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT+    , gl_COLOR_TABLE_SCALE+    , gl_POINT_FADE_THRESHOLD_SIZE_SGIS+    , gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB+    , gl_ACCUM_CLEAR_VALUE+    , gl_OPERAND0_ALPHA_EXT+    , gl_QUERY_NO_WAIT+    , gl_PRIMITIVE_RESTART+    , gl_STENCIL_ATTACHMENT_OES+    , gl_BUFFER_USAGE+    , gl_COLOR_TABLE_BLUE_SIZE+    , gl_VERTEX_ARRAY_SIZE_EXT+    , gl_ALPHA8+    , gl_PROXY_TEXTURE_2D+    , gl_HALF_BIT_ATI+    , gl_TRANSPOSE_MODELVIEW_MATRIX+    , gl_DRAW_BUFFER3+    , gl_4PASS_2_SGIS+    , gl_MAX_GEOMETRY_OUTPUT_COMPONENTS+    , gl_SAMPLER_2D_ARRAY_SHADOW_EXT+    , gl_TEXTURE_FORMAT_QCOM+    , gl_RGB16_SNORM+    , gl_DRAW_BUFFER8_NV+    , gl_AUX_BUFFERS+    , gl_CONVOLUTION_HINT_SGIX+    , gl_FOG_COLOR+    , gl_COLOR_TABLE_RED_SIZE_SGI+    , gl_FUNC_SUBTRACT_OES+    , gl_LUMINANCE_ALPHA16F_ARB+    , gl_MODELVIEW10_ARB+    , gl_LOGIC_OP+    , gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB+    , gl_SOURCE0_ALPHA_EXT+    , gl_INDEX_SHIFT+    , gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS+    , gl_RG32F_EXT+    , gl_GEOMETRY_LINKED_VERTICES_OUT_EXT+    , gl_STACK_UNDERFLOW_KHR+    , gl_TESS_GEN_POINT_MODE_EXT+    , gl_BUFFER_ACCESS_ARB+    , gl_DOT_PRODUCT_NV+    , gl_INVERTED_SCREEN_W_REND+    , gl_REG_11_ATI+    , gl_MAX_FRAMEZOOM_FACTOR_SGIX+    , gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD+    , gl_MATRIX20_ARB+    , gl_EVAL_VERTEX_ATTRIB1_NV+    , gl_COLOR_ATTACHMENT10_NV+    , gl_OUTPUT_TEXTURE_COORD28_EXT+    , gl_MAX_TEXTURE_COORDS_ARB+    , gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL+    , gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES+    , gl_RENDERBUFFER_BLUE_SIZE+    , gl_MULTISAMPLE_BIT+    , gl_CURRENT_PROGRAM+    , gl_AUX_DEPTH_STENCIL_APPLE+    , gl_LUMINANCE8_ALPHA8_EXT+    , gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV+    , gl_INTERLACE_OML+    , gl_REG_27_ATI+    , gl_UNSIGNED_INT_24_8_OES+    , gl_COMBINER_AB_OUTPUT_NV+    , gl_CURRENT_RASTER_INDEX+    , gl_SYNC_FENCE_APPLE+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT+    , gl_MAX_TEXTURE_SIZE+    , gl_TEXTURE24+    , gl_STENCIL_BACK_FUNC+    , gl_LUMINANCE12+    , gl_PARAMETER_BUFFER_ARB+    , gl_AUX2+    , gl_SLICE_ACCUM_SUN+    , gl_COLOR_TABLE_ALPHA_SIZE+    , gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT+    , gl_DRAW_FRAMEBUFFER_BINDING_ANGLE+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER+    , gl_SUBTRACT+    , gl_MAX_PROGRAM_IF_DEPTH_NV+    , gl_T2F_C4F_N3F_V3F+    , gl_ACTIVE_SUBROUTINE_UNIFORMS+    , gl_EMBOSS_LIGHT_NV+    , gl_POINT_SIZE_RANGE+    , gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT+    , gl_CLAMP_TO_BORDER+    , gl_TEXTURE_BUFFER_OFFSET_EXT+    , gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV+    , gl_COMPRESSED_INTENSITY+    , gl_MAX_PROGRAM_OUTPUT_VERTICES_NV+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES+    , gl_MAX_PROGRAM_ATTRIBS_ARB+    , gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI+    , gl_TEXTURE_3D_BINDING_EXT+    , gl_SHADER_STORAGE_BUFFER_START+    , gl_MAP2_INDEX+    , gl_CONSTANT_COLOR_EXT+    , gl_RG32UI+    , gl_BGRA+    , gl_FRAGMENT_DEPTH_EXT+    , gl_GENERATE_MIPMAP_HINT_SGIS+    , gl_DIFFERENCE_NV+    , gl_UNSIGNED_SHORT_1_15_REV_MESA+    , gl_PROGRAM_BINARY_RETRIEVABLE_HINT+    , gl_RGBA32I+    , gl_UNSIGNED_INT_8_8_8_8+    , gl_DOMAIN+    , gl_COLOR_MATRIX+    , gl_PROGRAM_NATIVE_ATTRIBS_ARB+    , gl_OP_ROUND_EXT+    , gl_VIEW_CLASS_96_BITS+    , gl_TEXTURE_WRAP_R_OES+    , gl_VERTEX_ARRAY_TYPE+    , gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV+    , gl_PIXEL_MAP_R_TO_R_SIZE+    , gl_UNSIGNED_NORMALIZED_ARB+    , gl_UNSIGNED_INT8_VEC3_NV+    , gl_COMPRESSED_RGBA8_ETC2_EAC_OES+    , gl_HI_BIAS_NV+    , gl_SECONDARY_COLOR_ARRAY_EXT+    , gl_BUFFER_MAP_OFFSET+    , gl_LUMINANCE4_ALPHA4_OES+    , gl_FORMAT_SUBSAMPLE_244_244_OML+    , gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA+    , gl_PLUS_CLAMPED_ALPHA_NV+    , gl_COLOR_ATTACHMENT0_NV+    , gl_COMPRESSED_RGB_S3TC_DXT1_EXT+    , gl_GEOMETRY_OUTPUT_TYPE+    , gl_INTENSITY8_EXT+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT+    , gl_COMPRESSED_RED_GREEN_RGTC2_EXT+    , gl_DEBUG_SOURCE_API_KHR+    , gl_BLEND_PREMULTIPLIED_SRC_NV+    , gl_CLIENT_STORAGE_BIT+    , gl_INTENSITY12_EXT+    , gl_MATRIX_INDEX_ARRAY_STRIDE_OES+    , gl_CURRENT_RASTER_SECONDARY_COLOR+    , gl_REPLACE+    , gl_LINEAR+    , gl_COMBINER_INPUT_NV+    , gl_TRANSFORM_FEEDBACK_VARYINGS+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES+    , gl_IMAGE_BINDING_ACCESS+    , gl_NUM_LOOPBACK_COMPONENTS_ATI+    , gl_ARRAY_ELEMENT_LOCK_COUNT_EXT+    , gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN+    , gl_TEXTURE_4DSIZE_SGIS+    , gl_COUNTER_RANGE_AMD+    , gl_RGB8_OES+    , gl_ALPHA16F_EXT+    , gl_C4F_N3F_V3F+    , gl_NEAREST_MIPMAP_LINEAR+    , gl_DEBUG_SEVERITY_LOW_KHR+    , gl_DISCARD_ATI+    , gl_LOCAL_CONSTANT_DATATYPE_EXT+    , gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT+    , gl_LOWER_LEFT+    , gl_RENDERBUFFER_HEIGHT_OES+    , gl_SPRITE_MODE_SGIX+    , gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN+    , gl_UNSIGNED_INT8_VEC2_NV+    , gl_NONE_OES+    , gl_POINT_SIZE_MIN_ARB+    , gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV+    , gl_RENDERBUFFER_DEPTH_SIZE_EXT+    , gl_BUFFER_MAP_LENGTH+    , gl_WRITE_ONLY+    , gl_NEAREST_CLIPMAP_NEAREST_SGIX+    , gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV+    , gl_ALREADY_SIGNALED_APPLE+    , gl_REPLICATE_BORDER+    , gl_SUBPIXEL_BITS+    , gl_ALPHA_MIN_SGIX+    , gl_BLUE_BIT_ATI+    , gl_UNSIGNED_INT_IMAGE_2D_EXT+    , gl_TRANSFORM_FEEDBACK_VARYINGS_EXT+    , gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT+    , gl_PIXEL_COUNTER_BITS_NV+    , gl_422_REV_AVERAGE_EXT+    , gl_TEXTURE_RESIDENT_EXT+    , gl_STENCIL_WRITEMASK+    , gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES+    , gl_FLOAT_VEC3_ARB+    , gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM+    , gl_DYNAMIC_STORAGE_BIT+    , gl_DRAW_FRAMEBUFFER_BINDING_APPLE+    , gl_CLIP_PLANE4_IMG+    , gl_CON_26_ATI+    , gl_COMPRESSED_SIGNED_R11_EAC_OES+    , gl_LINES_ADJACENCY_EXT+    , gl_AUTO_GENERATE_MIPMAP+    , gl_OP_EXP_BASE_2_EXT+    , gl_ATTRIB_STACK_DEPTH+    , gl_ALPHA32F_EXT+    , gl_KEEP+    , gl_TEXTURE_FILTER4_SIZE_SGIS+    , gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT+    , gl_INT_VEC3+    , gl_MATRIX_MODE+    , gl_UNSIGNED_NORMALIZED+    , gl_DEBUG_PRINT_MESA+    , gl_DST_OUT_NV+    , gl_CLEAR_BUFFER+    , gl_COMBINER_SCALE_NV+    , gl_WRITE_ONLY_OES+    , gl_422_AVERAGE_EXT+    , gl_COLOR_INDEX12_EXT+    , gl_COLOR_BUFFER_BIT0_QCOM+    , gl_CAVEAT_SUPPORT+    , gl_BLUE_INTEGER+    , gl_IUI_N3F_V2F_EXT+    , gl_VERTEX_DATA_HINT_PGI+    , gl_REG_13_ATI+    , gl_NEGATIVE_ONE_EXT+    , gl_CON_16_ATI+    , gl_TEXTURE_EXTERNAL_OES+    , gl_SHADER_TYPE+    , gl_OVERLAY_KHR+    , gl_LUMINANCE6_ALPHA2_EXT+    , gl_COLOR_TABLE_SGI+    , gl_TEXTURE_STENCIL_SIZE_EXT+    , gl_NEAREST+    , gl_RGB8I+    , gl_TEXTURE_SPARSE_ARB+    , gl_MATRIX9_ARB+    , gl_TEXTURE_TARGET+    , gl_SECONDARY_COLOR_ARRAY_TYPE_EXT+    , gl_RENDERER+    , gl_TEXTURE_BINDING_BUFFER+    , gl_INT_VEC3_ARB+    , gl_MATRIX12_ARB+    , gl_VERTEX_ATTRIB_ARRAY_ENABLED+    , gl_RENDERBUFFER_SAMPLES_NV+    , gl_COLOR_ATTACHMENT1_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE+    , gl_LINEAR_DETAIL_SGIS+    , gl_CURRENT_RASTER_POSITION_VALID+    , gl_LINEAR_DETAIL_COLOR_SGIS+    , gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT+    , gl_POINT_SIZE_MIN_EXT+    , gl_GPU_DISJOINT_EXT+    , gl_LIGHT_MODEL_COLOR_CONTROL+    , gl_MAX_TESS_PATCH_COMPONENTS+    , gl_CURRENT_PALETTE_MATRIX_OES+    , gl_SAMPLES_SGIS+    , gl_FUNC_REVERSE_SUBTRACT_OES+    , gl_TEXTURE13_ARB+    , gl_SMOOTH_CUBIC_CURVE_TO_NV+    , gl_COMPRESSED_RGBA_ASTC_3x3x3_OES+    , gl_MODELVIEW15_ARB+    , gl_EYE_PLANE_ABSOLUTE_NV+    , gl_READ_FRAMEBUFFER_BINDING_NV+    , gl_RENDERBUFFER_RED_SIZE+    , gl_PIXEL_PACK_BUFFER_BINDING_EXT+    , gl_MAX_RENDERBUFFER_SIZE+    , gl_DOUBLE_MAT4_EXT+    , gl_COMPRESSED_R11_EAC+    , gl_INT_IMAGE_2D_RECT+    , gl_MAD_ATI+    , gl_IMAGE_CLASS_4_X_32+    , gl_VIDEO_COLOR_CONVERSION_OFFSET_NV+    , gl_BOOL_VEC4+    , gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB+    , gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES+    , gl_HISTOGRAM_FORMAT_EXT+    , gl_UNSIGNED_INT_8_8_8_8_REV_EXT+    , gl_R1UI_C3F_V3F_SUN+    , gl_SAMPLER_1D_ARRAY_SHADOW_EXT+    , gl_TEXTURE_BINDING_2D_ARRAY+    , gl_TEXTURE_RANGE_POINTER_APPLE+    , gl_SMALL_CCW_ARC_TO_NV+    , gl_SHADER_COMPILER+    , gl_DEPTH_COMPONENT24_ARB+    , gl_COLOR_ATTACHMENT14_NV+    , gl_TIME_ELAPSED+    , gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT+    , gl_MATRIX11_ARB+    , gl_XOR+    , gl_HSL_SATURATION_KHR+    , gl_R1UI_T2F_V3F_SUN+    , gl_COMPUTE_WORK_GROUP_SIZE+    , gl_BLEND_EQUATION_EXT+    , gl_SAMPLER+    , gl_NUM_FRAGMENT_REGISTERS_ATI+    , gl_REG_5_ATI+    , gl_DSDT8_MAG8_INTENSITY8_NV+    , gl_PIXEL_MAP_S_TO_S_SIZE+    , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT+    , gl_OR_REVERSE+    , gl_QUERY_BUFFER_BARRIER_BIT+    , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING+    , gl_SAMPLER_1D+    , gl_COLOR_TABLE_INTENSITY_SIZE+    , gl_TRIANGLE_FAN+    , gl_POINT_SIZE_MAX_SGIS+    , gl_ELEMENT_ARRAY_POINTER_ATI+    , gl_INT_IMAGE_1D_EXT+    , gl_CONVOLUTION_FILTER_SCALE_EXT+    , gl_EVAL_VERTEX_ATTRIB8_NV+    , gl_DYNAMIC_COPY_ARB+    , gl_REG_12_ATI+    , gl_SIGNED_NORMALIZED+    , gl_REG_8_ATI+    , gl_SAMPLE_COVERAGE_ARB+    , gl_ALLOW_DRAW_MEM_HINT_PGI+    , gl_INTENSITY16F_ARB+    , gl_PATH_FORMAT_PS_NV+    , gl_TEXTURE_FREE_MEMORY_ATI+    , gl_SYNC_FENCE+    , gl_WRITE_ONLY_ARB+    , gl_INVERT+    , gl_TRANSLATE_Y_NV+    , gl_SAMPLER_3D+    , gl_LINE_STRIP_ADJACENCY+    , gl_OPERAND2_RGB_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG+    , gl_COLOR_ARRAY_ADDRESS_NV+    , gl_POST_CONVOLUTION_BLUE_SCALE_EXT+    , gl_HIGH_FLOAT+    , gl_TESS_GEN_MODE_EXT+    , gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV+    , gl_MAX_LABEL_LENGTH+    , gl_QUERY_BY_REGION_NO_WAIT+    , gl_OP_RECIP_EXT+    , gl_PROXY_TEXTURE_2D_ARRAY+    , gl_COMPRESSED_RGBA_FXT1_3DFX+    , gl_PRIMITIVES_GENERATED+    , gl_TEXTURE26_ARB+    , gl_TESS_EVALUATION_TEXTURE+    , gl_TEXTURE1+    , gl_TRANSFORM_FEEDBACK_RECORD_NV+    , gl_DRAW_FRAMEBUFFER_NV+    , gl_MODELVIEW8_ARB+    , gl_UNSIGNED_INT_SAMPLER_BUFFER+    , gl_CONVOLUTION_1D+    , gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV+    , gl_SAMPLER_1D_ARRAY+    , gl_TRANSFORM_FEEDBACK_BINDING+    , gl_LIGHTING_BIT+    , gl_R1UI_C4F_N3F_V3F_SUN+    , gl_TEXTURE_RED_SIZE_EXT+    , gl_VERTEX_ARRAY_KHR+    , gl_ALPHA_BITS+    , gl_MAX_VERTEX_SHADER_INVARIANTS_EXT+    , gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS+    , gl_SAMPLE_MASK_INVERT_EXT+    , gl_TRANSPOSE_PROGRAM_MATRIX_EXT+    , gl_ABGR_EXT+    , gl_MULTISAMPLE_BIT_3DFX+    , gl_MATRIX0_NV+    , gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING+    , gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG+    , gl_RGB9_E5+    , gl_IMAGE_2D_MULTISAMPLE_ARRAY+    , gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE+    , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV+    , gl_GEOMETRY_PROGRAM_NV+    , gl_RGB10_EXT+    , gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT+    , gl_ALWAYS_SOFT_HINT_PGI+    , gl_WEIGHT_ARRAY_BUFFER_BINDING+    , gl_BLEND_DST_ALPHA_OES+    , gl_UNIFORM_BUFFER_BINDING_EXT+    , gl_CONTINUOUS_AMD+    , gl_STENCIL_BUFFER_BIT4_QCOM+    , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV+    , gl_TESS_EVALUATION_SHADER_BIT+    , gl_TEXTURE_COORD_ARRAY_EXT+    , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET+    , gl_PROGRAM_INSTRUCTIONS_ARB+    , gl_PROXY_TEXTURE_3D+    , gl_CLIP_PLANE0+    , gl_CURRENT_QUERY_EXT+    , gl_T4F_C4F_N3F_V4F+    , gl_ADD+    , gl_STENCIL_EXT+    , gl_TEXTURE_BLUE_TYPE+    , gl_OUTPUT_TEXTURE_COORD8_EXT+    , gl_OBJECT_TYPE_ARB+    , gl_RESET_NOTIFICATION_STRATEGY+    , gl_UNSIGNED_INT_VEC2_EXT+    , gl_DRAW_BUFFER6_NV+    , gl_ASYNC_DRAW_PIXELS_SGIX+    , gl_INTERNALFORMAT_GREEN_SIZE+    , gl_TEXTURE_GREEN_SIZE+    , gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL+    , gl_VIRTUAL_PAGE_SIZE_Y_AMD+    , gl_OP_MUL_EXT+    , gl_NORMAL_MAP+    , gl_ALPHA16_EXT+    , gl_POINT_SIZE+    , gl_INTERNALFORMAT_SUPPORTED+    , gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT+    , gl_DEBUG_SEVERITY_HIGH_ARB+    , gl_TEXTURE_MAX_LEVEL_SGIS+    , gl_SHADING_LANGUAGE_VERSION_ARB+    , gl_STANDARD_FONT_FORMAT_NV+    , gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT+    , gl_IR_INSTRUMENT1_SGIX+    , gl_SIGNED_HILO8_NV+    , gl_RENDERBUFFER_GREEN_SIZE_OES+    , gl_REG_1_ATI+    , gl_CLAMP_TO_EDGE+    , gl_GEOMETRY_SHADER_BIT+    , gl_MODELVIEW7_ARB+    , gl_BUFFER_MAPPED_ARB+    , gl_DRAW_BUFFER12_EXT+    , gl_RGB565_OES+    , gl_SHORT+    , gl_STENCIL_BACK_FAIL_ATI+    , gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT+    , gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV+    , gl_CON_31_ATI+    , gl_RGB5+    , gl_SAMPLER_2D_RECT+    , gl_COMPRESSED_RGBA_ASTC_5x4x4_OES+    , gl_PASS_THROUGH_TOKEN+    , gl_RGBA_FLOAT32_ATI+    , gl_TEXTURE_COLOR_WRITEMASK_SGIS+    , gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS+    , gl_OUTPUT_TEXTURE_COORD23_EXT+    , gl_YCBYCR8_422_NV+    , gl_SRC_NV+    , gl_MAX_EXT+    , gl_UNPACK_COMPRESSED_BLOCK_DEPTH+    , gl_UNSIGNED_SHORT_5_5_5_1_EXT+    , gl_IMAGE_3D+    , gl_DEPTH_BUFFER_BIT0_QCOM+    , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS+    , gl_DECR_WRAP_OES+    , gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV+    , gl_SPARSE_STORAGE_BIT_ARB+    , gl_LAST_VIDEO_CAPTURE_STATUS_NV+    , gl_LAST_VERTEX_CONVENTION+    , gl_IDENTITY_NV+    , gl_RETAINED_APPLE+    , gl_FLOAT_RGB32_NV+    , gl_DRAW_BUFFER15_ARB+    , gl_COLOR_EXT+    , gl_WEIGHT_ARRAY_TYPE_OES+    , gl_DETAIL_TEXTURE_2D_BINDING_SGIS+    , gl_BGRA8_EXT+    , gl_T2F_IUI_V3F_EXT+    , gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS+    , gl_VERTEX_ARRAY_LIST_IBM+    , gl_INDEX_ARRAY_STRIDE_EXT+    , gl_SCALE_BY_ONE_HALF_NV+    , gl_PROXY_TEXTURE_4D_SGIS+    , gl_HALF_FLOAT+    , gl_FIELD_UPPER_NV+    , gl_OCCLUSION_QUERY_EVENT_MASK_AMD+    , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV+    , gl_VERTEX_ATTRIB_ARRAY4_NV+    , gl_CONVOLUTION_BORDER_COLOR_HP+    , gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT+    , gl_MODULATE+    , gl_NO_RESET_NOTIFICATION_KHR+    , gl_CURRENT_INDEX+    , gl_RED_MAX_CLAMP_INGR+    , gl_SAMPLE_ALPHA_TO_MASK_EXT+    , gl_DEBUG_CATEGORY_DEPRECATION_AMD+    , gl_EXP2+    , gl_HISTOGRAM+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR+    , gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT+    , gl_READ_FRAMEBUFFER_BINDING_APPLE+    , gl_COLOR_ATTACHMENT9+    , gl_PROXY_TEXTURE_CUBE_MAP_ARB+    , gl_SIGNED_RGB8_NV+    , gl_TEXTURE_INTENSITY_SIZE+    , gl_TEXTURE_MAX_CLAMP_S_SGIX+    , gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV+    , gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV+    , gl_TEXTURE_MAX_LOD_SGIS+    , gl_LUMINANCE+    , gl_FOG_COORD_ARRAY_BUFFER_BINDING+    , gl_OFFSET_TEXTURE_2D_BIAS_NV+    , gl_FEEDBACK+    , gl_MAGNITUDE_BIAS_NV+    , gl_POST_CONVOLUTION_ALPHA_SCALE+    , gl_PATH_TERMINAL_END_CAP_NV+    , gl_GLYPH_HEIGHT_BIT_NV+    , gl_TEXTURE_STORAGE_HINT_APPLE+    , gl_MATRIX2_NV+    , gl_RGB16I+    , gl_NUM_SHADER_BINARY_FORMATS+    , gl_MULTISAMPLE_BUFFER_BIT7_QCOM+    , gl_SAMPLE_ALPHA_TO_ONE+    , gl_CON_11_ATI+    , gl_MAP2_TEXTURE_COORD_1+    , gl_DRAW_BUFFER14_ARB+    , gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS+    , gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB+    , gl_FLOAT_RGBA_MODE_NV+    , gl_VERTEX_ATTRIB_ARRAY9_NV+    , gl_ALPHA4+    , gl_EVAL_VERTEX_ATTRIB9_NV+    , gl_VARIANT_ARRAY_POINTER_EXT+    , gl_INDEX_TEST_EXT+    , gl_MAX_RENDERBUFFER_SIZE_EXT+    , gl_MAP1_GRID_SEGMENTS+    , gl_DETAIL_TEXTURE_MODE_SGIS+    , gl_LINEARBURN_NV+    , gl_SOURCE2_ALPHA+    , gl_COLOR_ATTACHMENT9_EXT+    , gl_RENDERBUFFER_OES+    , gl_RGBA8UI+    , gl_MIPMAP+    , gl_SMOOTH_LINE_WIDTH_RANGE+    , gl_COMBINER7_NV+    , gl_VIEW_CLASS_64_BITS+    , gl_SAMPLE_MASK_VALUE_SGIS+    , gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS+    , gl_ALPHA32UI_EXT+    , gl_NONE+    , gl_MATRIX25_ARB+    , gl_DUAL_LUMINANCE_ALPHA4_SGIS+    , gl_PATCH_VERTICES+    , gl_COLOR_MATERIAL_PARAMETER+    , gl_NUM_PROGRAM_BINARY_FORMATS+    , gl_PACK_ROW_LENGTH+    , gl_RENDERBUFFER_BINDING_EXT+    , gl_FORMAT_SUBSAMPLE_24_24_OML+    , gl_RELATIVE_ROUNDED_RECT4_NV+    , gl_TEXTURE3+    , gl_DEPTH_COMPONENT16_SGIX+    , gl_SAMPLER_2D_SHADOW_EXT+    , gl_MIN_MAP_BUFFER_ALIGNMENT+    , gl_PROXY_TEXTURE_2D_ARRAY_EXT+    , gl_WEIGHT_ARRAY_TYPE_ARB+    , gl_LOW_INT+    , gl_DRAW_BUFFER11_ATI+    , gl_MAX_ELEMENTS_VERTICES_EXT+    , gl_COMPRESSED_RED_RGTC1_EXT+    , gl_RGBA+    , gl_DRAW_BUFFER0_ARB+    , gl_TEXTURE_RED_TYPE+    , gl_FENCE_APPLE+    , gl_MAX_CONVOLUTION_WIDTH_EXT+    , gl_UNSIGNED_INVERT_NV+    , gl_LIGHT6+    , gl_STREAM_COPY+    , gl_INSTRUMENT_BUFFER_POINTER_SGIX+    , gl_MODELVIEW+    , gl_RGB32F+    , gl_MAP_COLOR+    , gl_COLOR_TABLE_INTENSITY_SIZE_SGI+    , gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV+    , gl_LAYER_PROVOKING_VERTEX_EXT+    , gl_COMPRESSED_RGBA_ASTC_6x5x5_OES+    , gl_FOG_BIT+    , gl_NATIVE_GRAPHICS_HANDLE_PGI+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT+    , gl_MAX_COMPUTE_SHARED_MEMORY_SIZE+    , gl_STENCIL_INDEX1_EXT+    , gl_COLOR_ATTACHMENT2_NV+    , gl_DRAW_BUFFER5_ARB+    , gl_TEXTURE_OBJECT_VALID_QCOM+    , gl_PHONG_HINT_WIN+    , gl_MAP1_VERTEX_ATTRIB0_4_NV+    , gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX+    , gl_COLOR_TABLE_WIDTH+    , gl_INT_IMAGE_1D_ARRAY+    , gl_BUFFER_MAPPED+    , gl_TEXTURE_SWIZZLE_R+    , gl_COLOR_ATTACHMENT9_NV+    , gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER+    , gl_LUMINANCE16_ALPHA16+    , gl_PERFQUERY_GLOBAL_CONTEXT_INTEL+    , gl_POINT_FADE_THRESHOLD_SIZE_EXT+    , gl_BLEND_EQUATION_OES+    , gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES+    , gl_TEXTURE_BINDING_2D_ARRAY_EXT+    , gl_CON_7_ATI+    , gl_DUAL_LUMINANCE16_SGIS+    , gl_RASTER_POSITION_UNCLIPPED_IBM+    , gl_ALLOW_DRAW_FRG_HINT_PGI+    , gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT+    , gl_TEXTURE_COORD_ARRAY+    , gl_MAX_DEBUG_LOGGED_MESSAGES_KHR+    , gl_ARRAY_BUFFER_BINDING_ARB+    , gl_PIXEL_TEXTURE_SGIS+    , gl_STENCIL_INDEX8+    , gl_IMAGE_CLASS_10_10_10_2+    , gl_DRAW_INDIRECT_LENGTH_NV+    , gl_DEBUG_CALLBACK_FUNCTION_ARB+    , gl_INT_SAMPLER_2D_ARRAY+    , gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB+    , gl_GENERIC_ATTRIB_NV+    , gl_TEXTURE_RED_TYPE_ARB+    , gl_MAX_VERTEX_UNITS_ARB+    , gl_DEPTH_BIAS+    , gl_SRGB+    , gl_TEXTURE_COORD_ARRAY_TYPE+    , gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT+    , gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV+    , gl_CURRENT_TIME_NV+    , gl_TEXTURE_DEPTH_SIZE+    , gl_INDEX_ARRAY_LIST_STRIDE_IBM+    , gl_CLIP_PLANE1_IMG+    , gl_CULL_VERTEX_EYE_POSITION_EXT+    , gl_COPY_READ_BUFFER_NV+    , gl_CONTEXT_CORE_PROFILE_BIT+    , gl_ARC_TO_NV+    , gl_PACK_COMPRESSED_BLOCK_SIZE+    , gl_TRACE_NAME_MESA+    , gl_TEXTURE_CROP_RECT_OES+    , gl_MAP2_VERTEX_ATTRIB15_4_NV+    , gl_DRAW_INDIRECT_UNIFIED_NV+    , gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS+    , gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS+    , gl_CULL_FACE_MODE+    , gl_LUMINANCE_ALPHA_INTEGER_EXT+    , gl_SURFACE_MAPPED_NV+    , gl_FOG_COORD_ARRAY_LENGTH_NV+    , gl_R+    , gl_NUM_VIDEO_CAPTURE_STREAMS_NV+    , gl_VERTEX_PROGRAM_POINT_SIZE_NV+    , gl_CONSTANT_NV+    , gl_RGB10_A2+    , gl_INTENSITY16_EXT+    , gl_TEXTURE28+    , gl_COMPRESSED_RGBA_ASTC_4x4_KHR+    , gl_SRGB_READ+    , gl_LUMINANCE16_ALPHA16_SNORM+    , gl_UNSIGNED_INT_IMAGE_1D_ARRAY+    , gl_ELEMENT_ARRAY_TYPE_ATI+    , gl_PATCH_DEFAULT_OUTER_LEVEL+    , gl_LINE_STRIP_ADJACENCY_ARB+    , gl_POLYGON_OFFSET_POINT+    , gl_UNSIGNED_SHORT_8_8_APPLE+    , gl_DYNAMIC_ATI+    , gl_UNSIGNED_INT16_NV+    , gl_TEXTURE_BINDING_BUFFER_EXT+    , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB+    , gl_MAP2_VERTEX_ATTRIB14_4_NV+    , gl_COMPRESSED_RGB+    , gl_VERTEX_ATTRIB_ARRAY0_NV+    , gl_MIN+    , gl_COLOR_SUM+    , gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD+    , gl_RECIP_ADD_SIGNED_ALPHA_IMG+    , gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV+    , gl_SPRITE_AXIAL_SGIX+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES+    , gl_TEXTURE_ENV_BIAS_SGIX+    , gl_PROGRAM_FORMAT_ASCII_ARB+    , gl_OUTPUT_COLOR1_EXT+    , gl_SELECTION_BUFFER_SIZE+    , gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE+    , gl_INTENSITY_FLOAT16_ATI+    , gl_TEXTURE30_ARB+    , gl_TEXTURE_1D_STACK_MESAX+    , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE+    , gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM+    , gl_SIGNED_HILO_NV+    , gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT+    , gl_ACTIVE_ATTRIBUTE_MAX_LENGTH+    , gl_IMAGE_2D_RECT_EXT+    , gl_TESS_GEN_MODE+    , gl_TEXTURE_MIN_FILTER+    , gl_FLOAT_VEC4+    , gl_LIGHT2+    , gl_MODELVIEW24_ARB+    , gl_TESS_EVALUATION_SHADER+    , gl_PROXY_COLOR_TABLE_SGI+    , gl_INDEX_ARRAY_EXT+    , gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB+    , gl_FRAGMENT_INPUT_NV+    , gl_CON_13_ATI+    , gl_IMAGE_ROTATE_ORIGIN_Y_HP+    , gl_VERTEX_ARRAY_COUNT_EXT+    , gl_STENCIL_INDEX1_OES+    , gl_BUFFER_DATA_SIZE+    , gl_MAX_NAME_STACK_DEPTH+    , gl_SAMPLES_PASSED_ARB+    , gl_TEXTURE_PRE_SPECULAR_HP+    , gl_RESCALE_NORMAL_EXT+    , gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY+    , gl_TRANSLATE_2D_NV+    , gl_QUAD_INTENSITY8_SGIS+    , gl_LOCATION_INDEX+    , gl_MODELVIEW9_ARB+    , gl_CONTEXT_RELEASE_BEHAVIOR_KHR+    , gl_EDGE_FLAG_ARRAY_BUFFER_BINDING+    , gl_DEBUG_TYPE_PERFORMANCE_KHR+    , gl_POINT_DISTANCE_ATTENUATION+    , gl_PIXEL_TILE_GRID_HEIGHT_SGIX+    , gl_COLOR_ATTACHMENT3+    , gl_COUNT_UP_NV+    , gl_STENCIL_BACK_VALUE_MASK+    , gl_PERFQUERY_DONOT_FLUSH_INTEL+    , gl_VARIABLE_F_NV+    , gl_STENCIL_BACK_PASS_DEPTH_FAIL+    , gl_IMAGE_CUBIC_WEIGHT_HP+    , gl_STENCIL+    , gl_DRAW_BUFFER6_ARB+    , gl_MAX_COMBINED_IMAGE_UNIFORMS+    , gl_PROGRAM_STRING_NV+    , gl_STREAM_DRAW+    , gl_BGR_INTEGER_EXT+    , gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES+    , gl_LAYER_PROVOKING_VERTEX+    , gl_TEXTURE_ALPHA_SIZE_EXT+    , gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD+    , gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX+    , gl_VIEW_CLASS_48_BITS+    , gl_DRAW_BUFFER15_NV+    , gl_MAX_LABEL_LENGTH_KHR+    , gl_DEBUG_TYPE_PERFORMANCE+    , gl_DEPENDENT_RGB_TEXTURE_3D_NV+    , gl_MAX_GEOMETRY_ATOMIC_COUNTERS+    , gl_DRAW_BUFFER10_ARB+    , gl_FONT_UNDERLINE_THICKNESS_BIT_NV+    , gl_DRAW_BUFFER7+    , gl_TEXTURE_GREEN_TYPE_ARB+    , gl_TEXTURE_MIN_LOD_SGIS+    , gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT+    , gl_ELEMENT_ARRAY_BARRIER_BIT_EXT+    , gl_SAMPLE_COVERAGE_VALUE+    , gl_VERTEX_ATTRIB_RELATIVE_OFFSET+    , gl_COLOR_TABLE_RED_SIZE+    , gl_TRANSFORM_FEEDBACK_BUFFER_START_NV+    , gl_NAME_STACK_DEPTH+    , gl_UNSIGNED_INT_5_9_9_9_REV+    , gl_FUNC_SUBTRACT_EXT+    , gl_STENCIL_INDEX4_EXT+    , gl_TEXTURE_COMPRESSION_HINT+    , gl_DEPTH_CLAMP+    , gl_SAMPLE_COVERAGE_INVERT+    , gl_DRAW_BUFFER0_EXT+    , gl_DRAW_BUFFER4+    , gl_ALPHA_FLOAT16_ATI+    , gl_AFFINE_2D_NV+    , gl_MAX_TRACK_MATRICES_NV+    , gl_BINORMAL_ARRAY_STRIDE_EXT+    , gl_UNSIGNED_SHORT_1_5_5_5_REV+    , gl_ROUNDED_RECT4_NV+    , gl_COMMAND_BARRIER_BIT_EXT+    , gl_TEXTURE_ENV_COLOR+    , gl_READ_WRITE_ARB+    , gl_RGBA8_EXT+    , gl_EVAL_VERTEX_ATTRIB10_NV+    , gl_POST_CONVOLUTION_RED_BIAS+    , gl_INT16_VEC4_NV+    , gl_COLOR_SUM_ARB+    , gl_OUTPUT_TEXTURE_COORD5_EXT+    , gl_COMPRESSED_RGBA_ASTC_12x10_KHR+    , gl_MAX_ELEMENTS_INDICES+    , gl_REFERENCED_BY_FRAGMENT_SHADER+    , gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB+    , gl_WEIGHT_ARRAY_ARB+    , gl_TIME_ELAPSED_EXT+    , gl_BACK_SECONDARY_COLOR_NV+    , gl_COMPARE_REF_TO_TEXTURE_EXT+    , gl_IS_PER_PATCH_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE+    , gl_TEXTURE_LUMINANCE_SIZE_EXT+    , gl_COVERAGE_BUFFERS_NV+    , gl_MATRIX5_ARB+    , gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT+    , gl_COMPRESSED_RGBA_ASTC_5x5x4_OES+    , gl_CONVOLUTION_FILTER_BIAS+    , gl_TRACE_PRIMITIVES_BIT_MESA+    , gl_POINT_SPRITE+    , gl_POLYGON_STIPPLE_BIT+    , gl_DEBUG_SEVERITY_HIGH+    , gl_RENDERBUFFER_STENCIL_SIZE_EXT+    , gl_RED+    , gl_DRAW_BUFFER12_NV+    , gl_COMPRESSED_RGBA_ASTC_10x10_KHR+    , gl_ACTIVE_TEXTURE+    , gl_Q+    , gl_STRICT_LIGHTING_HINT_PGI+    , gl_INT8_VEC2_NV+    , gl_MAP2_VERTEX_ATTRIB0_4_NV+    , gl_SHADER_SOURCE_LENGTH+    , gl_FLOAT_MAT4+    , gl_COLOR_MATRIX_SGI+    , gl_SAMPLER_2D_ARRAY_EXT+    , gl_MODULATE_SUBTRACT_ATI+    , gl_TRIANGLES_ADJACENCY_ARB+    , gl_PROGRAM_TARGET_NV+    , gl_GEOMETRY_SHADER_ARB+    , gl_TEXTURE_BASE_LEVEL_SGIS+    , gl_1PASS_SGIS+    , gl_TEXTURE_HEIGHT_QCOM+    , gl_LUMINANCE12_ALPHA4_EXT+    , gl_PIXEL_TILE_HEIGHT_SGIX+    , gl_UNSIGNED_INT_S8_S8_8_8_NV+    , gl_SOURCE0_RGB+    , gl_DRAW_BUFFER6_EXT+    , gl_PATH_FILL_BOUNDING_BOX_NV+    , gl_RENDER_MODE+    , gl_X_EXT+    , gl_CON_14_ATI+    , gl_TRIANGLE_STRIP_ADJACENCY+    , gl_ROUNDED_RECT_NV+    , gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB+    , gl_DSDT_MAG_INTENSITY_NV+    , gl_MODELVIEW13_ARB+    , gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES+    , gl_CLIP_ORIGIN+    , gl_PATH_CLIENT_LENGTH_NV+    , gl_SAMPLE_ALPHA_TO_ONE_ARB+    , gl_RENDERBUFFER_INTERNAL_FORMAT_OES+    , gl_POINT_SPRITE_ARB+    , gl_FLOAT_MAT3_ARB+    , gl_IMAGE_CLASS_4_X_8+    , gl_PIXEL_SUBSAMPLE_4242_SGIX+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT+    , gl_ROUNDED_RECT8_NV+    , gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING+    , gl_DST_NV+    , gl_MAX_TRANSFORM_FEEDBACK_BUFFERS+    , gl_FUNC_ADD_OES+    , gl_VERTEX_STREAM7_ATI+    , gl_RG_EXT+    , gl_STENCIL_BACK_PASS_DEPTH_PASS+    , gl_FRAMEBUFFER_RENDERABLE_LAYERED+    , gl_MAP2_VERTEX_ATTRIB1_4_NV+    , gl_DRAW_BUFFER2_ATI+    , gl_RGBA_FLOAT16_ATI+    , gl_EVAL_VERTEX_ATTRIB13_NV+    , gl_DRAW_BUFFER15_ATI+    , gl_MAP_WRITE_BIT+    , gl_DOT3_RGBA+    , gl_MAT_SHININESS_BIT_PGI+    , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN+    , gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV+    , gl_MATRIX30_ARB+    , gl_STENCIL_TEST+    , gl_MAX_INTEGER_SAMPLES+    , gl_COPY_READ_BUFFER_BINDING+    , gl_TRANSFORM_FEEDBACK_BUFFER+    , gl_LUMINANCE_FLOAT16_APPLE+    , gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS+    , gl_MAX_VERTEX_UNIFORM_VECTORS+    , gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV+    , gl_SAMPLER_RENDERBUFFER_NV+    , gl_DRAW_BUFFER13_NV+    , gl_RGB32F_ARB+    , gl_FRAGMENT_LIGHT5_SGIX+    , gl_MAX_GENERAL_COMBINERS_NV+    , gl_TRANSPOSE_TEXTURE_MATRIX_ARB+    , gl_OPERAND1_ALPHA_ARB+    , gl_COLOR_ATTACHMENT12+    , gl_GREEN_MAX_CLAMP_INGR+    , gl_PATH_PROJECTION_STACK_DEPTH_NV+    , gl_MAP2_COLOR_4+    , gl_COLOR_SUM_EXT+    , gl_CLAMP_FRAGMENT_COLOR_ARB+    , gl_INDEX_BITS+    , gl_CON_15_ATI+    , gl_BLEND_OVERLAP_NV+    , gl_DS_SCALE_NV+    , gl_CURRENT_PALETTE_MATRIX_ARB+    , gl_IMAGE_BINDING_LAYER_EXT+    , gl_WEIGHT_SUM_UNITY_ARB+    , gl_ALPHA32I_EXT+    , gl_SHADER_STORAGE_BUFFER_SIZE+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER+    , gl_MAX_UNIFORM_LOCATIONS+    , gl_DEBUG_SOURCE_OTHER_KHR+    , gl_FRACTIONAL_EVEN+    , gl_MIN_PROGRAM_TEXEL_OFFSET+    , gl_WEIGHT_ARRAY_OES+    , gl_RESET_NOTIFICATION_STRATEGY_KHR+    , gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV+    , gl_RGB2_EXT+    , gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT+    , gl_ELEMENT_ARRAY_BUFFER+    , gl_MEDIUM_FLOAT+    , gl_SAMPLER_1D_SHADOW_ARB+    , gl_DRAW_BUFFER5+    , gl_PARALLEL_ARRAYS_INTEL+    , gl_REG_24_ATI+    , gl_DEPTH_STENCIL_TO_BGRA_NV+    , gl_MAX_FRAMEBUFFER_WIDTH+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES+    , gl_POLYGON_OFFSET_FILL+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES+    , gl_TEXTURE_GEN_T+    , gl_TEXTURE_POST_SPECULAR_HP+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES+    , gl_MAGNITUDE_SCALE_NV+    , gl_VERTEX_SHADER_LOCALS_EXT+    , gl_INT_2_10_10_10_REV+    , gl_DOUBLE_MAT3x2_EXT+    , gl_DISCARD_NV+    , gl_MATRIX13_ARB+    , gl_GENERATE_MIPMAP_HINT+    , gl_MAX_PIXEL_MAP_TABLE+    , gl_SHADER_STORAGE_BUFFER+    , gl_BUFFER_UPDATE_BARRIER_BIT+    , gl_FRAMEBUFFER_BINDING_OES+    , gl_CONTEXT_PROFILE_MASK+    , gl_MAX_VIEWPORTS+    , gl_DRAW_BUFFER4_ARB+    , gl_RESAMPLE_DECIMATE_SGIX+    , gl_SHADER_OBJECT_ARB+    , gl_SYNC_FLAGS_APPLE+    , gl_Z4Y12Z4CB12Z4CR12_444_NV+    , gl_VERTEX_ARRAY_LENGTH_NV+    , gl_FOG_COORDINATE_ARRAY_LIST_IBM+    , gl_FRAMEBUFFER_DEFAULT_SAMPLES+    , gl_FLAT+    , gl_REG_2_ATI+    , gl_VIEWPORT_BIT+    , gl_TEXTURE_VIEW_MIN_LEVEL_EXT+    , gl_FRACTIONAL_ODD_EXT+    , gl_VIRTUAL_PAGE_SIZE_X_ARB+    , gl_GLOBAL_ALPHA_SUN+    , gl_TEXTURE_BORDER+    , gl_MAP2_VERTEX_ATTRIB7_4_NV+    , gl_BUFFER_ACCESS+    , gl_COLOR_ATTACHMENT15_EXT+    , gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT+    , gl_PRIMITIVE_RESTART_FIXED_INDEX+    , gl_MAX_COMBINED_DIMENSIONS+    , gl_MINUS_NV+    , gl_NORMAL_MAP_ARB+    , gl_MAT_AMBIENT_BIT_PGI+    , gl_REG_14_ATI+    , gl_SECONDARY_INTERPOLATOR_ATI+    , gl_FRAGMENT_SHADER_BIT_EXT+    , gl_CON_20_ATI+    , gl_DYNAMIC_DRAW+    , gl_STENCIL_INDEX1+    , gl_DEPTH_COMPONENTS+    , gl_SEPARATE_SPECULAR_COLOR_EXT+    , gl_CONSTANT_COLOR0_NV+    , gl_LUMINANCE16I_EXT+    , gl_TEXTURE_COORD_ARRAY_SIZE_EXT+    , gl_BLEND_DST_RGB+    , gl_VARIABLE_C_NV+    , gl_INT_VEC2_ARB+    , gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX+    , gl_PIXEL_MAP_G_TO_G_SIZE+    , gl_BLUE_MIN_CLAMP_INGR+    , gl_RETURN+    , gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD+    , gl_DOUBLE+    , gl_COMBINE4_NV+    , gl_IMAGE_ROTATE_ORIGIN_X_HP+    , gl_COMBINER5_NV+    , gl_SYNC_CONDITION+    , gl_DEBUG_LOGGED_MESSAGES_ARB+    , gl_REG_15_ATI+    , gl_BUFFER_MAP_POINTER_OES+    , gl_SM_COUNT_NV+    , gl_MAX_FRAMEBUFFER_HEIGHT+    , gl_INCR_WRAP_OES+    , gl_GCCSO_SHADER_BINARY_FJ+    , gl_DRAW_BUFFER4_NV+    , gl_RGB565+    , gl_WRITE_PIXEL_DATA_RANGE_NV+    , gl_UNIFORM_OFFSET+    , gl_UNSIGNED_INT64_ARB+    , gl_STENCIL_RENDERABLE+    , gl_COMPRESSED_RGBA_BPTC_UNORM+    , gl_FLOAT_R32_NV+    , gl_TEXTURE_CLIPMAP_OFFSET_SGIX+    , gl_TEXTURE_IMAGE_VALID_QCOM+    , gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC+    , gl_IMAGE_PIXEL_TYPE+    , gl_EDGE_FLAG_ARRAY_STRIDE+    , gl_RED_SCALE+    , gl_RENDERBUFFER_ALPHA_SIZE_OES+    , gl_CLIP_DISTANCE7+    , gl_INTENSITY32UI_EXT+    , gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR+    , gl_PN_TRIANGLES_ATI+    , gl_LIGHT5+    , gl_QUERY_RESULT_ARB+    , gl_LUMINANCE16+    , gl_ALPHA_TEST_QCOM+    , gl_TEXTURE_BORDER_COLOR_NV+    , gl_CULL_FRAGMENT_NV+    , gl_PATH_GEN_MODE_NV+    , gl_PROGRAM_POINT_SIZE_ARB+    , gl_INTERNALFORMAT_DEPTH_TYPE+    , gl_UNPACK_SKIP_ROWS+    , gl_DEBUG_SEVERITY_NOTIFICATION+    , gl_MAX_FRAGMENT_LIGHTS_SGIX+    , gl_COUNTER_TYPE_AMD+    , gl_TEXTURE_FETCH_BARRIER_BIT_EXT+    , gl_CURRENT_NORMAL+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES+    , gl_MULTIVIEW_EXT+    , gl_TESS_GEN_VERTEX_ORDER_EXT+    , gl_IMAGE_SCALE_X_HP+    , gl_TEXTURE_COLOR_TABLE_SGI+    , gl_DSDT_MAG_NV+    , gl_Z400_BINARY_AMD+    , gl_COLOR_INDEX8_EXT+    , gl_SRGB8_NV+    , gl_UNSIGNED_IDENTITY_NV+    , gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES+    , gl_ALPHA_SNORM+    , gl_MAX_TEXTURE_UNITS+    , gl_DEBUG_SEVERITY_MEDIUM_KHR+    , gl_TEXTURE_RECTANGLE+    , gl_CONTRAST_NV+    , gl_FILL+    , gl_BLEND_COLOR+    , gl_POINT_SMOOTH_HINT+    , gl_CONTEXT_ROBUST_ACCESS+    , gl_FRAGMENT_PROGRAM_NV+    , gl_OP_MULTIPLY_MATRIX_EXT+    , gl_DEPENDENT_GB_TEXTURE_2D_NV+    , gl_DOUBLE_EXT+    , gl_VERTEX_PROGRAM_NV+    , gl_PATH_END_CAPS_NV+    , gl_PATH_STROKE_MASK_NV+    , gl_SAMPLER_CUBE_SHADOW_EXT+    , gl_COLOR_SAMPLES_NV+    , gl_DUAL_INTENSITY16_SGIS+    , gl_IMPLEMENTATION_COLOR_READ_TYPE_OES+    , gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR+    , gl_SCISSOR_TEST+    , gl_ADJACENT_PAIRS_NV+    , gl_MAX_VERTEX_ATTRIB_BINDINGS+    , gl_TEXTURE_GATHER+    , gl_LUMINANCE_ALPHA8UI_EXT+    , gl_RELATIVE_ARC_TO_NV+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR+    , gl_TEXTURE_BINDING_CUBE_MAP_EXT+    , gl_FRAGMENT_ALPHA_MODULATE_IMG+    , gl_CURRENT_VERTEX_EXT+    , gl_MAP1_VERTEX_ATTRIB11_4_NV+    , gl_MATRIX_INDEX_ARRAY_SIZE_ARB+    , gl_TRANSFORM_FEEDBACK_BUFFER_MODE+    , gl_PIXEL_TILE_CACHE_SIZE_SGIX+    , gl_MODELVIEW0_EXT+    , gl_FONT_DESCENDER_BIT_NV+    , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS+    , gl_RASTERIZER_DISCARD+    , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE+    , gl_MAX_DEBUG_MESSAGE_LENGTH_ARB+    , gl_EXTENSIONS+    , gl_RESAMPLE_AVERAGE_OML+    , gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV+    , gl_RELATIVE_SMALL_CCW_ARC_TO_NV+    , gl_FRONT+    , gl_BLEND_COLOR_EXT+    , gl_BUFFER_ACCESS_OES+    , gl_MATRIX29_ARB+    , gl_GEOMETRY_LINKED_INPUT_TYPE_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES+    , gl_COLOR_ATTACHMENT12_EXT+    , gl_DRAW_BUFFER1+    , gl_FLOAT_32_UNSIGNED_INT_24_8_REV+    , gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT+    , gl_UNSIGNED_INT_SAMPLER_CUBE+    , gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI+    , gl_MAX_CULL_DISTANCES+    , gl_TEXTURE_LOD_BIAS_S_SGIX+    , gl_SPRITE_SGIX+    , gl_VERTEX_ATTRIB_ARRAY3_NV+    , gl_QUAD_INTENSITY4_SGIS+    , gl_DIFFERENCE_KHR+    , gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT+    , gl_VOLATILE_APPLE+    , gl_MAT_EMISSION_BIT_PGI+    , gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV+    , gl_DRAW_FRAMEBUFFER_BINDING+    , gl_TEXTURE8+    , gl_MUL_ATI+    , gl_PROGRAM_OBJECT_EXT+    , gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB+    , gl_MATRIX_INDEX_ARRAY_TYPE_ARB+    , gl_PIXEL_MAG_FILTER_EXT+    , gl_LESS+    , gl_SOURCE2_RGB_ARB+    , gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH+    , gl_PATH_STENCIL_VALUE_MASK_NV+    , gl_IMPLEMENTATION_COLOR_READ_TYPE+    , gl_TEXTURE_CLIPMAP_CENTER_SGIX+    , gl_BUFFER+    , gl_DEBUG_CALLBACK_USER_PARAM_ARB+    , gl_FIXED_OES+    , gl_INT_VEC2+    , gl_VARIANT_VALUE_EXT+    , gl_QUAD_STRIP+    , gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT+    , gl_ZERO_TO_ONE+    , gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB+    , gl_CND_ATI+    , gl_PROGRAM_POINT_SIZE+    , gl_VIEWPORT_BOUNDS_RANGE+    , gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL+    , gl_R1UI_T2F_N3F_V3F_SUN+    , gl_DEPTH_STENCIL_EXT+    , gl_RESCALE_NORMAL+    , gl_INDEX_CLEAR_VALUE+    , gl_VERTEX_STREAM5_ATI+    , gl_CON_4_ATI+    , gl_LAYOUT_DEFAULT_INTEL+    , gl_RGBA8I_EXT+    , gl_IMAGE_CLASS_4_X_16+    , gl_RGB8_EXT+    , gl_TEXTURE_DS_SIZE_NV+    , gl_CLAMP_VERTEX_COLOR+    , gl_DEPTH_CLEAR_VALUE+    , gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB+    , gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS+    , gl_RGB_FLOAT16_APPLE+    , gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV+    , gl_COLOR_ATTACHMENT1+    , gl_MAX_TESS_GEN_LEVEL_EXT+    , gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER+    , gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM+    , gl_MATRIX3_ARB+    , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB+    , gl_FRAGMENT_PROGRAM_BINDING_NV+    , gl_DOT2_ADD_ATI+    , gl_CON_2_ATI+    , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES+    , gl_UNIFORM_ARRAY_STRIDE+    , gl_RECLAIM_MEMORY_HINT_PGI+    , gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS+    , gl_DRAW_BUFFER11_ARB+    , gl_NORMAL_ARRAY+    , gl_PATH_GEN_COMPONENTS_NV+    , gl_COLOR_FLOAT_APPLE+    , gl_WAIT_FAILED+    , gl_SAMPLER_1D_ARRAY_SHADOW+    , gl_PIXEL_TEX_GEN_Q_CEILING_SGIX+    , gl_ALWAYS_FAST_HINT_PGI+    , gl_GEOMETRY_OUTPUT_TYPE_EXT+    , gl_MAX_PROGRAM_PATCH_ATTRIBS_NV+    , gl_TEXTURE_1D_ARRAY+    , gl_LIST_MODE+    , gl_COLOR_ARRAY_TYPE+    , gl_SAMPLE_MASK_VALUE_EXT+    , gl_PIXEL_BUFFER_BARRIER_BIT+    , gl_SCISSOR_BOX+    , gl_UNSIGNED_INT_SAMPLER_3D_EXT+    , gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE+    , gl_CLIENT_ALL_ATTRIB_BITS+    , gl_TRANSPOSE_MODELVIEW_MATRIX_ARB+    , gl_TEXTURE_BINDING_RECTANGLE_NV+    , gl_ALPHA_FLOAT32_ATI+    , gl_MAP1_TEXTURE_COORD_4+    , gl_CONSTANT_ALPHA+    , gl_PREVIOUS_EXT+    , gl_PACK_COMPRESSED_SIZE_SGIX+    , gl_IMAGE_2D_ARRAY_EXT+    , gl_ASYNC_TEX_IMAGE_SGIX+    , gl_QUERY_RESULT+    , gl_MATRIX0_ARB+    , gl_UNPACK_CMYK_HINT_EXT+    , gl_MAP1_TEXTURE_COORD_1+    , gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH+    , gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI+    , gl_TEXTURE_BLUE_SIZE_EXT+    , gl_VARIANT_EXT+    , gl_UNPACK_ROW_LENGTH+    , gl_VARIANT_DATATYPE_EXT+    , gl_LINEAR_MIPMAP_LINEAR+    , gl_ALPHA8I_EXT+    , gl_OUTPUT_TEXTURE_COORD20_EXT+    , gl_EYE_LINEAR+    , gl_VIEWPORT+    , gl_SHADER_BINARY_DMP+    , gl_TEXTURE25_ARB+    , gl_UNSIGNED_SHORT_4_4_4_4_EXT+    , gl_PROXY_HISTOGRAM_EXT+    , gl_SCALEBIAS_HINT_SGIX+    , gl_MAP_INVALIDATE_RANGE_BIT_EXT+    , gl_FRAGMENT_PROGRAM_CALLBACK_MESA+    , gl_TRANSLATE_3D_NV+    , gl_PATH_COORD_COUNT_NV+    , gl_MAX_ACTIVE_LIGHTS_SGIX+    , gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB+    , gl_REFERENCE_PLANE_EQUATION_SGIX+    , gl_PATH_TERMINAL_DASH_CAP_NV+    , gl_INDEX_ARRAY+    , gl_INNOCENT_CONTEXT_RESET_ARB+    , gl_TEXTURE_BINDING_1D+    , gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE+    , gl_QUERY_OBJECT_EXT+    , gl_UNIFORM_BLOCK+    , gl_CONVOLUTION_HEIGHT+    , gl_STENCIL_FAIL+    , gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX+    , gl_TEXTURE_SAMPLES_IMG+    , gl_REFLECTION_MAP_NV+    , gl_GREEN_SCALE+    , gl_TRANSFORM_FEEDBACK_BUFFER_EXT+    , gl_LIGHTEN_NV+    , gl_HISTOGRAM_ALPHA_SIZE_EXT+    , gl_UNSIGNED_INT64_NV+    , gl_LINE_STIPPLE_REPEAT+    , gl_YCBCR_MESA+    , gl_LEQUAL+    , gl_BUFFER_USAGE_ARB+    , gl_MAP1_VERTEX_ATTRIB6_4_NV+    , gl_SAMPLER_BUFFER_AMD+    , gl_OBJECT_DISTANCE_TO_LINE_SGIS+    , gl_PIXEL_COUNT_NV+    , gl_VERTEX_PROGRAM_POSITION_MESA+    , gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI+    , gl_POST_COLOR_MATRIX_BLUE_BIAS+    , gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX+    , gl_VERTEX_ATTRIB_MAP2_APPLE+    , gl_PLUS_DARKER_NV+    , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT+    , gl_FRAGMENT_SHADER_INVOCATIONS_ARB+    , gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT+    , gl_PROXY_TEXTURE_CUBE_MAP_ARRAY+    , gl_UNSIGNED_INT_IMAGE_CUBE_EXT+    , gl_DYNAMIC_DRAW_ARB+    , gl_RGBA_SNORM+    , gl_MAX_UNIFORM_BLOCK_SIZE+    , gl_FUNC_REVERSE_SUBTRACT_EXT+    , gl_STENCIL_BUFFER_BIT1_QCOM+    , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER+    , gl_TEXTURE_1D_BINDING_EXT+    , gl_RGBA4_EXT+    , gl_PREFER_DOUBLEBUFFER_HINT_PGI+    , gl_UNKNOWN_CONTEXT_RESET_KHR+    , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES+    , gl_REFERENCED_BY_COMPUTE_SHADER+    , gl_REG_17_ATI+    , gl_BUFFER_FLUSHING_UNMAP_APPLE+    , gl_UNIFORM+    , gl_TEXCOORD4_BIT_PGI+    , gl_BIAS_BY_NEGATIVE_ONE_HALF_NV+    , gl_OP_FLOOR_EXT+    , gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV+    , gl_CURRENT_QUERY+    , gl_UNIFORM_BUFFER_START+    , gl_DEBUG_SEVERITY_HIGH_KHR+    , gl_T2F_C4UB_V3F+    , gl_FONT_GLYPHS_AVAILABLE_NV+    , gl_MAX_CONVOLUTION_HEIGHT_EXT+    , gl_STENCIL_BUFFER_BIT3_QCOM+    , gl_MAP1_VERTEX_ATTRIB3_4_NV+    , gl_BLEND_EQUATION_ALPHA_EXT+    , gl_RGB_FLOAT32_APPLE+    , gl_CONSTANT_BORDER+    , gl_CON_0_ATI+    , gl_VERTEX_ARRAY_RANGE_POINTER_NV+    , gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV+    , gl_INTERLACE_SGIX+    , gl_UNPACK_CONSTANT_DATA_SUNX+    , gl_VERTEX_BINDING_STRIDE+    , gl_IS_PER_PATCH+    , gl_AVERAGE_HP+    , gl_MAX_VERTEX_ATTRIBS+    , gl_MAX_SAMPLES_ANGLE+    , gl_RED_EXT+    , gl_MAP1_NORMAL+    , gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT+    , gl_MIN_SAMPLE_SHADING_VALUE_ARB+    , gl_COMPRESSED_SLUMINANCE_EXT+    , gl_RGBA4+    , gl_TEXTURE_VIEW_MIN_LAYER+    , gl_ONE_EXT+    , gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES+    , gl_MODELVIEW31_ARB+    , gl_MAX_TEXTURE_IMAGE_UNITS+    , gl_COLOR_ATTACHMENT3_NV+    , gl_LUMINANCE6_ALPHA2+    , gl_POINT_SPRITE_R_MODE_NV+    , gl_COMPARE_REF_TO_TEXTURE+    , gl_MAX_PROJECTION_STACK_DEPTH+    , gl_BLEND_DST_ALPHA+    , gl_TEXTURE_1D_STACK_BINDING_MESAX+    , gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV+    , gl_PROGRAM_PARAMETER_NV+    , gl_VIDEO_CAPTURE_FRAME_WIDTH_NV+    , gl_MATRIX21_ARB+    , gl_LIST_BASE+    , gl_COLOR_ATTACHMENT5+    , gl_VERTEX_ARRAY_BINDING_APPLE+    , gl_RELATIVE_LARGE_CW_ARC_TO_NV+    , gl_MAX_DEFORMATION_ORDER_SGIX+    , gl_COVERAGE_AUTOMATIC_NV+    , gl_FOG_FUNC_SGIS+    , gl_SAMPLER_BUFFER_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT+    , gl_RGB8+    , gl_PRIMARY_COLOR_NV+    , gl_DEPTH_TEXTURE_MODE_ARB+    , gl_LUMINANCE12_ALPHA4+    , gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS+    , gl_TEXTURE_BUFFER_EXT+    , gl_LINK_STATUS+    , gl_VERTEX_SHADER_EXT+    , gl_VERTEX_ARRAY_POINTER+    , gl_ONE_MINUS_SRC1_ALPHA+    , gl_TEXTURE_BUFFER_SIZE_EXT+    , gl_DEBUG_SEVERITY_MEDIUM+    , gl_ASYNC_READ_PIXELS_SGIX+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME+    , gl_REPLACE_EXT+    , gl_DEBUG_SOURCE_APPLICATION_ARB+    , gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES+    , gl_BROWSER_DEFAULT_WEBGL+    , gl_MULTISAMPLE_BUFFER_BIT0_QCOM+    , gl_DUAL_ALPHA8_SGIS+    , gl_COMPRESSED_RGB_FXT1_3DFX+    , gl_BLEND_SRC_RGB_OES+    , gl_T2F_IUI_V2F_EXT+    , gl_DRAW_BUFFER13_ARB+    , gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV+    , gl_TEXTURE_INTENSITY_TYPE_ARB+    , gl_DU8DV8_ATI+    , gl_MAP1_VERTEX_ATTRIB14_4_NV+    , gl_VARIANT_ARRAY_STRIDE_EXT+    , gl_RGB_S3TC+    , gl_NORMAL_ARRAY_POINTER+    , gl_CONSTANT_ALPHA_EXT+    , gl_COLOR_ATTACHMENT8_NV+    , gl_MAX_LIST_NESTING+    , gl_FRAMEBUFFER_UNDEFINED+    , gl_ACTIVE_STENCIL_FACE_EXT+    , gl_DEPTH_SCALE+    , gl_READ_PIXELS_FORMAT+    , gl_QUADS_EXT+    , gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS+    , gl_OUTPUT_VERTEX_EXT+    , gl_PROGRAM_ATTRIBS_ARB+    , gl_MAP1_VERTEX_ATTRIB8_4_NV+    , gl_INVALID_ENUM+    , gl_1PASS_EXT+    , gl_FUNC_ADD_EXT+    , gl_DISTANCE_ATTENUATION_SGIS+    , gl_REG_3_ATI+    , gl_INTERPOLATE+    , gl_MITER_TRUNCATE_NV+    , gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB+    , gl_CONTEXT_COMPATIBILITY_PROFILE_BIT+    , gl_MATRIX_STRIDE+    , gl_FONT_Y_MIN_BOUNDS_BIT_NV+    , gl_COMBINER_BIAS_NV+    , gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB+    , gl_CIRCULAR_CW_ARC_TO_NV+    , gl_UNSIGNED_INT_IMAGE_1D_EXT+    , gl_BLUE_SCALE+    , gl_OFFSET_TEXTURE_SCALE_NV+    , gl_OFFSET_TEXTURE_2D_NV+    , gl_INTERNALFORMAT_DEPTH_SIZE+    , gl_TIMEOUT_IGNORED+    , gl_BGRA_EXT+    , gl_GEQUAL+    , gl_EXCLUSION_KHR+    , gl_LINES_ADJACENCY_ARB+    , gl_MAX_COMPUTE_WORK_GROUP_COUNT+    , gl_RENDERBUFFER_EXT+    , gl_GENERATE_MIPMAP+    , gl_SOURCE1_ALPHA_EXT+    , gl_VERTEX_TEXTURE+    , gl_LIGHT1+    , gl_STATIC_READ_ARB+    , gl_INTERLACE_READ_INGR+    , gl_COMPRESSED_R11_EAC_OES+    , gl_FRAGMENT_SHADER_ARB+    , gl_CURRENT_RASTER_POSITION+    , gl_WEIGHT_ARRAY_BUFFER_BINDING_OES+    , gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT+    , gl_RGB_FLOAT32_ATI+    , gl_LUMINANCE16_ALPHA16_EXT+    , gl_RENDERBUFFER_WIDTH_EXT+    , gl_DEPTH_RANGE+    , gl_4_BYTES+    , gl_VERTEX_WEIGHTING_EXT+    , gl_TEXTURE_SWIZZLE_B+    , gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV+    , gl_FEEDBACK_BUFFER_POINTER+    , gl_CULL_VERTEX_IBM+    , gl_UNPACK_SKIP_VOLUMES_SGIS+    , gl_PIXEL_CUBIC_WEIGHT_EXT+    , gl_DECR_WRAP_EXT+    , gl_TEXTURE31+    , gl_MAX_TESS_GEN_LEVEL+    , gl_YCBAYCR8A_4224_NV+    , gl_POINT_SPRITE_OES+    , gl_SAMPLER_EXTERNAL_OES+    , gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT+    , gl_PIXEL_PACK_BUFFER_BINDING_ARB+    , gl_DEBUG_CATEGORY_API_ERROR_AMD+    , gl_TEXCOORD3_BIT_PGI+    , gl_UNIFORM_BUFFER_EXT+    , gl_COMPRESSED_RGBA8_ETC2_EAC+    , gl_COLOR_SUM_CLAMP_NV+    , gl_SAMPLER_CUBE+    , gl_FRACTIONAL_ODD+    , gl_ONE_MINUS_DST_COLOR+    , gl_REG_9_ATI+    , gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV+    , gl_PIXEL_MAP_I_TO_G+    , gl_FOG_COORD_ARRAY_STRIDE+    , gl_TRIANGLES_ADJACENCY_EXT+    , gl_DRAW_BUFFER14_EXT+    , gl_TEXTURE_COMPARE_MODE_ARB+    , gl_REFLECTION_MAP_OES+    , gl_WARPS_PER_SM_NV+    , gl_QUERY_WAIT+    , gl_COMPRESSED_SLUMINANCE_ALPHA+    , gl_MAP2_TEXTURE_COORD_3+    , gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV+    , gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV+    , gl_INTENSITY_FLOAT32_ATI+    , gl_CLAMP_TO_BORDER_SGIS+    , gl_FIELDS_NV+    , gl_MAX_GEOMETRY_OUTPUT_VERTICES+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER+    , gl_INT_SAMPLER_CUBE_EXT+    , gl_SOURCE0_RGB_EXT+    , gl_DRAW_BUFFER10_ATI+    , gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT+    , gl_COPY_WRITE_BUFFER_NV+    , gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV+    , gl_LUMINANCE8_OES+    , gl_POST_CONVOLUTION_RED_BIAS_EXT+    , gl_HSL_COLOR_KHR+    , gl_SAMPLE_MASK_VALUE_NV+    , gl_SLUMINANCE8_NV+    , gl_ASYNC_MARKER_SGIX+    , gl_TEXTURE17+    , gl_SYNC_CL_EVENT_COMPLETE_ARB+    , gl_INVARIANT_VALUE_EXT+    , gl_BUMP_ROT_MATRIX_SIZE_ATI+    , gl_ACTIVE_VARYING_MAX_LENGTH_NV+    , gl_DEPTH_COMPONENT16+    , gl_MODELVIEW25_ARB+    , gl_SHADER_BINARY_VIV+    , gl_VERTEX_ARRAY_STRIDE_EXT+    , gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB+    , gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB+    , gl_MAX_PALETTE_MATRICES_ARB+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER+    , gl_DEPTH_COMPONENT32_ARB+    , gl_PRESERVE_ATI+    , gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX+    , gl_VERTEX_PROGRAM_TWO_SIDE_NV+    , gl_MAX_ELEMENTS_INDICES_EXT+    , gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS+    , gl_CONTEXT_LOST+    , gl_VERTEX_SUBROUTINE_UNIFORM+    , gl_COMPRESSED_SRGB_EXT+    , gl_SAMPLER_2D_MULTISAMPLE_ARRAY+    , gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB+    , gl_STENCIL_INDEX_OES+    , gl_PATH_INITIAL_END_CAP_NV+    , gl_INTENSITY32F_ARB+    , gl_SAMPLES_PASSED+    , gl_INT_IMAGE_2D_RECT_EXT+    , gl_CLIP_PLANE2+    , gl_PALETTE8_RGB8_OES+    , gl_ALPHA16I_EXT+    , gl_VERTEX_ARRAY+    , gl_TEXTURE23_ARB+    , gl_AMBIENT_AND_DIFFUSE+    , gl_MULTISAMPLE_BUFFER_BIT2_QCOM+    , gl_LUMINANCE_FLOAT16_ATI+    , gl_INDEX_ARRAY_TYPE+    , gl_COMPATIBLE_SUBROUTINES+    , gl_VERTEX4_BIT_PGI+    , gl_FOG_COORD_SRC+    , gl_FULL_SUPPORT+    , gl_STEREO+    , gl_LUMINANCE_ALPHA16UI_EXT+    , gl_ONE_MINUS_SRC_COLOR+    , gl_MAX_SHADER_STORAGE_BLOCK_SIZE+    , gl_REPLICATE_BORDER_HP+    , gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE+    , gl_CPU_OPTIMIZED_QCOM+    , gl_FLOAT16_VEC2_NV+    , gl_SAMPLE_ALPHA_TO_ONE_SGIS+    , gl_MAP2_VERTEX_ATTRIB12_4_NV+    , gl_COMBINER_MUX_SUM_NV+    , gl_UNSIGNED_SHORT_5_6_5_REV_EXT+    , gl_TEXTURE20_ARB+    , gl_DOT3_RGB+    , gl_STENCIL_BUFFER_BIT0_QCOM+    , gl_LO_SCALE_NV+    , gl_FONT_ASCENDER_BIT_NV+    , gl_DRAW_BUFFER9_EXT+    , gl_UNSIGNED_INT_2_10_10_10_REV+    , gl_BINNING_CONTROL_HINT_QCOM+    , gl_PROGRAM_TEMPORARIES_ARB+    , gl_MODELVIEW27_ARB+    , gl_RGBA16F_EXT+    , gl_INDEX_ARRAY_TYPE_EXT+    , gl_MAX_VERTEX_SHADER_LOCALS_EXT+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES+    , gl_COMP_BIT_ATI+    , gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT+    , gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY+    , gl_RGB10_A2_EXT+    , gl_MAP1_VERTEX_ATTRIB4_4_NV+    , gl_FLOAT_VEC3+    , gl_DELETE_STATUS+    , gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI+    , gl_UNCORRELATED_NV+    , gl_RELATIVE_SMALL_CW_ARC_TO_NV+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT+    , gl_RGB_FLOAT16_ATI+    , gl_DRAW_BUFFER7_ATI+    , gl_COMBINE_ALPHA_ARB+    , gl_RESET_NOTIFICATION_STRATEGY_EXT+    , gl_DRAW_BUFFER10_NV+    , gl_READ_PIXEL_DATA_RANGE_POINTER_NV+    , gl_TRANSFORM_FEEDBACK_ACTIVE+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR+    , gl_PROGRAM_PIPELINE_BINDING+    , gl_SRGB8_ALPHA8+    , gl_COLOR_INDEX16_EXT+    , gl_PHONG_WIN+    , gl_MAX_TEXTURE_IMAGE_UNITS_NV+    , gl_DSDT8_MAG8_NV+    , gl_COPY_READ_BUFFER+    , gl_RGBA16F+    , gl_UNSIGNED_SHORT_5_6_5+    , gl_CLIP_DISTANCE5+    , gl_TEXTURE_BINDING_3D_OES+    , gl_IUI_V2F_EXT+    , gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV+    , gl_ONE_MINUS_CONSTANT_ALPHA+    , gl_SMALL_CW_ARC_TO_NV+    , gl_IMAGE_BINDING_NAME_EXT+    , gl_CURRENT_FOG_COORDINATE_EXT+    , gl_SKIP_COMPONENTS4_NV+    , gl_CLIP_PLANE5_IMG+    , gl_PATH_MITER_LIMIT_NV+    , gl_TEXTURE_3D+    , gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS+    , gl_COMPRESSED_LUMINANCE_LATC1_EXT+    , gl_MULTISAMPLE_BUFFER_BIT3_QCOM+    , gl_SECONDARY_COLOR_ARRAY_SIZE+    , gl_RENDERBUFFER_SAMPLES_IMG+    , gl_R1UI_C4UB_V3F_SUN+    , gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX+    , gl_TRANSFORM_FEEDBACK_NV+    , gl_FRAMEBUFFER_RENDERABLE+    , gl_HARDLIGHT_KHR+    , gl_SOURCE0_ALPHA+    , gl_COMBINER4_NV+    , gl_ELEMENT_ARRAY_BUFFER_BINDING+    , gl_TEXTURE10_ARB+    , gl_CURRENT_BINORMAL_EXT+    , gl_REG_26_ATI+    , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS+    , gl_ACTIVE_VARYINGS_NV+    , gl_COMBINE_RGB_EXT+    , gl_FRAMEBUFFER_COMPLETE_EXT+    , gl_MAX_WIDTH+    , gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS+    , gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT+    , gl_COLORDODGE_KHR+    , gl_PATH_GEN_COEFF_NV+    , gl_FLOAT_MAT4x3_NV+    , gl_MINMAX_SINK+    , gl_FRONT_AND_BACK+    , gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT+    , gl_MATRIX1_ARB+    , gl_VIEWPORT_SUBPIXEL_BITS+    , gl_MAX_DUAL_SOURCE_DRAW_BUFFERS+    , gl_BOOL_VEC3_ARB+    , gl_OPERAND2_ALPHA+    , gl_MAX_DEBUG_GROUP_STACK_DEPTH+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR+    , gl_PROGRAM+    , gl_WEIGHT_ARRAY_SIZE_ARB+    , gl_BUFFER_GPU_ADDRESS_NV+    , gl_ALPHA8_EXT+    , gl_RGBA_MODE+    , gl_DUDV_ATI+    , gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV+    , gl_RESAMPLE_DECIMATE_OML+    , gl_QUERY_BUFFER+    , gl_SINGLE_COLOR+    , gl_INT_SAMPLER_RENDERBUFFER_NV+    , gl_MAT_COLOR_INDEXES_BIT_PGI+    , gl_MODELVIEW3_ARB+    , gl_TESS_CONTROL_OUTPUT_VERTICES_EXT+    , gl_PIXEL_MAP_B_TO_B+    , gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE+    , gl_DOUBLE_MAT3+    , gl_MAX_COMBINED_UNIFORM_BLOCKS+    , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT+    , gl_MAX_VERTEX_IMAGE_UNIFORMS+    , gl_QUERY_RESULT_NO_WAIT_AMD+    , gl_MODELVIEW26_ARB+    , gl_DEPTH_COMPONENT24_OES+    , gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB+    , gl_EVAL_VERTEX_ATTRIB6_NV+    , gl_OUTPUT_TEXTURE_COORD24_EXT+    , gl_COMPUTE_SHADER_BIT+    , gl_MATRIX7_ARB+    , gl_RENDER+    , gl_VERTEX_ATTRIB_BINDING+    , gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV+    , gl_TEXTURE_COORD_ARRAY_ADDRESS_NV+    , gl_UNSIGNED_INT_SAMPLER_2D_RECT+    , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB+    , gl_GENERATE_MIPMAP_SGIS+    , gl_SHADER_IMAGE_STORE+    , gl_INT_SAMPLER_3D+    , gl_PROGRAM_BINARY_LENGTH+    , gl_REFERENCED_BY_GEOMETRY_SHADER+    , gl_SHADER_IMAGE_ACCESS_BARRIER_BIT+    , gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS+    , gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT+    , gl_LINE+    , gl_RENDERBUFFER_ALPHA_SIZE_EXT+    , gl_INTENSITY+    , gl_AFFINE_3D_NV+    , gl_ADD_SIGNED_ARB+    , gl_OBJECT_COMPILE_STATUS_ARB+    , gl_RGB8I_EXT+    , gl_COMMAND_BARRIER_BIT+    , gl_COMBINE_RGB+    , gl_VERTEX_SHADER_BINDING_EXT+    , gl_SECONDARY_COLOR_ARRAY_SIZE_EXT+    , gl_DEPTH_EXT+    , gl_LINE_RESET_TOKEN+    , gl_SMOOTH_POINT_SIZE_GRANULARITY+    , gl_SAMPLER_2D_MULTISAMPLE+    , gl_PRIMARY_COLOR_ARB+    , gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY+    , gl_GEOMETRY_TEXTURE+    , gl_SOURCE1_RGB_ARB+    , gl_COLOR_ATTACHMENT6_EXT+    , gl_PIXEL_MAP_I_TO_I+    , gl_EVAL_VERTEX_ATTRIB7_NV+    , gl_OP_MIN_EXT+    , gl_RGB16F_EXT+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Z+    , gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS+    , gl_PACK_RESAMPLE_SGIX+    , gl_GREEN_BIAS+    , gl_DEPTH_STENCIL_NV+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER+    , gl_CON_29_ATI+    , gl_COLOR_ARRAY_STRIDE_EXT+    , gl_ISOLINES_EXT+    , gl_MODELVIEW4_ARB+    , gl_LINES_ADJACENCY+    , gl_PATH_FILL_MASK_NV+    , gl_HISTOGRAM_LUMINANCE_SIZE+    , gl_TEXTURE_BINDING_RENDERBUFFER_NV+    , gl_PIXEL_UNPACK_BUFFER_EXT+    , gl_RENDERBUFFER_GREEN_SIZE+    , gl_PASS_THROUGH_NV+    , gl_GEOMETRY_VERTICES_OUT_EXT+    , gl_EVAL_VERTEX_ATTRIB12_NV+    , gl_SMOOTH_QUADRATIC_CURVE_TO_NV+    , gl_TEXTURE_BUFFER_SIZE+    , gl_READ_PIXEL_DATA_RANGE_NV+    , gl_ALIASED_LINE_WIDTH_RANGE+    , gl_TRACK_MATRIX_NV+    , gl_COLOR_ARRAY_LIST_STRIDE_IBM+    , gl_WEIGHT_ARRAY_POINTER_ARB+    , gl_SMOOTH_LINE_WIDTH_GRANULARITY+    , gl_CLIP_DISTANCE6+    , gl_FRAMEBUFFER_BINDING+    , gl_EVAL_VERTEX_ATTRIB4_NV+    , gl_CURRENT_SECONDARY_COLOR_EXT+    , gl_IMAGE_CLASS_2_X_32+    , gl_PERSPECTIVE_CORRECTION_HINT+    , gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI+    , gl_SATURATE_BIT_ATI+    , gl_FONT_UNITS_PER_EM_BIT_NV+    , gl_EVAL_VERTEX_ATTRIB3_NV+    , gl_R16UI+    , gl_OUTPUT_TEXTURE_COORD17_EXT+    , gl_TEXTURE_MULTI_BUFFER_HINT_SGIX+    , gl_SKIP_MISSING_GLYPH_NV+    , gl_MIRROR_CLAMP_TO_EDGE_EXT+    , gl_TEXTURE_TYPE_QCOM+    , gl_RGB5_A1+    , gl_UNIFORM_BARRIER_BIT_EXT+    , gl_MULTISAMPLE+    , gl_SAMPLES_ARB+    , gl_RGBA_INTEGER+    , gl_STENCIL_COMPONENTS+    , gl_DEBUG_SEVERITY_LOW+    , gl_TEXTURE_COMPARE_SGIX+    , gl_COLOR_ARRAY_LIST_IBM+    , gl_COMPRESSED_SIGNED_RED_RGTC1+    , gl_MATRIX3_NV+    , gl_MAX_FRAGMENT_UNIFORM_BLOCKS+    , gl_INT_SAMPLER_3D_EXT+    , gl_MODELVIEW19_ARB+    , gl_SWIZZLE_STRQ_DQ_ATI+    , gl_COMBINE_ARB+    , gl_FRAGMENT_COLOR_EXT+    , gl_RENDERBUFFER_WIDTH+    , gl_LUMINANCE4_EXT+    , gl_UNSIGNED_INT_SAMPLER_2D_EXT+    , gl_RGB_SCALE_EXT+    , gl_PIXEL_MAP_I_TO_R+    , gl_DOT4_ATI+    , gl_MAP1_VERTEX_ATTRIB7_4_NV+    , gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB+    , gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB+    , gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI+    , gl_NUM_VIRTUAL_PAGE_SIZES_ARB+    , gl_RENDERBUFFER_FREE_MEMORY_ATI+    , gl_FRAMEBUFFER_DEFAULT_LAYERS+    , gl_COMPUTE_SUBROUTINE+    , gl_PROGRAM_TEX_INSTRUCTIONS_ARB+    , gl_SIGNALED_APPLE+    , gl_MULTISAMPLE_3DFX+    , gl_TEXTURE_INDEX_SIZE_EXT+    , gl_LAYOUT_LINEAR_INTEL+    , gl_LERP_ATI+    , gl_FACTOR_MAX_AMD+    , gl_MATRIX2_ARB+    , gl_EQUAL+    , gl_COLOR_ATTACHMENT0_OES+    , gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI+    , gl_RGB16+    , gl_COLOR_INDEX4_EXT+    , gl_PROXY_TEXTURE_CUBE_MAP_EXT+    , gl_STENCIL_BACK_FUNC_ATI+    , gl_DRAW_BUFFER8_EXT+    , gl_DST_ALPHA+    , gl_DEBUG_SOURCE_SHADER_COMPILER_KHR+    , gl_C4UB_V2F+    , gl_INTERNALFORMAT_BLUE_TYPE+    , gl_PIXEL_TILE_GRID_DEPTH_SGIX+    , gl_DEPTH_BITS+    , gl_FLOAT16_VEC3_NV+    , gl_ARRAY_OBJECT_OFFSET_ATI+    , gl_DOUBLE_MAT2_EXT+    , gl_TEXTURE_COLOR_SAMPLES_NV+    , gl_NORMAL_ARRAY_EXT+    , gl_MIRROR_CLAMP_TO_EDGE_ATI+    , gl_EDGE_FLAG_ARRAY_POINTER+    , gl_UNSIGNED_INT_24_8_MESA+    , gl_IMAGE_COMPATIBILITY_CLASS+    , gl_BACK_LEFT+    , gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB+    , gl_COLOR_TABLE_BIAS+    , gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG+    , gl_DARKEN_KHR+    , gl_OCCLUSION_TEST_RESULT_HP+    , gl_DEBUG_TYPE_POP_GROUP_KHR+    , gl_CLAMP_TO_BORDER_ARB+    , gl_UNSIGNED_BYTE_2_3_3_REV+    , gl_SOURCE2_ALPHA_ARB+    , gl_SAMPLE_COVERAGE+    , gl_INTERLEAVED_ATTRIBS_EXT+    , gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL+    , gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING+    , gl_VERTEX_SHADER+    , gl_INDEX_ARRAY_ADDRESS_NV+    , gl_QUERY_COUNTER_BITS+    , gl_COMPRESSED_RGBA_ASTC_8x6_KHR+    , gl_FRAMEBUFFER_BINDING_EXT+    , gl_VERTEX_ELEMENT_SWIZZLE_AMD+    , gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD+    , gl_ARRAY_OBJECT_BUFFER_ATI+    , gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES+    , gl_RENDERBUFFER_INTERNAL_FORMAT+    , gl_VIEW_CLASS_8_BITS+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES+    , gl_SHADER_IMAGE_ATOMIC+    , gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB+    , gl_COVERAGE_ATTACHMENT_NV+    , gl_NUM_PROGRAM_BINARY_FORMATS_OES+    , gl_CURRENT_RASTER_TEXTURE_COORDS+    , gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS+    , gl_PIXEL_MAP_A_TO_A+    , gl_TEXTURE_WRAP_T+    , gl_LINE_SMOOTH_HINT+    , gl_DRAW_BUFFER11_EXT+    , gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV+    , gl_LUMINANCE16_SNORM+    , gl_PERFQUERY_FLUSH_INTEL+    , gl_HISTOGRAM_SINK+    , gl_MAP1_VERTEX_ATTRIB15_4_NV+    , gl_OUTPUT_TEXTURE_COORD7_EXT+    , gl_HISTOGRAM_BLUE_SIZE+    , gl_LUMINANCE32F_EXT+    , gl_RG16UI+    , gl_TEXTURE_ALPHA_MODULATE_IMG+    , gl_INT_SAMPLER_2D_RECT+    , gl_STENCIL_BACK_WRITEMASK+    , gl_PIXEL_TRANSFORM_2D_MATRIX_EXT+    , gl_AUX3+    , gl_FRAMEBUFFER_UNSUPPORTED+    , gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT+    , gl_TEXTURE_DEFORMATION_SGIX+    , gl_CON_23_ATI+    , gl_CLIP_DISTANCE0+    , gl_COLOR_ATTACHMENT10+    , gl_POINT_SIZE_MAX_EXT+    , gl_TEXTURE5+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR+    , gl_PATH_MODELVIEW_MATRIX_NV+    , gl_LINE_LOOP+    , gl_MODELVIEW17_ARB+    , gl_UNSIGNED_INT16_VEC2_NV+    , gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES+    , gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS+    , gl_DRAW_BUFFER3_EXT+    , gl_TEXTURE_SHADOW+    , gl_STENCIL_ATTACHMENT+    , gl_MAP_STENCIL+    , gl_PATH_DASH_ARRAY_COUNT_NV+    , gl_BLEND+    , gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT+    , gl_TEXTURE_TARGET_QCOM+    , gl_NORMAL_MAP_OES+    , gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT+    , gl_TEXTURE20+    , gl_EDGE_FLAG_ARRAY_COUNT_EXT+    , gl_SMOOTH+    , gl_SHADER_INCLUDE_ARB+    , gl_CLAMP_TO_EDGE_SGIS+    , gl_COMPRESSED_ALPHA+    , gl_TEXTURE_IMAGE_FORMAT+    , gl_MAX_FRAMEBUFFER_LAYERS+    , gl_WRITEONLY_RENDERING_QCOM+    , gl_BACK_RIGHT+    , gl_INVARIANT_DATATYPE_EXT+    , gl_LINE_TO_NV+    , gl_PIXEL_UNPACK_BUFFER_BINDING_ARB+    , gl_LIST_BIT+    , gl_MAX_ATTRIB_STACK_DEPTH+    , gl_FRAGMENT_SHADER+    , gl_IMPLEMENTATION_COLOR_READ_FORMAT+    , gl_COLOR_TABLE_WIDTH_SGI+    , gl_DEBUG_OBJECT_MESA+    , gl_EYE_LINE_SGIS+    , gl_COMPRESSED_ALPHA_ARB+    , gl_DEPTH_BUFFER_BIT7_QCOM+    , gl_OPERAND2_RGB_ARB+    , gl_PROGRAM_BINARY_ANGLE+    , gl_MATRIX_EXT+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS+    , gl_RED_NV+    , gl_LIGHT7+    , gl_LOW_FLOAT+    , gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT+    , gl_CON_18_ATI+    , gl_UNIFORM_BUFFER_ADDRESS_NV+    , gl_VERTEX_ARRAY_BUFFER_BINDING_ARB+    , gl_RED_BIT_ATI+    , gl_TRACE_TEXTURES_BIT_MESA+    , gl_GEOMETRY_SHADER+    , gl_VERTEX_ARRAY_ADDRESS_NV+    , gl_TIMEOUT_IGNORED_APPLE+    , gl_RENDERBUFFER_BINDING+    , gl_RGB16F+    , gl_TEXTURE_COORD_ARRAY_LENGTH_NV+    , gl_MAX_FRAMEBUFFER_LAYERS_EXT+    , gl_MODELVIEW23_ARB+    , gl_BGR_EXT+    , gl_ONE_MINUS_SRC1_COLOR+    , gl_VARIANT_ARRAY_EXT+    , gl_RGB4+    , gl_RENDERBUFFER_DEPTH_SIZE_OES+    , gl_MAX_VARYING_COMPONENTS_EXT+    , gl_CURRENT_MATRIX_NV+    , gl_T2F_IUI_N3F_V3F_EXT+    , gl_SLUMINANCE8+    , gl_MODELVIEW1_MATRIX_EXT+    , gl_MODELVIEW29_ARB+    , gl_COLOR_ATTACHMENT5_EXT+    , gl_DOUBLE_MAT2+    , gl_RGBA12_EXT+    , gl_ACCUM_BLUE_BITS+    , gl_INVARIANT_EXT+    , gl_ACTIVE_UNIFORM_MAX_LENGTH+    , gl_FOG_SPECULAR_TEXTURE_WIN+    , gl_COLOR_TABLE_SCALE_SGI+    , gl_IUI_V3F_EXT+    , gl_UNSIGNED_INT_IMAGE_3D_EXT+    , gl_MAX_DEBUG_MESSAGE_LENGTH_KHR+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Y+    , gl_DOUBLE_VEC2+    , gl_MAX_SAMPLE_MASK_WORDS+    , gl_DEBUG_OUTPUT+    , gl_OBJECT_SHADER_SOURCE_LENGTH_ARB+    , gl_R32F_EXT+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV+    , gl_COPY_WRITE_BUFFER_BINDING+    , gl_TEXTURE15_ARB+    , gl_UNIFORM_BLOCK_NAME_LENGTH+    , gl_COLOR_ATTACHMENT4_NV+    , gl_DST_OVER_NV+    , gl_ATOMIC_COUNTER_BUFFER+    , gl_MAP1_VERTEX_ATTRIB12_4_NV+    , gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB+    , gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE+    , gl_RGB_RAW_422_APPLE+    , gl_MAX_RECTANGLE_TEXTURE_SIZE+    , gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT+    , gl_FRAGMENT_COLOR_MATERIAL_SGIX+    , gl_POST_COLOR_MATRIX_RED_SCALE_SGI+    , gl_VIBRANCE_SCALE_NV+    , gl_POINT_FADE_THRESHOLD_SIZE+    , gl_QUERY_NO_WAIT_NV+    , gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES+    , gl_RESAMPLE_REPLICATE_OML+    , gl_RENDERBUFFER_BINDING_ANGLE+    , gl_R1UI_V3F_SUN+    , gl_CONVOLUTION_2D+    , gl_OBJECT_TYPE+    , gl_MAX_MAP_TESSELLATION_NV+    , gl_DOUBLE_MAT4x3_EXT+    , gl_MULTISAMPLE_BUFFER_BIT4_QCOM+    , gl_UNSIGNED_INT64_AMD+    , gl_MAX_PATCH_VERTICES+    , gl_TEXTURE_COMPONENTS+    , gl_ELEMENT_ARRAY_POINTER_APPLE+    , gl_COLOR_ATTACHMENT6_NV+    , gl_MODELVIEW_PROJECTION_NV+    , gl_STATIC_ATI+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z+    , gl_CONVOLUTION_BORDER_MODE+    , gl_2PASS_0_SGIS+    , gl_GREEN_INTEGER_EXT+    , gl_DEBUG_TYPE_OTHER+    , gl_FRAMEBUFFER_SRGB_EXT+    , gl_COLOR_WRITEMASK+    , gl_TANGENT_ARRAY_EXT+    , gl_FONT_TARGET_UNAVAILABLE_NV+    , gl_FONT_UNAVAILABLE_NV+    , gl_COMBINER2_NV+    , gl_TEXTURE22_ARB+    , gl_PATH_INITIAL_DASH_CAP_NV+    , gl_SWIZZLE_STRQ_ATI+    , gl_OBJECT_LINE_SGIS+    , gl_MAX_NUM_ACTIVE_VARIABLES+    , gl_COLOR_ATTACHMENT3_EXT+    , gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI+    , gl_SCREEN_KHR+    , gl_ZOOM_X+    , gl_PROGRAM_MATRIX_EXT+    , gl_TEXTURE_VIEW+    , gl_NEGATIVE_ONE_TO_ONE+    , gl_CONVOLUTION_1D_EXT+    , gl_CLAMP_READ_COLOR+    , gl_REFLECTION_MAP+    , gl_PROXY_HISTOGRAM+    , gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS+    , gl_HALF_FLOAT_ARB+    , gl_LINE_QUALITY_HINT_SGIX+    , gl_MAP_WRITE_BIT_EXT+    , gl_PIXEL_TRANSFORM_2D_EXT+    , gl_INCR+    , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES+    , gl_LUMINANCE_FLOAT32_ATI+    , gl_EVAL_VERTEX_ATTRIB11_NV+    , gl_TEXTURE_COORD_ARRAY_SIZE+    , gl_IMAGE_BINDING_LEVEL_EXT+    , gl_RGBA16I_EXT+    , gl_T2F_IUI_N3F_V2F_EXT+    , gl_MIN_PROGRAM_TEXEL_OFFSET_NV+    , gl_EQUIV+    , gl_TEXTURE_BINDING_CUBE_MAP_ARB+    , gl_DRAW_BUFFER1_NV+    , gl_INTERLACE_READ_OML+    , gl_TEXTURE15+    , gl_NAND+    , gl_VERTEX_ARRAY_RANGE_APPLE+    , gl_CONDITION_SATISFIED_APPLE+    , gl_DISPATCH_INDIRECT_BUFFER_BINDING+    , gl_RG16I+    , gl_EYE_RADIAL_NV+    , gl_SLUMINANCE_ALPHA_EXT+    , gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL+    , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT+    , gl_RG32F+    , gl_SRC1_ALPHA+    , gl_RGBA2+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES+    , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT+    , gl_TEXTURE_COORD_ARRAY_STRIDE_EXT+    , gl_OUTPUT_TEXTURE_COORD10_EXT+    , gl_DEPTH_ATTACHMENT+    , gl_NORMAL_ARRAY_POINTER_EXT+    , gl_OPERAND0_ALPHA_ARB+    , gl_COMPRESSED_LUMINANCE_ARB+    , gl_LIST_PRIORITY_SGIX+    , gl_BOUNDING_BOX_NV+    , gl_PATCH_VERTICES_EXT+    , gl_COPY_INVERTED+    , gl_FRAMEBUFFER_BARRIER_BIT_EXT+    , gl_OBJECT_ACTIVE_ATTRIBUTES_ARB+    , gl_DISCRETE_AMD+    , gl_DOT3_RGBA_ARB+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES+    , gl_SET+    , gl_TEXTURE_MAX_ANISOTROPY_EXT+    , gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2+    , gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB+    , gl_MAP2_GRID_DOMAIN+    , gl_RENDERBUFFER_SAMPLES+    , gl_MAX_TEXTURE_LOD_BIAS+    , gl_DEPTH_PASS_INSTRUMENT_SGIX+    , gl_TEXTURE_COORD_NV+    , gl_PROGRAM_ERROR_POSITION_NV+    , gl_RENDERBUFFER_RED_SIZE_EXT+    , gl_INDEX_OFFSET+    , gl_CURRENT_FOG_COORD+    , gl_MIRRORED_REPEAT+    , gl_MAP_INVALIDATE_BUFFER_BIT+    , gl_MATRIX_INDEX_ARRAY_OES+    , gl_DRAW_BUFFER6_ATI+    , gl_INTENSITY12+    , gl_FLOAT_RGBA_NV+    , gl_SMOOTH_POINT_SIZE_RANGE+    , gl_COLOR_BUFFER_BIT1_QCOM+    , gl_TEXT_FRAGMENT_SHADER_ATI+    , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT+    , gl_CLIP_PLANE3+    , gl_NAMED_STRING_TYPE_ARB+    , gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB+    , gl_TEXTURE_VIEW_MIN_LEVEL+    , gl_SWIZZLE_STQ_ATI+    , gl_RGBA_FLOAT_MODE_ARB+    , gl_RG8UI+    , gl_FRAGMENT_DEPTH+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR+    , gl_MULTISAMPLE_SGIS+    , gl_PROXY_TEXTURE_1D+    , gl_MODELVIEW0_ARB+    , gl_LINE_STRIP_ADJACENCY_EXT+    , gl_RGBA16UI+    , gl_SRC_ATOP_NV+    , gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE+    , gl_REG_30_ATI+    , gl_4PASS_3_EXT+    , gl_INT_IMAGE_3D_EXT+    , gl_SYSTEM_FONT_NAME_NV+    , gl_DRAW_BUFFER6+    , gl_RG32I+    , gl_COLOR_BUFFER_BIT3_QCOM+    , gl_CURRENT_OCCLUSION_QUERY_ID_NV+    , gl_INTERNALFORMAT_STENCIL_SIZE+    , gl_STATIC_DRAW_ARB+    , gl_COMPRESSED_SRGB_ALPHA_EXT+    , gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI+    , gl_PALETTE8_RGBA4_OES+    , gl_FOG_START+    , gl_DEBUG_TYPE_POP_GROUP+    , gl_DRAW_BUFFER14_ATI+    , gl_IMAGE_1D_ARRAY+    , gl_RELATIVE_LARGE_CCW_ARC_TO_NV+    , gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV+    , gl_EXCLUSION_NV+    , gl_FONT_X_MAX_BOUNDS_BIT_NV+    , gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX+    , gl_DEPTH_BUFFER_BIT2_QCOM+    , gl_UNPACK_FLIP_Y_WEBGL+    , gl_COLOR_ATTACHMENT15_NV+    , gl_RG16F_EXT+    , gl_PRIMARY_COLOR+    , gl_UNIFORM_BLOCK_DATA_SIZE+    , gl_INTERNALFORMAT_STENCIL_TYPE+    , gl_COLOR_MATRIX_STACK_DEPTH_SGI+    , gl_AND+    , gl_GEOMETRY_INPUT_TYPE_ARB+    , gl_SAMPLER_BUFFER+    , gl_COLOR_BUFFER_BIT2_QCOM+    , gl_MAX_CLIP_DISTANCES+    , gl_OUTPUT_TEXTURE_COORD25_EXT+    , gl_SLIM8U_SGIX+    , gl_OP_DOT4_EXT+    , gl_INFO_LOG_LENGTH+    , gl_REG_25_ATI+    , gl_MAX_PROGRAM_CALL_DEPTH_NV+    , gl_VIRTUAL_PAGE_SIZE_INDEX_ARB+    , gl_MAX_PROGRAM_RESULT_COMPONENTS_NV+    , gl_RELATIVE_CONIC_CURVE_TO_NV+    , gl_CLIP_DISTANCE4+    , gl_UTF8_NV+    , gl_INVALID_INDEX+    , gl_DOT3_RGBA_IMG+    , gl_FRAGMENT_MATERIAL_EXT+    , gl_PACK_CMYK_HINT_EXT+    , gl_LUMINANCE_ALPHA8I_EXT+    , gl_PIXEL_BUFFER_BARRIER_BIT_EXT+    , gl_BUFFER_KHR+    , gl_STENCIL_BACK_OP_VALUE_AMD+    , gl_DST_COLOR+    , gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT+    , gl_ZERO+    , gl_COORD_REPLACE+    , gl_FRAMEBUFFER_SRGB+    , gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES+    , gl_CONSTANT+    , gl_TEXTURE_CONSTANT_DATA_SUNX+    , gl_MAX_DEBUG_MESSAGE_LENGTH+    , gl_MAX_VARYING_FLOATS+    , gl_PLUS_NV+    , gl_UNIFORM_NAME_LENGTH+    , gl_SECONDARY_COLOR_ARRAY_STRIDE+    , gl_MAP1_VERTEX_ATTRIB13_4_NV+    , gl_TRACK_MATRIX_TRANSFORM_NV+    , gl_MAX_COMPUTE_UNIFORM_COMPONENTS+    , gl_DOUBLE_MAT4+    , gl_TEXTURE_SRGB_DECODE_EXT+    , gl_TEXTURE_BORDER_COLOR+    , gl_DISPLAY_LIST+    , gl_COLOR_ENCODING+    , gl_EXPAND_NEGATE_NV+    , gl_UNPACK_ROW_LENGTH_EXT+    , gl_RGB_SCALE_ARB+    , gl_CURRENT_ATTRIB_NV+    , gl_TEXTURE25+    , gl_DEPTH+    , gl_DRAW_BUFFER2_ARB+    , gl_FENCE_CONDITION_NV+    , gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB+    , gl_OP_POWER_EXT+    , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB+    , gl_FRAMEBUFFER_DEFAULT+    , gl_COLOR_ATTACHMENT13_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE+    , gl_CUBIC_HP+    , gl_GREATER+    , gl_OP_MOV_EXT+    , gl_RED_SNORM+    , gl_ALPHA_MAX_CLAMP_INGR+    , gl_VERTEX_ATTRIB_ARRAY_LONG+    , gl_DEBUG_SEVERITY_LOW_ARB+    , gl_PURGEABLE_APPLE+    , gl_MAX_SHININESS_NV+    , gl_VERTEX_SHADER_INVARIANTS_EXT+    , gl_CLIP_DISTANCE1+    , gl_PROGRAM_NATIVE_PARAMETERS_ARB+    , gl_SRC_ALPHA_SATURATE+    , gl_COLOR_RENDERABLE+    , gl_LINE_STIPPLE+    , gl_COMPILE_AND_EXECUTE+    , gl_FOG_COORDINATE+    , gl_MULTISAMPLE_COVERAGE_MODES_NV+    , gl_OUTPUT_TEXTURE_COORD16_EXT+    , gl_SCALE_BY_FOUR_NV+    , gl_INDEX_ARRAY_BUFFER_BINDING_ARB+    , gl_MAX_TEXTURE_IMAGE_UNITS_ARB+    , gl_HALF_BIAS_NEGATE_NV+    , gl_INT_IMAGE_2D_MULTISAMPLE_EXT+    , gl_CON_30_ATI+    , gl_SAMPLE_ALPHA_TO_ONE_EXT+    , gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB+    , gl_STORAGE_CACHED_APPLE+    , gl_SAMPLER_2D_SHADOW+    , gl_ALPHA_FLOAT16_APPLE+    , gl_PERFQUERY_COUNTER_EVENT_INTEL+    , gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB+    , gl_BACK_PRIMARY_COLOR_NV+    , gl_PROGRAM_PARAMETERS_ARB+    , gl_MIN_SPARSE_LEVEL_AMD+    , gl_INT_SAMPLER_1D_ARRAY_EXT+    , gl_DOUBLEBUFFER+    , gl_NEGATIVE_W_EXT+    , gl_VIEW_CLASS_RGTC1_RED+    , gl_PROGRAM_KHR+    , gl_LINEARDODGE_NV+    , gl_NORMALIZED_RANGE_EXT+    , gl_BUFFER_SERIALIZED_MODIFY_APPLE+    , gl_TEXTURE3_ARB+    , gl_INDEX_TEST_FUNC_EXT+    , gl_COMPUTE_TEXTURE+    , gl_UNSIGNED_INT_IMAGE_BUFFER_EXT+    , gl_CON_9_ATI+    , gl_RELATIVE_LINE_TO_NV+    , gl_TEXTURE_RECTANGLE_NV+    , gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE+    , gl_COMPRESSED_RGBA_ASTC_6x5_KHR+    , gl_TEXTURE_LUMINANCE_SIZE+    , gl_PROJECTION_MATRIX+    , gl_VIBRANCE_BIAS_NV+    , gl_MAX_VERTEX_ATOMIC_COUNTERS+    , gl_FOG_COORD_ARRAY_POINTER+    , gl_POLYGON_OFFSET_BIAS_EXT+    , gl_DEBUG_SOURCE_OTHER+    , gl_LINEAR_SHARPEN_ALPHA_SGIS+    , gl_AVERAGE_EXT+    , gl_PACK_SKIP_IMAGES_EXT+    , gl_BITMAP_TOKEN+    , gl_TESSELLATION_MODE_AMD+    , gl_POST_CONVOLUTION_COLOR_TABLE_SGI+    , gl_MODELVIEW1_EXT+    , gl_OPERAND1_RGB_ARB+    , gl_4D_COLOR_TEXTURE+    , gl_ACTIVE_ATTRIBUTES+    , gl_BUFFER_BINDING+    , gl_VERTEX_STATE_PROGRAM_NV+    , gl_DST_ATOP_NV+    , gl_TEXTURE_DEPTH_EXT+    , gl_UNSIGNED_INT_VEC4+    , gl_GREEN_INTEGER+    , gl_DOUBLE_MAT4x2_EXT+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR+    , gl_INDEX_ARRAY_LIST_IBM+    , gl_SAMPLER_2D_ARRAY_SHADOW+    , gl_COMPRESSED_SRGB_S3TC_DXT1_NV+    , gl_COMPRESSED_RGBA_ASTC_4x3x3_OES+    , gl_DRAW_BUFFER3_ATI+    , gl_MAX_FRAGMENT_UNIFORM_COMPONENTS+    , gl_PROXY_TEXTURE_3D_EXT+    , gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT+    , gl_PATH_COMPUTED_LENGTH_NV+    , gl_DEPTH_STENCIL_MESA+    , gl_MAT_DIFFUSE_BIT_PGI+    , gl_TEXTURE_STENCIL_SIZE+    , gl_PATH_PROJECTION_NV+    , gl_DUAL_TEXTURE_SELECT_SGIS+    , gl_MATRIX14_ARB+    , gl_PATH_OBJECT_BOUNDING_BOX_NV+    , gl_READ_PIXELS+    , gl_TRIANGLE_LIST_SUN+    , gl_COMPARE_R_TO_TEXTURE+    , gl_INTENSITY8UI_EXT+    , gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB+    , gl_COLOR_TABLE_GREEN_SIZE+    , gl_CURRENT_VERTEX_ATTRIB+    , gl_POST_COLOR_MATRIX_GREEN_BIAS+    , gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX+    , gl_SUBSAMPLE_DISTANCE_AMD+    , gl_SRGB8_EXT+    , gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS+    , gl_INCR_WRAP_EXT+    , gl_UNPACK_COMPRESSED_BLOCK_SIZE+    , gl_OBJECT_VALIDATE_STATUS_ARB+    , gl_WEIGHT_ARRAY_STRIDE_ARB+    , gl_OUTPUT_TEXTURE_COORD3_EXT+    , gl_TEXTURE16_ARB+    , gl_VIDEO_COLOR_CONVERSION_MATRIX_NV+    , gl_EYE_DISTANCE_TO_POINT_SGIS+    , gl_TEXTURE_COMPARE_FUNC+    , gl_DEPTH_BUFFER_FLOAT_MODE_NV+    , gl_TEXTURE_SWIZZLE_G+    , gl_DEBUG_TYPE_OTHER_ARB+    , gl_TESS_EVALUATION_SHADER_BIT_EXT+    , gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA+    , gl_INT_SAMPLER_BUFFER_EXT+    , gl_OP_CLAMP_EXT+    , gl_POINT_SIZE_MIN+    , gl_UNSIGNED_BYTE_3_3_2_EXT+    , gl_TEXTURE_CLIPMAP_DEPTH_SGIX+    , gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT+    , gl_DOUBLE_VEC4_EXT+    , gl_SYNC_CONDITION_APPLE+    , gl_MAX_TEXTURE_COORDS_NV+    , gl_RELATIVE_QUADRATIC_CURVE_TO_NV+    , gl_DEBUG_GROUP_STACK_DEPTH_KHR+    , gl_CONTEXT_LOST_KHR+    , gl_QUADRATIC_CURVE_TO_NV+    , gl_MIN_EXT+    , gl_VERTEX_ATTRIB_ARRAY11_NV+    , gl_FACTOR_ALPHA_MODULATE_IMG+    , gl_MAP1_GRID_DOMAIN+    , gl_COLOR_MATRIX_STACK_DEPTH+    , gl_IMAGE_PIXEL_FORMAT+    , gl_DRAW_BUFFER1_EXT+    , gl_UNSIGNED_INT_VEC2+    , gl_QUAD_LUMINANCE8_SGIS+    , gl_ELEMENT_ARRAY_UNIFIED_NV+    , gl_COLOR_LOGIC_OP+    , gl_GREEN_NV+    , gl_DEPTH_COMPONENT+    , gl_TEXTURE18+    , gl_COMBINER_SUM_OUTPUT_NV+    , gl_DUAL_LUMINANCE8_SGIS+    , gl_PATH_DASH_OFFSET_RESET_NV+    , gl_INT_SAMPLER_BUFFER+    , gl_DEBUG_SEVERITY_MEDIUM_ARB+    , gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT+    , gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX+    , gl_UNSIGNED_SHORT_15_1_MESA+    , gl_LUMINANCE32F_ARB+    , gl_TRANSPOSE_NV+    , gl_LUMINANCE8_EXT+    , gl_WRITE_DISCARD_NV+    , gl_STENCIL_BUFFER_BIT5_QCOM+    , gl_FOG_END+    , gl_DRAW_BUFFER9_NV+    , gl_PROVOKING_VERTEX_EXT+    , gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS+    , gl_2PASS_0_EXT+    , gl_MAP_UNSYNCHRONIZED_BIT+    , gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI+    , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV+    , gl_SAMPLER_CUBE_SHADOW+    , gl_V2F+    , gl_IMAGE_2D_EXT+    , gl_LUMINANCE32UI_EXT+    , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT+    , gl_SLUMINANCE8_ALPHA8_NV+    , gl_MAX_ASYNC_DRAW_PIXELS_SGIX+    , gl_POINT_SIZE_ARRAY_TYPE_OES+    , gl_SIGNED_LUMINANCE8_ALPHA8_NV+    , gl_UNSIGNED_INT_24_8_EXT+    , gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV+    , gl_CONIC_CURVE_TO_NV+    , gl_STREAM_DRAW_ARB+    , gl_ACTIVE_PROGRAM_EXT+    , gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB+    , gl_PROGRAM_RESIDENT_NV+    , gl_COLOR_TABLE_ALPHA_SIZE_SGI+    , gl_INT_IMAGE_2D_ARRAY_EXT+    , gl_OUTPUT_TEXTURE_COORD15_EXT+    , gl_SRC_OUT_NV+    , gl_MAP_FLUSH_EXPLICIT_BIT+    , gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB+    , gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS+    , gl_EVAL_VERTEX_ATTRIB2_NV+    , gl_PIXEL_TILE_WIDTH_SGIX+    , gl_PROXY_TEXTURE_RECTANGLE+    , gl_VERTEX_ARRAY_BINDING+    , gl_CLIP_PLANE4+    , gl_EVAL_VERTEX_ATTRIB15_NV+    , gl_POINT_FADE_THRESHOLD_SIZE_ARB+    , gl_UNSIGNED_INT_5_9_9_9_REV_EXT+    , gl_DEBUG_GROUP_STACK_DEPTH+    , gl_QUERY_WAIT_INVERTED+    , gl_DRAW_PIXEL_TOKEN+    , gl_OPERAND2_ALPHA_ARB+    , gl_STACK_UNDERFLOW+    , gl_FLOAT_VEC4_ARB+    , gl_OBJECT_INFO_LOG_LENGTH_ARB+    , gl_DRAW_BUFFER15_EXT+    , gl_PATH_PROJECTION_MATRIX_NV+    , gl_ADD_SIGNED+    , gl_FRAGMENT_INTERPOLATION_OFFSET_BITS+    , gl_VERTEX_SHADER_INSTRUCTIONS_EXT+    , gl_NEXT_BUFFER_NV+    , gl_TRIANGLE_STRIP_ADJACENCY_ARB+    , gl_UNSIGNED_BYTE_2_3_3_REV_EXT+    , gl_QUERY_RESULT_NO_WAIT+    , gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV+    , gl_ALPHA16_SNORM+    , gl_COLOR_ARRAY_LENGTH_NV+    , gl_SLUMINANCE_EXT+    , gl_DOT_PRODUCT_TEXTURE_2D_NV+    , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES+    , gl_INT_IMAGE_2D_ARRAY+    , gl_POLYGON_OFFSET_LINE+    , gl_ONE_MINUS_DST_ALPHA+    , gl_ACCUM_BUFFER_BIT+    , gl_SOURCE1_ALPHA_ARB+    , gl_HISTOGRAM_WIDTH_EXT+    , gl_RENDERBUFFER_SAMPLES_EXT+    , gl_FRAGMENT_LIGHTING_SGIX+    , gl_TEXTURE_WIDTH_QCOM+    , gl_TEXTURE_BUFFER_FORMAT_EXT+    , gl_VERTEX_PROGRAM_TWO_SIDE+    , gl_DEBUG_TYPE_OTHER_KHR+    , gl_PRIMARY_COLOR_EXT+    , gl_TEXTURE_COMPRESSED_ARB+    , gl_PROXY_TEXTURE_1D_ARRAY_EXT+    , gl_NORMAL_ARRAY_TYPE+    , gl_POST_COLOR_MATRIX_RED_BIAS_SGI+    , gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB+    , gl_VERTEX_ATTRIB_ARRAY7_NV+    , gl_MAX_VERTEX_ATTRIB_STRIDE+    , gl_COLOR+    , gl_YCBCR_422_APPLE+    , gl_TESS_GEN_SPACING+    , gl_VERTEX_SHADER_INVOCATIONS_ARB+    , gl_STENCIL_INDEX4_OES+    , gl_COMBINER_CD_DOT_PRODUCT_NV+    , gl_VIRTUAL_PAGE_SIZE_Z_ARB+    , gl_RIGHT+    , gl_ALPHA16F_ARB+    , gl_TANGENT_ARRAY_TYPE_EXT+    , gl_READ_FRAMEBUFFER_NV+    , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT+    , gl_PALETTE4_RGB8_OES+    , gl_UNSIGNED_INT_IMAGE_3D+    , gl_NORMAL_ARRAY_ADDRESS_NV+    , gl_NO_RESET_NOTIFICATION_EXT+    , gl_RGB4_S3TC+    , gl_AUX1+    , gl_MODELVIEW1_ARB+    , gl_OP_NEGATE_EXT+    , gl_PACK_COMPRESSED_BLOCK_HEIGHT+    , gl_RENDERBUFFER_BINDING_OES+    , gl_INT_IMAGE_1D+    , gl_TEXTURE_GEQUAL_R_SGIX+    , gl_VERTEX_BINDING_DIVISOR+    , gl_BLEND_SRC_ALPHA_OES+    , gl_READ_BUFFER_NV+    , gl_DEBUG_TYPE_ERROR_KHR+    , gl_INT_IMAGE_CUBE_EXT+    , gl_COMPRESSED_RGBA_ASTC_6x6x6_OES+    , gl_IMAGE_MIN_FILTER_HP+    , gl_QUAD_ALPHA8_SGIS+    , gl_IMAGE_BINDING_LEVEL+    , gl_DOT3_RGB_EXT+    , gl_SAMPLER_3D_OES+    , gl_INT_VEC4+    , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT+    , gl_NO_RESET_NOTIFICATION_ARB+    , gl_IMAGE_MAG_FILTER_HP+    , gl_COLOR4_BIT_PGI+    , gl_MAX_CLIPMAP_DEPTH_SGIX+    , gl_DEBUG_CATEGORY_OTHER_AMD+    , gl_INT_IMAGE_2D_MULTISAMPLE+    , gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL+    , gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB+    , gl_BINORMAL_ARRAY_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT+    , gl_DRAW_BUFFER9_ARB+    , gl_DSDT8_NV+    , gl_MAP1_VERTEX_ATTRIB9_4_NV+    , gl_PROGRAM_OBJECT_ARB+    , gl_FONT_UNDERLINE_POSITION_BIT_NV+    , gl_SHADER_OPERATION_NV+    , gl_QUERY_RESULT_AVAILABLE_EXT+    , gl_VIVIDLIGHT_NV+    , gl_HSL_HUE_NV+    , gl_EMBOSS_MAP_NV+    , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB+    , gl_ALL_BARRIER_BITS+    , gl_TEXTURE11_ARB+    , gl_BOLD_BIT_NV+    , gl_SAMPLE_BUFFERS_3DFX+    , gl_INTERNALFORMAT_ALPHA_SIZE+    , gl_COMPRESSED_RGBA_ASTC_8x8_KHR+    , gl_VIRTUAL_PAGE_SIZE_Z_AMD+    , gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE+    , gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB+    , gl_DRAW_PIXELS_APPLE+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB+    , gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX+    , gl_DRAW_INDIRECT_ADDRESS_NV+    , gl_COVERAGE_BUFFER_BIT_NV+    , gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT+    , gl_BLUE_NV+    , gl_TEXTURE0_ARB+    , gl_DEBUG_SOURCE_THIRD_PARTY_ARB+    , gl_TEXTURE_NORMAL_EXT+    , gl_TEXTURE_BUFFER_FORMAT_ARB+    , gl_OPERAND0_ALPHA+    , gl_FLOAT_MAT2x3+    , gl_TEXTURE_BINDING+    , gl_INT_SAMPLER_2D+    , gl_OR+    , gl_INT16_VEC2_NV+    , gl_DUAL_ALPHA4_SGIS+    , gl_FRAMEZOOM_FACTOR_SGIX+    , gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT+    , gl_RGB_INTEGER+    , gl_UNSIGNED_INT64_VEC2_NV+    , gl_OUTPUT_TEXTURE_COORD21_EXT+    , gl_ENABLE_BIT+    , gl_POLYGON_OFFSET_EXT+    , gl_PIXEL_TEX_GEN_MODE_SGIX+    , gl_LINE_SMOOTH+    , gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB+    , gl_COLOR_TABLE_LUMINANCE_SIZE_SGI+    , gl_COLOR_BUFFER_BIT7_QCOM+    , gl_PATH_FILL_MODE_NV+    , gl_IMAGE_CUBE+    , gl_CON_5_ATI+    , gl_COLOR_ATTACHMENT2_EXT+    , gl_FAILURE_NV+    , gl_VERTEX_ARRAY_LIST_STRIDE_IBM+    , gl_MAX_SPARSE_TEXTURE_SIZE_ARB+    , gl_VERSION_ES_CL_1_1+    , gl_PERFMON_GLOBAL_MODE_QCOM+    , gl_DEPTH_COMPONENT32F+    , gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT+    , gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS+    , gl_IMAGE_2D_MULTISAMPLE_EXT+    , gl_FRAMEBUFFER_OES+    , gl_TRANSPOSE_PROJECTION_MATRIX+    , gl_BUFFER_MAP_POINTER+    , gl_INT_10_10_10_2_OES+    , gl_PROGRAM_PIPELINE_OBJECT_EXT+    , gl_GEOMETRY_SHADER_INVOCATIONS_EXT+    , gl_SPRITE_AXIS_SGIX+    , gl_RED_INTEGER_EXT+    , gl_COMPRESSED_RGBA_ASTC_10x6_KHR+    , gl_TEXTURE_COORD_ARRAY_COUNT_EXT+    , gl_SIGNED_RGB_NV+    , gl_CW+    , gl_PACK_SUBSAMPLE_RATE_SGIX+    , gl_TEXTURE14_ARB+    , gl_OUTPUT_TEXTURE_COORD26_EXT+    , gl_DRAW_BUFFER+    , gl_PACK_ROW_BYTES_APPLE+    , gl_BLUE_INTEGER_EXT+    , gl_STORAGE_CLIENT_APPLE+    , gl_ALL_SHADER_BITS+    , gl_FOG_COORDINATE_ARRAY_POINTER+    , gl_ACTIVE_PROGRAM+    , gl_RGBA32F_ARB+    , gl_VERTEX_ATTRIB_ARRAY_INTEGER+    , gl_MAP2_VERTEX_ATTRIB13_4_NV+    , gl_SAMPLER_2D+    , gl_QUERY+    , gl_GEOMETRY_INPUT_TYPE_EXT+    , gl_RGB5_A1_OES+    , gl_MATRIX15_ARB+    , gl_INT_IMAGE_CUBE_MAP_ARRAY+    , gl_STACK_OVERFLOW+    , gl_NORMAL_ARRAY_LENGTH_NV+    , gl_RENDERBUFFER_BLUE_SIZE_EXT+    , gl_TEXTURE_INTENSITY_SIZE_EXT+    , gl_POINT_SIZE_MIN_SGIS+    , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW+    , gl_BEVEL_NV+    , gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX+    , gl_SIGNED_RGBA_NV+    , gl_COLOR_CLEAR_VALUE+    , gl_ARRAY_BUFFER+    , gl_CLIP_PLANE2_IMG+    , gl_POLYGON_OFFSET_UNITS+    , gl_COLOR_ARRAY_POINTER_EXT+    , gl_POST_COLOR_MATRIX_COLOR_TABLE+    , gl_SHADOW_AMBIENT_SGIX+    , gl_SAMPLES+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES+    , gl_MIRRORED_REPEAT_IBM+    , gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES+    , gl_FRAMEBUFFER_DEFAULT_WIDTH+    , gl_TEXTURE_GEN_MODE_OES+    , gl_BLEND_SRC_ALPHA_EXT+    , gl_OUTPUT_COLOR0_EXT+    , gl_SLUMINANCE8_ALPHA8+    , gl_SAMPLER_3D_ARB+    , gl_UNSIGNED_INT_SAMPLER_3D+    , gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT+    , gl_PATH_FORMAT_SVG_NV+    , gl_MAP1_BINORMAL_EXT+    , gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX+    , gl_COLOR_ARRAY_BUFFER_BINDING+    , gl_MATRIX_INDEX_ARRAY_TYPE_OES+    , gl_PROJECTION_STACK_DEPTH+    , gl_AUTO_NORMAL+    , gl_FRAGMENT_SHADER_ATI+    , gl_SAMPLE_BUFFERS_EXT+    , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT+    , gl_UNSIGNED_INT_10_10_10_2+    , gl_COMPRESSED_RG11_EAC_OES+    , gl_LUMINANCE8I_EXT+    , gl_VERTEX_ATTRIB_ARRAY13_NV+    , gl_UNIFORM_BUFFER_SIZE+    , gl_TEXTURE2_ARB+    , gl_COMPRESSED_RGBA_BPTC_UNORM_ARB+    , gl_POLYGON+    , gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT+    , gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB+    , gl_SAMPLE_BUFFERS_ARB+    , gl_RGBA4_DXT5_S3TC+    , gl_STREAM_READ+    , gl_STATIC_READ+    , gl_MAX_FRAGMENT_ATOMIC_COUNTERS+    , gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT+    , gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST+    , gl_COUNT_DOWN_NV+    , gl_SLUMINANCE+    , gl_INNOCENT_CONTEXT_RESET+    , gl_DRAW_FRAMEBUFFER_BINDING_NV+    , gl_VERTEX_STREAM3_ATI+    , gl_TRIANGULAR_NV+    , gl_SAMPLER_2D_RECT_ARB+    , gl_POST_CONVOLUTION_GREEN_SCALE_EXT+    , gl_SKIP_COMPONENTS2_NV+    , gl_IMAGE_1D+    , gl_ATTRIB_ARRAY_TYPE_NV+    , gl_ORDER+    , gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB+    , gl_RGB4_EXT+    , gl_COMPRESSED_TEXTURE_FORMATS_ARB+    , gl_STENCIL_INDEX16_EXT+    , gl_OP_RECIP_SQRT_EXT+    , gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS+    , gl_MAX_PROGRAM_TEXEL_OFFSET+    , gl_POST_TEXTURE_FILTER_BIAS_SGIX+    , gl_RGB32F_EXT+    , gl_SURFACE_REGISTERED_NV+    , gl_RGBA_FLOAT16_APPLE+    , gl_VIDEO_BUFFER_BINDING_NV+    , gl_PRIMITIVE_RESTART_INDEX+    , gl_DOT3_RGB_ARB+    , gl_INT64_VEC4_NV+    , gl_DRAW_BUFFER12_ATI+    , gl_RESAMPLE_REPLICATE_SGIX+    , gl_ALPHA+    , gl_MATRIX22_ARB+    , gl_DEPTH_TEST+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR+    , gl_BLEND_SRC_ALPHA+    , gl_MIRROR_CLAMP_ATI+    , gl_COMBINER3_NV+    , gl_TEXTURE_BINDING_1D_ARRAY_EXT+    , gl_MIRROR_CLAMP_TO_BORDER_EXT+    , gl_MAP1_INDEX+    , gl_VIEW_CLASS_BPTC_FLOAT+    , gl_TRANSPOSE_AFFINE_2D_NV+    , gl_IMAGE_CLASS_2_X_8+    , gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB+    , gl_EYE_POINT_SGIS+    , gl_TEXTURE_DEPTH_SIZE_ARB+    , gl_GLYPH_HAS_KERNING_BIT_NV+    , gl_ACTIVE_SUBROUTINES+    , gl_MVP_MATRIX_EXT+    , gl_READ_FRAMEBUFFER_BINDING+    , gl_GUILTY_CONTEXT_RESET_EXT+    , gl_ALPHA16UI_EXT+    , gl_TEXTURE_SWIZZLE_B_EXT+    , gl_RGB16I_EXT+    , gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB+    , gl_VERTEX_WEIGHT_ARRAY_EXT+    , gl_SWIZZLE_STR_DR_ATI+    , gl_READ_FRAMEBUFFER+    , gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI+    , gl_COORD_REPLACE_NV+    , gl_MAX_CLIP_PLANES+    , gl_DRAW_BUFFER0+    , gl_SPRITE_OBJECT_ALIGNED_SGIX+    , gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX+    , gl_CONSERVE_MEMORY_HINT_PGI+    , gl_GET_TEXTURE_IMAGE_FORMAT+    , gl_MOVE_TO_RESETS_NV+    , gl_SHADER_CONSISTENT_NV+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT+    , gl_PACK_ALIGNMENT+    , gl_HISTOGRAM_ALPHA_SIZE+    , gl_SHARED_TEXTURE_PALETTE_EXT+    , gl_MODELVIEW0_MATRIX_EXT+    , gl_MAX_NAME_LENGTH+    , gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY+    , gl_IMAGE_2D+    , gl_QUERY_BUFFER_AMD+    , gl_BUMP_ENVMAP_ATI+    , gl_POINTS+    , gl_ARRAY_SIZE+    , gl_MAX_CLIP_PLANES_IMG+    , gl_TRIANGLE_STRIP_ADJACENCY_EXT+    , gl_VERTEX_STREAM6_ATI+    , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR+    , gl_TEXTURE22+    , gl_CURRENT_FOG_COORDINATE+    , gl_CON_27_ATI+    , gl_MAX_VERTEX_UNITS_OES+    , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT+    , gl_SIGNED_INTENSITY8_NV+    , gl_MAX_EVAL_ORDER+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT+    , gl_DYNAMIC_READ_ARB+    , gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV+    , gl_FLOAT16_NV+    , gl_COMPUTE_SHADER_INVOCATIONS_ARB+    , gl_VERTEX_SHADER_OPTIMIZED_EXT+    , gl_TEXTURE_LOD_BIAS_EXT+    , gl_INT8_VEC3_NV+    , gl_4PASS_0_SGIS+    , gl_HISTOGRAM_EXT+    , gl_ALLOW_DRAW_WIN_HINT_PGI+    , gl_TEXTURE_GREEN_SIZE_EXT+    , gl_R32I+    , gl_REG_22_ATI+    , gl_UNSIGNED_INT_ATOMIC_COUNTER+    , gl_COLOR_ATTACHMENT2+    , gl_INTENSITY8+    , gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS+    , gl_FOG_DENSITY+    , gl_RENDERBUFFER_HEIGHT_EXT+    , gl_Z_EXT+    , gl_TEXTURE_FETCH_BARRIER_BIT+    , gl_PROGRAM_BINARY_FORMATS+    , gl_UNSIGNED_INT_IMAGE_BUFFER+    , gl_OPERAND0_RGB+    , gl_COVERAGE_COMPONENT_NV+    , gl_NEGATE_BIT_ATI+    , gl_DEBUG_TYPE_PUSH_GROUP+    , gl_SELECT+    , gl_IMAGE_BINDING_ACCESS_EXT+    , gl_TEXTURE_GEN_STR_OES+    , gl_OCCLUSION_TEST_HP+    , gl_BLEND_DST_RGB_OES+    , gl_IMAGE_BINDING_NAME+    , gl_DUAL_LUMINANCE_ALPHA8_SGIS+    , gl_POLYGON_BIT+    , gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI+    , gl_COLOR_ATTACHMENT8_EXT+    , gl_BLUE_BIAS+    , gl_EMISSION+    , gl_DEPTH_ATTACHMENT_OES+    , gl_POLYGON_OFFSET_FACTOR_EXT+    , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT+    , gl_TEXTURE_MATERIAL_FACE_EXT+    , gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI+    , gl_DRAW_FRAMEBUFFER_ANGLE+    , gl_DEPTH_BUFFER_BIT3_QCOM+    , gl_DISTANCE_ATTENUATION_EXT+    , gl_TRACE_ARRAYS_BIT_MESA+    , gl_MOVE_TO_NV+    , gl_2PASS_1_SGIS+    , gl_DUAL_LUMINANCE4_SGIS+    , gl_PRIMITIVES_SUBMITTED_ARB+    , gl_TOP_LEVEL_ARRAY_STRIDE+    , gl_NORMAL_ARRAY_STRIDE+    , gl_TEXTURE_2D_ARRAY_EXT+    , gl_UNPACK_COMPRESSED_BLOCK_WIDTH+    , gl_TEXTURE_FIXED_SAMPLE_LOCATIONS+    , gl_YCRCBA_SGIX+    , gl_LOCATION_COMPONENT+    , gl_TEXTURE27+    , gl_CONTEXT_FLAG_DEBUG_BIT_KHR+    , gl_FOG_COORDINATE_EXT+    , gl_DEBUG_CALLBACK_USER_PARAM_KHR+    , gl_MIRRORED_REPEAT_OES+    , gl_SYNC_GPU_COMMANDS_COMPLETE+    , gl_SLUMINANCE8_ALPHA8_EXT+    , gl_TEXTURE_BUFFER_OFFSET+    , gl_PROXY_COLOR_TABLE+    , gl_FIXED+    , gl_SRGB8+    , gl_COMPRESSED_RGBA+    , gl_IMAGE_BINDING_FORMAT+    , gl_MAX_RENDERBUFFER_SIZE_OES+    , gl_DEBUG_SOURCE_API+    , gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH+    , gl_CLIP_PLANE3_IMG+    , gl_TEXTURE16+    , gl_FRAGMENTS_INSTRUMENT_SGIX+    , gl_MATRIX8_ARB+    , gl_DOUBLE_MAT2x4+    , gl_DRAW_BUFFER9_ATI+    , gl_CURRENT_TEXTURE_COORDS+    , gl_DOT_PRODUCT_TEXTURE_3D_NV+    , gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT+    , gl_UNSIGNED_INT_IMAGE_2D_ARRAY+    , gl_FRAMEBUFFER_BARRIER_BIT+    , gl_MAX_SAMPLES_IMG+    , gl_TESS_CONTROL_SHADER_BIT_EXT+    , gl_PROGRAM_NATIVE_TEMPORARIES_ARB+    , gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG+    , gl_VERTEX_PROGRAM_ARB+    , gl_MAP2_BINORMAL_EXT+    , gl_ETC1_RGB8_OES+    , gl_PROGRAM_MATRIX_STACK_DEPTH_EXT+    , gl_TEXTURE_USAGE_ANGLE+    , gl_TEXTURE_MATRIX+    , gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT+    , gl_INDEX_ARRAY_STRIDE+    , gl_POST_COLOR_MATRIX_BLUE_SCALE+    , gl_TESS_CONTROL_OUTPUT_VERTICES+    , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET+    , gl_COMPRESSED_RGBA_ASTC_6x6_KHR+    , gl_INTERNALFORMAT_SHARED_SIZE+    , gl_SOURCE1_RGB_EXT+    , gl_STENCIL_PASS_DEPTH_FAIL+    , gl_MATRIX_PALETTE_OES+    , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET+    , gl_DOT3_RGBA_EXT+    , gl_CLIP_VOLUME_CLIPPING_HINT_EXT+    , gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV+    , gl_FONT_X_MIN_BOUNDS_BIT_NV+    , gl_WRAP_BORDER_SUN+    , gl_MAP_INVALIDATE_RANGE_BIT+    , gl_PATH_MODELVIEW_NV+    , gl_TESS_CONTROL_SHADER+    , gl_VERTEX_STREAM1_ATI+    , gl_R3_G3_B2+    , gl_LARGE_CW_ARC_TO_NV+    , gl_PRIMITIVE_BOUNDING_BOX_EXT+    , gl_ALPHA_BIAS+    , gl_DST_IN_NV+    , gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT+    , gl_NUM_FILL_STREAMS_NV+    , gl_ATTRIB_ARRAY_POINTER_NV+    , gl_SOURCE0_RGB_ARB+    , gl_MAX_PROGRAM_TEXEL_OFFSET_EXT+    , gl_MATRIX27_ARB+    , gl_R11F_G11F_B10F+    , gl_ATOMIC_COUNTER_BUFFER_INDEX+    , gl_TEXTURE_SWIZZLE_R_EXT+    , gl_MAX_ASYNC_READ_PIXELS_SGIX+    , gl_ACTIVE_TEXTURE_ARB+    , gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT+    , gl_REFERENCE_PLANE_SGIX+    , gl_UNPACK_CLIENT_STORAGE_APPLE+    , gl_SKIP_DECODE_EXT+    , gl_MAP2_VERTEX_ATTRIB10_4_NV+    , gl_ALIASED_POINT_SIZE_RANGE+    , gl_MATRIX1_NV+    , gl_CCW+    , gl_SIGNED_RGB_UNSIGNED_ALPHA_NV+    , gl_TEXTURE_BUFFER_BINDING_EXT+    , gl_LINEAR_ATTENUATION+    , gl_FACTOR_MIN_AMD+    , gl_POINT_SPRITE_NV+    , gl_IMAGE_FORMAT_COMPATIBILITY_TYPE+    , gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD+    , gl_MAP2_VERTEX_ATTRIB4_4_NV+    , gl_PATCHES_EXT+    , gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS+    , gl_OUTPUT_TEXTURE_COORD14_EXT+    , gl_V3F+    , gl_4PASS_2_EXT+    , gl_SAMPLES_3DFX+    , gl_MINOR_VERSION+    , gl_MAX_DEBUG_LOGGED_MESSAGES_ARB+    , gl_FUNC_REVERSE_SUBTRACT+    , gl_LAYOUT_LINEAR_CPU_CACHED_INTEL+    , gl_MULTISAMPLE_BUFFER_BIT1_QCOM+    , gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV+    , gl_PATH_COVER_DEPTH_FUNC_NV+    , gl_MAX_FRAGMENT_IMAGE_UNIFORMS+    , gl_PROXY_TEXTURE_COLOR_TABLE_SGI+    , gl_PIXEL_MAP_I_TO_A_SIZE+    , gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR+    , gl_FRAME_NV+    , gl_FLOAT_R_NV+    , gl_REFLECTION_MAP_EXT+    , gl_RG_SNORM+    , gl_REPLACE_MIDDLE_SUN+    , gl_COMBINER_MAPPING_NV+    , gl_ELEMENT_ARRAY_BUFFER_ARB+    , gl_SECONDARY_COLOR_ARRAY_LENGTH_NV+    , gl_INTERPOLATE_ARB+    , gl_POSITION+    , gl_PIXEL_MAP_S_TO_S+    , gl_READ_ONLY_ARB+    , gl_INVALID_FRAMEBUFFER_OPERATION_OES+    , gl_3DC_X_AMD+    , gl_FRAGMENT_LIGHT2_SGIX+    , gl_IMAGE_SCALE_Y_HP+    , gl_READ_FRAMEBUFFER_APPLE+    , gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES+    , gl_INDEX_MATERIAL_PARAMETER_EXT+    , gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH+    , gl_CUBIC_CURVE_TO_NV+    , gl_QUAD_ALPHA4_SGIS+    , gl_FORCE_BLUE_TO_ONE_NV+    , gl_DOT_PRODUCT_DEPTH_REPLACE_NV+    , gl_MAX_VERTEX_OUTPUT_COMPONENTS+    , gl_COMPRESSED_RGBA_ASTC_4x4x3_OES+    , gl_COLOR_INDEX1_EXT+    , gl_RELATIVE_CUBIC_CURVE_TO_NV+    , gl_NOR+    , gl_CLIPPING_OUTPUT_PRIMITIVES_ARB+    , gl_VERTEX_ATTRIB_ARRAY12_NV+    , gl_LINE_BIT+    , gl_FOG_COORDINATE_ARRAY_STRIDE+    , gl_DUP_FIRST_CUBIC_CURVE_TO_NV+    , gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES+    , gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS+    , gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV+    , gl_FRAGMENT_LIGHT1_SGIX+    , gl_PALETTE8_R5_G6_B5_OES+    , gl_DUAL_INTENSITY4_SGIS+    , gl_TEXTURE_RANGE_LENGTH_APPLE+    , gl_TEXTURE_RECTANGLE_ARB+    , gl_LUMINANCE16F_EXT+    , gl_DEPTH_COMPONENT16_ARB+    , gl_BUMP_TARGET_ATI+    , gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB+    , gl_DOUBLE_MAT3_EXT+    , gl_QUERY_BY_REGION_NO_WAIT_INVERTED+    , gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB+    , gl_QUADS+    , gl_ALPHA_INTEGER_EXT+    , gl_VERTEX_SHADER_BIT_EXT+    , gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX+    , gl_COLOR_MATERIAL_FACE+    , gl_LIGHT_MODEL_TWO_SIDE+    , gl_INTERLEAVED_ATTRIBS+    , gl_RGBA16I+    , gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB+    , gl_DEBUG_SEVERITY_LOW_AMD+    , gl_POINT_SPRITE_COORD_ORIGIN+    , gl_DRAW_BUFFER8+    , gl_SPOT_DIRECTION+    , gl_SAMPLE_COVERAGE_INVERT_ARB+    , gl_PERFQUERY_COUNTER_RAW_INTEL+    , gl_STRICT_SCISSOR_HINT_PGI+    , gl_LUMINANCE16_EXT+    , gl_UNPACK_ALIGNMENT+    , gl_BIAS_BIT_ATI+    , gl_LARGE_CCW_ARC_TO_NV+    , gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB+    , gl_FASTEST+    , gl_LUMINANCE8_ALPHA8+    , gl_CONVOLUTION_FILTER_BIAS_EXT+    , gl_VIEW_CLASS_S3TC_DXT5_RGBA+    , gl_DEPTH32F_STENCIL8_NV+    , gl_TRACE_OPERATIONS_BIT_MESA+    , gl_QUERY_RESULT_EXT+    , gl_TRANSFORM_FEEDBACK_BINDING_NV+    , gl_REG_10_ATI+    , gl_MATRIX16_ARB+    , gl_FONT_HAS_KERNING_BIT_NV+    , gl_INNOCENT_CONTEXT_RESET_EXT+    , gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV+    , gl_NATIVE_GRAPHICS_END_HINT_PGI+    , gl_HISTOGRAM_LUMINANCE_SIZE_EXT+    , gl_COMBINER0_NV+    , gl_COORD_REPLACE_OES+    , gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT+    , gl_TIMESTAMP_EXT+    , gl_MAX_IMAGE_UNITS_EXT+    , gl_POINT_SIZE_MAX_ARB+    , gl_DEPTH_WRITEMASK+    , gl_FOG_COORDINATE_ARRAY_STRIDE_EXT+    , gl_BUMP_NUM_TEX_UNITS_ATI+    , gl_INT_SAMPLER_1D_EXT+    , gl_INDEX_MODE+    , gl_422_EXT+    , gl_ATOMIC_COUNTER_BUFFER_START+    , gl_GPU_ADDRESS_NV+    , gl_REG_19_ATI+    , gl_IMAGE_BUFFER+    , gl_HISTOGRAM_GREEN_SIZE+    , gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV+    , gl_INTENSITY8_SNORM+    , gl_DEBUG_TYPE_MARKER+    , gl_VERTEX_PROGRAM_TWO_SIDE_ARB+    , gl_INDEX_MATERIAL_FACE_EXT+    , gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB+    , gl_CMYKA_EXT+    , gl_MAP_ATTRIB_V_ORDER_NV+    , gl_OFFSET_HILO_TEXTURE_2D_NV+    , gl_CALLIGRAPHIC_FRAGMENT_SGIX+    , gl_MAX_PROGRAM_PARAMETERS_ARB+    , gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV+    , gl_MAP_READ_BIT+    , gl_IMAGE_1D_EXT+    , gl_READ_BUFFER+    , gl_POST_CONVOLUTION_RED_SCALE+    , gl_MATRIX23_ARB+    , gl_MAX_SAMPLES_NV+    , gl_RGB8_SNORM+    , gl_MATRIX5_NV+    , gl_UNPACK_SWAP_BYTES+    , gl_TABLE_TOO_LARGE+    , gl_MIN_SAMPLE_SHADING_VALUE_OES+    , gl_SWIZZLE_STQ_DQ_ATI+    , gl_BUFFER_IMMUTABLE_STORAGE+    , gl_ELEMENT_ARRAY_TYPE_APPLE+    , gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI+    , gl_PARTIAL_SUCCESS_NV+    , gl_LOCAL_CONSTANT_EXT+    , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB+    , gl_GEOMETRY_DEFORMATION_SGIX+    , gl_SAMPLER_CUBE_MAP_ARRAY_EXT+    , gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI+    , gl_DISJOINT_NV+    , gl_FLOAT_MAT4x3+    , gl_TRANSFORM_FEEDBACK_PAUSED+    , gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION+    , gl_RG8_EXT+    , gl_RECT_NV+    , gl_GEOMETRY_OUTPUT_TYPE_ARB+    , gl_DEBUG_SOURCE_API_ARB+    , gl_COLOR_ATTACHMENT15+    , gl_MAX_VARYING_FLOATS_ARB+    , gl_MAX_DRAW_BUFFERS_NV+    , gl_VERTEX_BLEND_ARB+    , gl_DOUBLE_MAT2x3_EXT+    , gl_MAX_DEBUG_LOGGED_MESSAGES_AMD+    , gl_VERTICES_SUBMITTED_ARB+    , gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG+    , gl_STATE_RESTORE+    , gl_MAX_COLOR_ATTACHMENTS_EXT+    , gl_INDEX_LOGIC_OP+    , gl_PRIMITIVE_RESTART_NV+    , gl_FLOAT_MAT3x2_NV+    , gl_VERTEX_CONSISTENT_HINT_PGI+    , gl_LUMINANCE_ALPHA16F_EXT+    , gl_FLOAT_VEC2_ARB+    , gl_TEXTURE_SWIZZLE_RGBA+    , gl_PROGRAM_SEPARABLE_EXT+    , gl_COMPRESSED_RGBA_ASTC_10x8_KHR+    , gl_DEPTH_ATTACHMENT_EXT+    , gl_FRAMEBUFFER_UNSUPPORTED_OES+    , gl_OPERAND1_ALPHA+    , gl_PIXEL_MAP_I_TO_B_SIZE+    , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT+    , gl_EVAL_2D_NV+    , gl_GREEN_MIN_CLAMP_INGR+    , gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS+    , gl_VERTEX_ARRAY_RANGE_NV+    , gl_CONTEXT_LOST_WEBGL+    , gl_MAX_VERTEX_UNIFORM_BLOCKS+    , gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE+    , gl_TEXTURE_MAX_CLAMP_T_SGIX+    , gl_LUMINANCE_SNORM+    , gl_PIXEL_UNPACK_BUFFER_BINDING+    , gl_RGBA8_SNORM+    , gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX+    , gl_PIXEL_SUBSAMPLE_2424_SGIX+    , gl_TEXTURE_GATHER_SHADOW+    , gl_VIEWPORT_INDEX_PROVOKING_VERTEX+    , gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT+    , gl_UNSIGNED_INT_IMAGE_CUBE+    , gl_WEIGHT_ARRAY_POINTER_OES+    , gl_ALL_ATTRIB_BITS+    , gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL+    , gl_TESS_EVALUATION_SHADER_EXT+    , gl_BUFFER_OBJECT_EXT+    , gl_TIMESTAMP+    , gl_RGBA_INTEGER_EXT+    , gl_RGB16UI+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT+    , gl_SAMPLE_SHADING_OES+    , gl_CONVOLUTION_BORDER_COLOR+    , gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV+    , gl_VERTEX_ARRAY_BUFFER_BINDING+    , gl_DEPTH_CLAMP_NEAR_AMD+    , gl_POLYGON_TOKEN+    , gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB+    , gl_R8_SNORM+    , gl_DS_BIAS_NV+    , gl_2X_BIT_ATI+    , gl_ALREADY_SIGNALED+    , gl_2D+    , gl_MAX_VERTEX_UNIFORM_COMPONENTS+    , gl_DEBUG_CATEGORY_PERFORMANCE_AMD+    , gl_OVERLAY_NV+    , gl_ATOMIC_COUNTER_BUFFER_SIZE+    , gl_COLOR_ATTACHMENT10_EXT+    , gl_COLOR_TABLE_BLUE_SIZE_SGI+    , gl_ADD_SIGNED_EXT+    , gl_INT_SAMPLER_2D_ARRAY_EXT+    , gl_TRANSFORM_FEEDBACK_BUFFER_INDEX+    , gl_REFERENCED_BY_TESS_CONTROL_SHADER+    , gl_FIELD_LOWER_NV+    , gl_POST_COLOR_MATRIX_RED_SCALE+    , gl_IMAGE_BUFFER_EXT+    , gl_3D_COLOR_TEXTURE+    , gl_DEBUG_CALLBACK_FUNCTION_KHR+    , gl_SCISSOR_BIT+    , gl_IMAGE_TRANSLATE_X_HP+    , gl_PIXEL_MAP_I_TO_A+    , gl_VERTEX_SUBROUTINE+    , gl_TEXTURE4_ARB+    , gl_PACK_COMPRESSED_BLOCK_DEPTH+    , gl_SHADER_STORAGE_BLOCK+    , gl_SIGNED_ALPHA_NV+    , gl_BLEND_DST_ALPHA_EXT+    , gl_MAP2_VERTEX_ATTRIB9_4_NV+    , gl_HILO8_NV+    , gl_SHADER_BINARY_FORMATS+    , gl_DEBUG_OUTPUT_SYNCHRONOUS+    , gl_TEXTURE_GEN_R+    , gl_PERFORMANCE_MONITOR_AMD+    , gl_INTENSITY_FLOAT16_APPLE+    , gl_PROGRAM_PIPELINE+    , gl_COLOR_BUFFER_BIT5_QCOM+    , gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT+    , gl_DEBUG_TYPE_PORTABILITY_KHR+    , gl_RGB16F_ARB+    , gl_PRIMITIVES_GENERATED_EXT+    , gl_PROGRAM_BINARY_FORMATS_OES+    , gl_AMBIENT+    , gl_QUERY_BY_REGION_NO_WAIT_NV+    , gl_VIEW_CLASS_RGTC2_RG+    , gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT+    , gl_DRAW_BUFFER2_EXT+    , gl_TEXTURE_BUFFER_BINDING+    , gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT+    , gl_OPERAND3_ALPHA_NV+    , gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV+    , gl_LINEAR_SHARPEN_SGIS+    , gl_MAP_UNSYNCHRONIZED_BIT_EXT+    , gl_MODELVIEW28_ARB+    , gl_EDGE_FLAG_ARRAY_LIST_IBM+    , gl_PALETTE4_RGB5_A1_OES+    , gl_MULTIPLY_KHR+    , gl_GPU_OPTIMIZED_QCOM+    , gl_FOG_FUNC_POINTS_SGIS+    , gl_MAX_IMAGE_SAMPLES+    , gl_DRAW_BUFFER3_NV+    , gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS+    , gl_RESET_NOTIFICATION_STRATEGY_ARB+    , gl_MAX_TEXTURE_STACK_DEPTH+    , gl_INT64_NV+    , gl_DEBUG_SOURCE_APPLICATION+    , gl_STENCIL_CLEAR_VALUE+    , gl_SRC1_COLOR+    , gl_LIGHT4+    , gl_PIXEL_PACK_BUFFER_BINDING+    , gl_MAX_LIGHTS+    , gl_OPERAND1_ALPHA_EXT+    , gl_PIXEL_MAP_B_TO_B_SIZE+    , gl_COLOR_TABLE_FORMAT_SGI+    , gl_MODELVIEW22_ARB+    , gl_UNSIGNED_INT64_VEC4_NV+    , gl_COLOR_ARRAY_TYPE_EXT+    , gl_LOSE_CONTEXT_ON_RESET_EXT+    , gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV+    , gl_TEXTURE_PRIORITY_EXT+    , gl_UNPACK_COMPRESSED_SIZE_SGIX+    , gl_SEPARATE_ATTRIBS_EXT+    , gl_IMAGE_BINDING_LAYERED+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR+    , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE+    , gl_READ_ONLY+    , gl_TEXTURE_3D_BINDING_OES+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER+    , gl_COVERAGE_ALL_FRAGMENTS_NV+    , gl_SRC2_ALPHA+    , gl_PRIMITIVE_ID_NV+    , gl_VIDEO_COLOR_CONVERSION_MAX_NV+    , gl_MAP2_TANGENT_EXT+    , gl_LIGHTING+    , gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB+    , gl_VERTEX_ATTRIB_ARRAY2_NV+    , gl_PRESENT_TIME_NV+    , gl_PATCH_DEFAULT_INNER_LEVEL+    , gl_NEVER+    , gl_PATH_STROKE_WIDTH_NV+    , gl_INVERT_RGB_NV+    , gl_BUFFER_MAP_POINTER_ARB+    , gl_MAP2_GRID_SEGMENTS+    , gl_INVALID_VALUE+    , gl_BLEND_EQUATION_ALPHA_OES+    , gl_MAX_RATIONAL_EVAL_ORDER_NV+    , gl_VERTEX_ATTRIB_ARRAY10_NV+    , gl_UNPACK_IMAGE_DEPTH_SGIS+    , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES+    , gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS+    , gl_TRANSPOSE_PROJECTION_MATRIX_ARB+    , gl_REDUCE_EXT+    , gl_RGB8UI_EXT+    , gl_MAX_CLIENT_ATTRIB_STACK_DEPTH+    , gl_RGB9_E5_EXT+    , gl_OUTPUT_TEXTURE_COORD18_EXT+    , gl_COLOR_ATTACHMENT0_EXT+    , gl_ALPHA_SCALE+    , gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV+    , gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE+    , gl_BLEND_SRC+    , gl_TEXTURE_MAX_CLAMP_R_SGIX+    , gl_MAX_PROGRAM_TEXEL_OFFSET_NV+    , gl_TEXTURE_LOD_BIAS_R_SGIX+    , gl_UNSIGNED_INT_SAMPLER_2D+    , gl_TEXTURE_FILTER_CONTROL_EXT+    , gl_VARIABLE_G_NV+    , gl_SELECTION_BUFFER_POINTER+    , gl_INT_SAMPLER_1D+    , gl_COMBINE_ALPHA+    , gl_FONT_Y_MAX_BOUNDS_BIT_NV+    , gl_UNIFORM_BARRIER_BIT+    , gl_TEXTURE_BLUE_TYPE_ARB+    , gl_STENCIL_INDEX16+    , gl_SRC_OVER_NV+    , gl_INT_SAMPLER_2D_MULTISAMPLE+    , gl_COLOR_TABLE_GREEN_SIZE_SGI+    , gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV+    , gl_TEXTURE_COMPRESSED_IMAGE_SIZE+    , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV+    , gl_REFERENCED_BY_TESS_EVALUATION_SHADER+    , gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT+    , gl_MAX_HEIGHT+    , gl_ALPHA32F_ARB+    , gl_COLOR_ATTACHMENT13+    , gl_OP_SET_GE_EXT+    , gl_RGBA16_EXT+    , gl_OPERAND3_RGB_NV+    , gl_RENDERBUFFER_BLUE_SIZE_OES+    , gl_LUMINANCE_ALPHA_FLOAT16_ATI+    , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV+    , gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL+    , gl_MAX_DEPTH+    , gl_LINEAR_MIPMAP_NEAREST+    , gl_UNSIGNED_INT_8_8_S8_S8_REV_NV+    , gl_N3F_V3F+    , gl_PACK_MAX_COMPRESSED_SIZE_SGIX+    , gl_QUERY_BUFFER_BINDING_AMD+    , gl_FOG_MODE+    , gl_RGBA32F+    , gl_FRAGMENT_SHADER_DERIVATIVE_HINT+    , gl_UNPACK_SKIP_ROWS_EXT+    , gl_LINES+    , gl_SPOT_EXPONENT+    , gl_MAX_NUM_COMPATIBLE_SUBROUTINES+    , gl_RGBA_FLOAT32_APPLE+    , gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT+    , gl_BLEND_EQUATION_ALPHA+    , gl_PATH_MODELVIEW_STACK_DEPTH_NV+    , gl_TEXTURE_SHARED_SIZE_EXT+    , gl_RGBA16+    , gl_UNDEFINED_VERTEX_EXT+    , gl_PALETTE8_RGB5_A1_OES+    , gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT+    , gl_IMAGE_CLASS_11_11_10+    , gl_HISTOGRAM_GREEN_SIZE_EXT+    , gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT+    , gl_MAX_COMPUTE_IMAGE_UNIFORMS+    , gl_MAX_PATCH_VERTICES_EXT+    , gl_ISOLINES+    , gl_LUMINANCE_ALPHA_SNORM+    , gl_PROGRAM_PIPELINE_BINDING_EXT+    , gl_FIRST_VERTEX_CONVENTION_EXT+    , gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT+    , gl_UTF16_NV+    , gl_PRESENT_DURATION_NV+    , gl_TEXTURE_SAMPLES+    , gl_BGR+    , gl_CULL_VERTEX_OBJECT_POSITION_EXT+    , gl_FRAGMENT_PROGRAM_POSITION_MESA+    , gl_FLOAT_RG_NV+    , gl_PROXY_TEXTURE_2D_MULTISAMPLE+    , gl_CON_21_ATI+    , gl_MAX_GEOMETRY_IMAGE_UNIFORMS+    , gl_FLOAT_MAT3x4_NV+    , gl_BUFFER_VARIABLE+    , gl_ANY_SAMPLES_PASSED_EXT+    , gl_TEXTURE_GEN_Q+    , gl_GEOMETRY_VERTICES_OUT_ARB+    , gl_POLYGON_SMOOTH_HINT+    , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY+    , gl_SEPARABLE_2D_EXT+    , gl_VERSION_ES_CL_1_0+    , gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV+    , gl_RED_INTEGER+    , gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD+    , gl_OFFSET_TEXTURE_RECTANGLE_NV+    , gl_TEXTURE_COORD_ARRAY_TYPE_EXT+    , gl_INT8_NV+    , gl_VIDEO_COLOR_CONVERSION_MIN_NV+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV+    , gl_FRAMEBUFFER_ATTACHMENT_ANGLE+    , gl_SRC1_RGB+    , gl_CON_24_ATI+    , gl_DEBUG_CALLBACK_USER_PARAM+    , gl_MALI_SHADER_BINARY_ARM+    , gl_VIEW_CLASS_16_BITS+    , gl_DITHER+    , gl_PATH_STROKE_COVER_MODE_NV+    , gl_BGR_INTEGER+    , gl_TEXTURE_MATERIAL_PARAMETER_EXT+    , gl_COMPRESSED_RGBA_ASTC_5x4_KHR+    , gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT+    , gl_POST_CONVOLUTION_GREEN_BIAS_EXT+    , gl_PATH_ERROR_POSITION_NV+    , gl_SAMPLE_ALPHA_TO_COVERAGE+    , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY+    , gl_NUM_COMPATIBLE_SUBROUTINES+    , gl_RGBA16UI_EXT+    , gl_VERTEX_SHADER_ARB+    , gl_RGB+    , gl_MAP_PERSISTENT_BIT+    , gl_QUERY_COUNTER_BITS_ARB+    , gl_BLEND_EQUATION_RGB_OES+    , gl_FRAGMENT_SHADER_BIT+    , gl_MATRIX_INDEX_ARRAY_ARB+    , gl_OUTPUT_TEXTURE_COORD29_EXT+    , gl_HISTOGRAM_FORMAT+    , gl_MAX_ASYNC_HISTOGRAM_SGIX+    , gl_MAX_VERTEX_ATTRIBS_ARB+    , gl_SAMPLE_MASK_NV+    , gl_COLOR_INDEXES+    , gl_QUAD_TEXTURE_SELECT_SGIS+    , gl_RG16_SNORM+    , gl_ACTIVE_SUBROUTINE_MAX_LENGTH+    , gl_LOGIC_OP_MODE+    , gl_DEPTH_COMPONENT16_NONLINEAR_NV+    , gl_PRIMITIVE_RESTART_INDEX_NV+    , gl_UNKNOWN_CONTEXT_RESET+    , gl_VBO_FREE_MEMORY_ATI+    , gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES+    , gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR+    , gl_TEXTURE_2D_STACK_MESAX+    , gl_DRAW_BUFFER10+    , gl_FLOAT16_VEC4_NV+    , gl_SIGNED_HILO16_NV+    , gl_BUFFER_MAPPED_OES+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT+    , gl_DRAW_BUFFER5_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB+    , gl_NUM_EXTENSIONS+    , gl_WARP_SIZE_NV+    , gl_TEXTURE23+    , gl_INT_SAMPLER_2D_RECT_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES+    , gl_REG_4_ATI+    , gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG+    , gl_FOG_INDEX+    , gl_QUADRATIC_ATTENUATION+    , gl_COLOR_MATERIAL+    , gl_SAMPLE_MASK+    , gl_DRAW_FRAMEBUFFER_BINDING_EXT+    , gl_MULTISAMPLE_BUFFER_BIT5_QCOM+    , gl_DEPTH_STENCIL_OES+    , gl_STENCIL_BITS+    , gl_CURRENT_VERTEX_ATTRIB_ARB+    , gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB+    , gl_COORD_REPLACE_ARB+    , gl_RGBA32I_EXT+    , gl_TEXTURE6+    , gl_FLOAT_RGB16_NV+    , gl_TEXTURE_IMMUTABLE_FORMAT+    , gl_ZERO_EXT+    , gl_SOFTLIGHT_NV+    , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT+    , gl_TEXTURE_BASE_LEVEL+    , gl_COMPRESSED_SRGB_ALPHA+    , gl_TEXTURE18_ARB+    , gl_AND_INVERTED+    , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT+    , gl_ARRAY_BUFFER_ARB+    , gl_RGBA32F_EXT+    , gl_BLEND_EQUATION_RGB_EXT+    , gl_FRONT_FACE+    , gl_SINGLE_COLOR_EXT+    , gl_QUERY_COUNTER_BITS_EXT+    , gl_TESS_CONTROL_SHADER_PATCHES_ARB+    , gl_SPOT_CUTOFF+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB+    , gl_OUTPUT_TEXTURE_COORD6_EXT+    , gl_COLOR_ATTACHMENT13_NV+    , gl_COMPRESSED_RGBA_S3TC_DXT3_EXT+    , gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV+    , gl_TRANSPOSE_TEXTURE_MATRIX+    , gl_MULTISAMPLE_ARB+    , gl_DEPTH_COMPONENT24+    , gl_PIXEL_MAP_G_TO_G+    , gl_NAMED_STRING_LENGTH_ARB+    , gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT+    , gl_UNIFORM_SIZE+    , gl_MODELVIEW21_ARB+    , gl_FRAGMENT_LIGHT7_SGIX+    , gl_DRAW_BUFFER3_ARB+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES+    , gl_UNSIGNED_SHORT+    , gl_MULTISAMPLE_BIT_ARB+    , gl_FOG+    , gl_TEXTURE_COMPARE_MODE+    , gl_SPHERE_MAP+    , gl_TIMEOUT_EXPIRED_APPLE+    , gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT+    , gl_PROXY_TEXTURE_1D_ARRAY+    , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT+    , gl_TEXTURE_BINDING_CUBE_MAP+    , gl_COLOR_ATTACHMENT14+    , gl_STENCIL_BUFFER_BIT+    , gl_SIGNALED+    , gl_TEXTURE_WIDTH+    , gl_EVAL_BIT+    , gl_REG_28_ATI+    , gl_TEXTURE_BIT+    , gl_CONTEXT_ROBUST_ACCESS_EXT+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV+    , gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB+    , gl_DEPTH_BUFFER_BIT+    , gl_TEXCOORD2_BIT_PGI+    , gl_POST_CONVOLUTION_RED_SCALE_EXT+    , gl_QUERY_KHR+    , gl_PACK_IMAGE_HEIGHT_EXT+    , gl_COMPRESSED_RGBA_ASTC_5x5_KHR+    , gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB+    , gl_DEPTH_STENCIL_ATTACHMENT+    , gl_HSL_HUE_KHR+    , gl_ATC_RGB_AMD+    , gl_DECR_WRAP+    , gl_GEOMETRY_VERTICES_OUT+    , gl_OFFSET_TEXTURE_BIAS_NV+    , gl_COLOR_ATTACHMENT5_NV+    , gl_POINT_SIZE_ARRAY_POINTER_OES+    , gl_TEXTURE_COMPARE_FAIL_VALUE_ARB+    , gl_RENDERBUFFER_COLOR_SAMPLES_NV+    , gl_CON_10_ATI+    , gl_IMAGE_ROTATE_ANGLE_HP+    , gl_UNIFORM_BUFFER_UNIFIED_NV+    , gl_INTENSITY4+    , gl_DEBUG_LOGGED_MESSAGES_KHR+    , gl_MINUS_CLAMPED_NV+    , gl_BUFFER_SIZE+    , gl_SRGB_EXT+    , gl_PIXEL_TEX_GEN_Q_ROUND_SGIX+    , gl_R16I+    , gl_COLOR_COMPONENTS+    , gl_TEXTURE_VIEW_NUM_LEVELS+    , gl_COLOR_ATTACHMENT11+    , gl_OBJECT_PLANE+    , gl_IMAGE_3D_EXT+    , gl_MAX_GEOMETRY_INPUT_COMPONENTS+    , gl_TEXTURE_COORD_ARRAY_LIST_IBM+    , gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS+    , gl_CLIENT_ACTIVE_TEXTURE+    , gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB+    , gl_OPERAND1_RGB+    , gl_POINT_SIZE_ARRAY_OES+    , gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV+    , gl_MODELVIEW6_ARB+    , gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR+    , gl_AND_REVERSE+    , gl_CLAMP_TO_BORDER_NV+    , gl_GUILTY_CONTEXT_RESET_ARB+    , gl_INT64_VEC2_NV+    , gl_C3F_V3F+    , gl_OBJECT_LINEAR_NV+    , gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT+    , gl_TEXTURE_FLOAT_COMPONENTS_NV+    , gl_SOURCE3_ALPHA_NV+    , gl_OPERAND2_ALPHA_EXT+    , gl_CON_12_ATI+    , gl_SYNC_STATUS+    , gl_BLEND_SRC_RGB_EXT+    , gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB+    , gl_TEXTURE_2D_MULTISAMPLE_ARRAY+    , gl_LEFT+    , gl_UNSIGNED_INT_SAMPLER_1D+    , gl_PIXEL_MAP_I_TO_R_SIZE+    , gl_VERTEX_ARRAY_BINDING_OES+    , gl_COMBINE_ALPHA_EXT+    , gl_TRANSFORM_FEEDBACK_ATTRIBS_NV+    , gl_CURRENT_WEIGHT_ARB+    , gl_RASTERIZER_DISCARD_NV+    , gl_SRC_IN_NV+    , gl_OBJECT_DISTANCE_TO_POINT_SGIS+    , gl_COMPRESSED_RGB8_ETC2+    , gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS+    , gl_RGB_SNORM+    , gl_INTENSITY4_EXT+    , gl_R8I+    , gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS+    , gl_EDGEFLAG_BIT_PGI+    , gl_MAX_FRAMEBUFFER_SAMPLES+    , gl_SECONDARY_COLOR_ARRAY_TYPE+    , gl_ALL_BARRIER_BITS_EXT+    , gl_TEXTURE14+    , gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER+    , gl_SRC0_ALPHA+    , gl_MODELVIEW16_ARB+    , gl_DARKEN_NV+    , gl_INTENSITY_EXT+    , gl_CURRENT_BIT+    , gl_FLOAT_RGBA32_NV+    , gl_SHADOW_ATTENUATION_EXT+    , gl_COMPRESSED_SRGB8_ETC2+    , gl_DRAW_BUFFER15+    , gl_COMPARE_R_TO_TEXTURE_ARB+    , gl_R11F_G11F_B10F_EXT+    , gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG+    , gl_MULTISAMPLE_BUFFER_BIT6_QCOM+    , gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT+    , gl_FEEDBACK_BUFFER_TYPE+    , gl_IMAGE_BINDING_FORMAT_EXT+    , gl_PROXY_TEXTURE_2D_EXT+    , gl_DEPTH32F_STENCIL8+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS+    , gl_TESS_EVALUATION_SUBROUTINE+    , gl_TEXTURE_LOD_BIAS_T_SGIX+    , gl_COVERAGE_COMPONENT4_NV+    , gl_TEXTURE6_ARB+    , gl_MAX_3D_TEXTURE_SIZE_EXT+    , gl_TEXTURE_RESIDENT+    , gl_FOG_COORD_ARRAY_TYPE+    , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR+    , gl_QUERY_BY_REGION_WAIT+    , gl_SLUMINANCE_ALPHA+    , gl_INT_SAMPLER_CUBE+    , gl_UNSIGNED_SHORT_4_4_4_4_REV+    , gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB+    , gl_LUMINANCE4_ALPHA4_EXT+    , gl_OPERAND0_RGB_ARB+    , gl_PROXY_TEXTURE_2D_STACK_MESAX+    , gl_TEXTURE_3D_EXT+    , gl_STREAM_RASTERIZATION_AMD+    , gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT+    , gl_DEPTH_COMPONENT32_SGIX+    , gl_LINE_STRIP+    , gl_CON_25_ATI+    , gl_SLIM10U_SGIX+    , gl_COLOR_INDEX2_EXT+    , gl_CON_22_ATI+    , gl_DEFORMATIONS_MASK_SGIX+    , gl_INVERSE_TRANSPOSE_NV+    , gl_MULT+    , gl_ATTRIB_ARRAY_STRIDE_NV+    , gl_RGBA16_SNORM+    , gl_MIN_SAMPLE_SHADING_VALUE+    , gl_RG8_SNORM+    , gl_OBJECT_ATTACHED_OBJECTS_ARB+    , gl_UNPACK_SKIP_PIXELS_EXT+    , gl_ACTIVE_VERTEX_UNITS_ARB+    , gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT+    , gl_INTERNALFORMAT_RED_TYPE+    , gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV+    , gl_FLOAT_RGB_NV+    , gl_MAP_FLUSH_EXPLICIT_BIT_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS+    , gl_HALF_FLOAT_NV+    , gl_DEPTH_STENCIL+    , gl_PROGRAM_ERROR_POSITION_ARB+    , gl_TRACE_ERRORS_BIT_MESA+    , gl_STENCIL_OP_VALUE_AMD+    , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES+    , gl_COMPRESSED_SIGNED_R11_EAC+    , gl_FLOAT_MAT3x2+    , gl_PROGRAM_ERROR_STRING_NV+    , gl_VERTEX_ID_NV+    , gl_VERTEX_BINDING_OFFSET+    , gl_RESTART_SUN+    , gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT+    , gl_COLOR_INDEX+    , gl_TEXTURE31_ARB+    , gl_MAX_DRAW_BUFFERS_ARB+    , gl_MAX_IMAGE_UNITS+    , gl_OUTPUT_TEXTURE_COORD4_EXT+    , gl_COLOR_ARRAY_POINTER+    , gl_MAX_COLOR_TEXTURE_SAMPLES+    , gl_SIGNED_NEGATE_NV+    , gl_MAX_GEOMETRY_UNIFORM_BLOCKS+    , gl_DEBUG_TYPE_ERROR+    , gl_HISTOGRAM_RED_SIZE_EXT+    , gl_SECONDARY_COLOR_ARRAY_POINTER_EXT+    , gl_UNSIGNALED+    , gl_CON_8_ATI+    , gl_COMPRESSED_RED+    , gl_RGBA2_EXT+    , gl_T2F_C3F_V3F+    , gl_SECONDARY_COLOR_ARRAY+    , gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT+    , gl_COLOR3_BIT_PGI+    , gl_CLIP_DISTANCE3+    , gl_TEXTURE_SWIZZLE_G_EXT+    , gl_SAMPLER_CUBE_MAP_ARRAY+    , gl_4PASS_3_SGIS+    , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT+    , gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT+    , gl_VERTEX_ARRAY_STRIDE+    , gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS+    , gl_TEXTURE_SWIZZLE_A+    , gl_DOUBLE_MAT3x2+    , gl_TEXTURE_UPDATE_BARRIER_BIT_EXT+    , gl_SHADING_LANGUAGE_VERSION+    , gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP+    , gl_FIXED_ONLY_ARB+    , gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI+    , gl_CON_19_ATI+    , gl_CONTEXT_RELEASE_BEHAVIOR+    , gl_ARRAY_BUFFER_BINDING+    , gl_UNPACK_COLORSPACE_CONVERSION_WEBGL+    , gl_CONVEX_HULL_NV+    , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB+    , gl_FIRST_TO_REST_NV+    , gl_MAX_TEXTURE_COORDS+    , gl_TEXTURE_DEPTH+    , gl_LIGHT0+    , gl_VERTEX_STREAM4_ATI+    , gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI+    , gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS+    , gl_SAMPLER_2D_RECT_SHADOW_ARB+    , gl_DRAW_BUFFER1_ATI+    , gl_SAMPLE_BUFFERS_SGIS+    , gl_SIGNED_LUMINANCE_ALPHA_NV+    , gl_R16_SNORM+    , gl_DRAW_BUFFER13_ATI+    , gl_TEXTURE_LIGHT_EXT+    , gl_BOOL_ARB+    , gl_BGRA_IMG+    , gl_SRGB_ALPHA_EXT+    , gl_RELATIVE_ROUNDED_RECT2_NV+    , gl_LUMINANCE16UI_EXT+    , gl_MATRIX7_NV+    , gl_INTENSITY16+    , gl_DRAW_INDIRECT_BUFFER+    , gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM+    , gl_MAX_IMAGE_SAMPLES_EXT+    , gl_DEBUG_SOURCE_OTHER_ARB+    , gl_POINT_BIT+    , gl_MAX_VARYING_VECTORS+    , gl_SUBTRACT_ARB+    , gl_INT_SAMPLER_BUFFER_AMD+    , gl_SAMPLE_MASK_INVERT_SGIS+    , gl_POINT_DISTANCE_ATTENUATION_ARB+    , gl_GREEN_BIT_ATI+    , gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT+    , gl_FRAMEBUFFER+    , gl_TEXTURE_COMPRESSION_HINT_ARB+    , gl_PROGRAM_INPUT+    , gl_SCREEN_NV+    , gl_TEXTURE_CUBE_MAP_ARRAY_EXT+    , gl_FENCE_STATUS_NV+    , gl_MAX_BINDABLE_UNIFORM_SIZE_EXT+    , gl_PACK_COMPRESSED_BLOCK_WIDTH+    , gl_RELATIVE_VERTICAL_LINE_TO_NV+    , gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI+    , gl_ALPHA_INTEGER+    , gl_MAX_SUBROUTINES+    , gl_UNSIGNED_INT_VEC3_EXT+    , gl_ELEMENT_ARRAY_ATI+    , gl_ONE_MINUS_CONSTANT_COLOR+    , gl_MODELVIEW18_ARB+    , gl_CONSTANT_ARB+    , gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV+    , gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL+    , gl_DRAW_BUFFER_EXT+    , gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT+    , gl_FLOAT_MAT2x4_NV+    , gl_CULL_VERTEX_EXT+    , gl_MATRIX_PALETTE_ARB+    , gl_VERTEX_PROGRAM_POINT_SIZE_ARB+    , gl_FLOAT_RG16_NV+    , gl_CON_1_ATI+    , gl_BLEND_EQUATION_RGB+    , gl_OP_CROSS_PRODUCT_EXT+    , gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT+    , gl_TESS_CONTROL_PROGRAM_NV+    , gl_FIXED_ONLY+    , gl_4PASS_1_EXT+    , gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES+    , gl_UNSIGNED_INT_8_8_8_8_REV+    , gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS+    , gl_SLUMINANCE_ALPHA_NV+    , gl_PROXY_TEXTURE_CUBE_MAP+    , gl_IMAGE_CLASS_1_X_32+    , gl_STACK_OVERFLOW_KHR+    , gl_COMPRESSED_RGBA_ASTC_5x5x5_OES+    , gl_CLOSE_PATH_NV+    , gl_PIXEL_COUNT_AVAILABLE_NV+    , gl_PATH_DASH_OFFSET_NV+    , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV+    , gl_GLOBAL_ALPHA_FACTOR_SUN+    , gl_INDEX_ARRAY_COUNT_EXT+    , gl_PACK_RESAMPLE_OML+    , gl_LAYER_NV+    , gl_DRAW_FRAMEBUFFER+    , gl_LINEAR_DETAIL_ALPHA_SGIS+    , gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT+    , gl_EDGE_FLAG_ARRAY+    , gl_TEXTURE_DEFORMATION_BIT_SGIX+    , gl_SOURCE1_RGB+    , gl_TEXTURE_3D_OES+    , gl_ALLOW_DRAW_OBJ_HINT_PGI+    , gl_PATH_STROKE_BOUNDING_BOX_NV+    , gl_HINT_BIT+    , gl_VERTICAL_LINE_TO_NV+    , gl_MAX_TEXTURE_BUFFER_SIZE_EXT+    , gl_MAX_DRAW_BUFFERS_ATI+    , gl_R8_EXT+    , gl_TEXTURE_COVERAGE_SAMPLES_NV+    , gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV+    , gl_REFERENCED_BY_VERTEX_SHADER+    , gl_FLOAT_RG32_NV+    , gl_TESSELLATION_FACTOR_AMD+    , gl_MAX_PROGRAM_TEMPORARIES_ARB+    , gl_COMPRESSED_RGBA_ASTC_12x12_KHR+    , gl_PROJECTION+    , gl_S+    , gl_ALPHA_FLOAT32_APPLE+    , gl_LUMINANCE8_ALPHA8_OES+    , gl_4_BYTES_NV+    , gl_CONST_EYE_NV+    , gl_MAT_SPECULAR_BIT_PGI+    , gl_TEXTURE1_ARB+    , gl_LINE_WIDTH_GRANULARITY+    , gl_DRAW_INDIRECT_BUFFER_BINDING+    , gl_BLEND_EQUATION+    , gl_RGBA8UI_EXT+    , gl_NORMALIZE+    , gl_LUMINANCE_ALPHA_FLOAT16_APPLE+    , gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX+    , gl_INVERSE_NV+    , gl_TEXTURE_SWIZZLE_A_EXT+    , gl_DEPTH24_STENCIL8_OES+    , gl_UNPACK_COMPRESSED_BLOCK_HEIGHT+    , gl_RGBA32UI+    , gl_MAP1_COLOR_4+    , gl_MAX_ELEMENTS_VERTICES+    , gl_CLIENT_VERTEX_ARRAY_BIT+    , gl_TEXTURE_GREEN_TYPE+    , gl_TEXTURE_BINDING_BUFFER_ARB+    , gl_MAX_RECTANGLE_TEXTURE_SIZE_NV+    , gl_INTERNALFORMAT_GREEN_TYPE+    , gl_OP_ADD_EXT+    , gl_UNSIGNED_INT_24_8+    , gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS+    , gl_3D_COLOR+    , gl_MODULATE_COLOR_IMG+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB+    , gl_TEXTURE_CLIPMAP_FRAME_SGIX+    , gl_NORMAL_ARRAY_STRIDE_EXT+    , gl_R16+    , gl_PIXEL_PACK_BUFFER+    , gl_SOFTLIGHT_KHR+    , gl_POST_CONVOLUTION_BLUE_SCALE+    , gl_INTERLEAVED_ATTRIBS_NV+    , gl_COLOR_ATTACHMENT8+    , gl_DEBUG_TYPE_PUSH_GROUP_KHR+    , gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL+    , gl_MOV_ATI+    , gl_PROGRAM_SEPARABLE+    , gl_REG_20_ATI+    , gl_DOUBLE_VEC3+    , gl_8X_BIT_ATI+    , gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY+    , gl_MATRIX26_ARB+    , gl_PROXY_TEXTURE_RECTANGLE_ARB+    , gl_TRANSFORM_HINT_APPLE+    , gl_UNPACK_ROW_BYTES_APPLE+    , gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI+    , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB+    , gl_ONE_MINUS_CONSTANT_COLOR_EXT+    , gl_TEXTURE_BINDING_CUBE_MAP_OES+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT+    , gl_VERTEX_ARRAY_STORAGE_HINT_APPLE+    , gl_VERTEX_BINDING_BUFFER+    , gl_FRAGMENT_LIGHT0_SGIX+    , gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV+    , gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT+    , gl_SRC2_RGB+    , gl_NUM_COMPRESSED_TEXTURE_FORMATS+    , gl_OUTPUT_TEXTURE_COORD2_EXT+    , gl_DEPTH_TEXTURE_MODE+    , gl_SAMPLE_PATTERN_EXT+    , gl_ELEMENT_ARRAY_APPLE+    , gl_MAX_FOG_FUNC_POINTS_SGIS+    , gl_TEXTURE_APPLICATION_MODE_EXT+    , gl_COLOR_ARRAY_SIZE_EXT+    , gl_VERTEX_SOURCE_ATI+    , gl_MAP2_VERTEX_ATTRIB3_4_NV+    , gl_LIGHTEN_KHR+    , gl_INT_SAMPLER_1D_ARRAY+    , gl_UNSIGNED_INT_10F_11F_11F_REV_EXT+    , gl_LUMINANCE8+    , gl_ACCUM_ALPHA_BITS+    , gl_MINMAX_FORMAT+    , gl_NOOP+    , gl_READ_FRAMEBUFFER_EXT+    , gl_SHADER+    , gl_UNSIGNED_INT_10_10_10_2_OES+    , gl_TEXTURE_COMPRESSED_BLOCK_WIDTH+    , gl_DEBUG_OUTPUT_KHR+    , gl_SOURCE0_ALPHA_ARB+    , gl_SAMPLER_1D_ARRAY_EXT+    , gl_T2F_V3F+    , gl_SAMPLE_MASK_SGIS+    , gl_CIRCULAR_TANGENT_ARC_TO_NV+    , gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS+    , gl_MAX_DEBUG_LOGGED_MESSAGES+    , gl_SOURCE1_ALPHA+    , gl_RGB_422_APPLE+    , gl_COLOR_TABLE+    , gl_MAP1_TEXTURE_COORD_3+    , gl_DEBUG_SEVERITY_HIGH_AMD+    , gl_UNSIGNED_INT+    , gl_VERTEX_PROGRAM_CALLBACK_MESA+    , gl_BLOCK_INDEX+    , gl_FLOAT+    , gl_TRACE_PIXELS_BIT_MESA+    , gl_BACK+    , gl_PATH_JOIN_STYLE_NV+    , gl_LUMINANCE_ALPHA16I_EXT+    , gl_FLOAT_MAT2+    , gl_SIGNED_IDENTITY_NV+    , gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA+    , gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX+    , gl_CLIP_DEPTH_MODE+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT+    , gl_CULL_FACE+    , gl_DETAIL_TEXTURE_LEVEL_SGIS+    , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB+    , gl_PACK_SKIP_ROWS+    , gl_COEFF+    , gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT+    , gl_NUM_INSTRUCTIONS_PER_PASS_ATI+    , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB+    , gl_RGBA8+    , gl_TESS_GEN_VERTEX_ORDER+    , gl_TEXTURE_CUBE_MAP+    , gl_VERTEX_PRECLIP_HINT_SGIX+    , gl_NUM_SHADING_LANGUAGE_VERSIONS+    , gl_OUTPUT_TEXTURE_COORD9_EXT+    , gl_MAX_PROGRAM_GENERIC_RESULTS_NV+    , gl_COLOR_ATTACHMENT7_NV+    , gl_OUT_OF_MEMORY+    , gl_TEXTURE_COORD_ARRAY_POINTER_EXT+    , gl_FLOAT_MAT2_ARB+    , gl_COMBINER_AB_DOT_PRODUCT_NV+    , gl_INDEX_ARRAY_POINTER_EXT+    , gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV+    , gl_3D+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES+    , gl_UPPER_LEFT+    , gl_IMAGE_1D_ARRAY_EXT+    , gl_GREEN+    , gl_RGB12+    , gl_GEOMETRY_DEFORMATION_BIT_SGIX+    , gl_LUMINANCE_ALPHA_FLOAT32_ATI+    , gl_INT_SAMPLER_CUBE_MAP_ARRAY+    , gl_EVAL_TRIANGULAR_2D_NV+    , gl_QUERY_BY_REGION_WAIT_INVERTED+    , gl_CONTEXT_ROBUST_ACCESS_KHR+    , gl_STREAM_READ_ARB+    , gl_INT_IMAGE_1D_ARRAY_EXT+    , gl_QUERY_NO_WAIT_INVERTED+    , gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT+    , gl_COLOR_ATTACHMENT4_EXT+    , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR+    , gl_LOSE_CONTEXT_ON_RESET+    , gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM+    , gl_REPLACEMENT_CODE_SUN+    , gl_422_REV_EXT+    , gl_COMPILE_STATUS+    , gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE+    , gl_TRANSPOSE_COLOR_MATRIX+    , gl_COLOR_TABLE_FORMAT+    , gl_VERSION_ES_CM_1_1+    , gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE+    , gl_BUFFER_STORAGE_FLAGS+    , gl_UNSIGNED_NORMALIZED_EXT+    , gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE+    , gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT+    , gl_3_BYTES+    , gl_CND0_ATI+    , gl_TEXTURE_MAX_LEVEL_APPLE+    , gl_POINT+    , gl_MODELVIEW11_ARB+    , gl_RED_BITS+    , gl_PIXEL_TILE_GRID_WIDTH_SGIX+    , gl_DRAW_BUFFER7_NV+    , gl_OP_SET_LT_EXT+    , gl_TEXTURE24_ARB+    , gl_TESS_GEN_POINT_MODE+    , gl_INTERNALFORMAT_PREFERRED+    , gl_VERTEX_SHADER_VARIANTS_EXT+    , gl_COMBINER_CD_OUTPUT_NV+    , gl_TRANSPOSE_CURRENT_MATRIX_ARB+    , gl_MAX_ARRAY_TEXTURE_LAYERS_EXT+    , gl_UNSIGNED_SHORT_8_8_MESA+    , gl_BLEND_ADVANCED_COHERENT_NV+    , gl_VERTEX_ARRAY_EXT+    , gl_BOOL_VEC4_ARB+    , gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV+    , gl_UNSIGNED_SHORT_5_5_5_1+    , gl_SHADE_MODEL+    , gl_MIRROR_CLAMP_TO_EDGE+    , gl_RGB5_EXT+    , gl_TEXTURE_GEN_S+    , gl_TEXTURE_COMPRESSED+    , gl_FRAMEBUFFER_BLEND+    , gl_REPLACE_VALUE_AMD+    , gl_YCRCB_SGIX+    , gl_UNIFORM_BLOCK_INDEX+    , gl_TEXTURE_TOO_LARGE_EXT+    , gl_MIRRORED_REPEAT_ARB+    , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER+    , gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB+    , gl_MAX_SAMPLES+    , gl_ATTENUATION_EXT+    , gl_MIRROR_CLAMP_EXT+    , gl_DEBUG_LOGGED_MESSAGES+    , gl_DOT3_ATI+    , gl_EMBOSS_CONSTANT_NV+    , gl_OUTPUT_TEXTURE_COORD11_EXT+    , gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL+    , gl_INDEX+    , gl_CURRENT_MATRIX_ARB+    , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS+    , gl_MAX_DRAW_BUFFERS_EXT+    , gl_ADD_BLEND_IMG+    , gl_CLIP_FAR_HINT_PGI+    , gl_POST_CONVOLUTION_COLOR_TABLE+    , gl_RGBA4_OES+    , gl_QUERY_RESULT_AVAILABLE_ARB+    , gl_RGB8UI+    , gl_DYNAMIC_READ+    , gl_TEXTURE_BINDING_2D_MULTISAMPLE+    , gl_OBJECT_TYPE_APPLE+    , gl_PERCENTAGE_AMD+    , gl_LIGHT_MODEL_LOCAL_VIEWER+    , gl_SPARE0_PLUS_SECONDARY_COLOR_NV+    , gl_OP_INDEX_EXT+    , gl_VIEW_CLASS_S3TC_DXT3_RGBA+    , gl_TEXTURE_DEPTH_TYPE_ARB+    , gl_TEXTURE_ALPHA_SIZE+    , gl_YCRCB_422_SGIX+    , gl_INDEX_ARRAY_LENGTH_NV+    , gl_TRANSPOSE_AFFINE_3D_NV+    , gl_MATRIX17_ARB+    , gl_SRGB_ALPHA+    , gl_MAP_TESSELLATION_NV+    , gl_PACK_SKIP_VOLUMES_SGIS+    , gl_COLOR_BUFFER_BIT+    , gl_REG_6_ATI+    , gl_ATOMIC_COUNTER_BUFFER_BINDING+    , gl_POST_CONVOLUTION_ALPHA_BIAS+    , gl_HARDLIGHT_NV+    , gl_INTENSITY16_SNORM+    , gl_TEXCOORD1_BIT_PGI+    , gl_DEBUG_CALLBACK_FUNCTION+    , gl_TEXTURE8_ARB+    , gl_DOUBLE_VEC2_EXT+    , gl_TRIANGLES_ADJACENCY+    , gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER+    , gl_R16F+    , gl_OUTPUT_TEXTURE_COORD19_EXT+    , gl_QUAD_LUMINANCE4_SGIS+    , gl_SAMPLER_OBJECT_AMD+    , gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE+    , gl_UNSIGNED_INT_IMAGE_2D+    , gl_ALPHA_TEST+    , gl_CONVOLUTION_WIDTH+    , gl_SLUMINANCE_NV+    , gl_FRAMEBUFFER_UNDEFINED_OES+    , gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED+    , gl_HALF_FLOAT_OES+    , gl_CONVOLUTION_FORMAT_EXT+    , gl_FALSE+    , gl_ADD_ATI+    , gl_STENCIL_BACK_FAIL+    , gl_DOUBLE_VEC4+    , gl_STANDARD_FONT_NAME_NV+    , gl_ALPHA4_EXT+    , gl_EXPAND_NORMAL_NV+    , gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB+    , gl_TRACE_MASK_MESA+    , gl_VARIABLE_B_NV+    , gl_RGB16_EXT+    , gl_TEXTURE+    , gl_PIXEL_UNPACK_BUFFER_BINDING_EXT+    , gl_IMAGE_CLASS_1_X_8+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE+    , gl_BOOL_VEC2_ARB+    , gl_MAP2_VERTEX_3+    , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH+    , gl_TEXTURE_WRAP_S+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_X+    , gl_TEXTURE_CUBE_MAP_ARRAY+    , gl_TEXTURE_ALPHA_TYPE+    , gl_MAX_COLOR_ATTACHMENTS_NV+    , gl_MAX_CUBE_MAP_TEXTURE_SIZE+    , gl_ANY_SAMPLES_PASSED+    , gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE+    , gl_COLOR_ARRAY_STRIDE+    , gl_MULTISAMPLE_BIT_EXT+    , gl_VERTEX_ATTRIB_ARRAY_DIVISOR+    , gl_UNSIGNED_INT64_VEC3_NV+    , gl_WAIT_FAILED_APPLE+    , gl_DRAW_BUFFER5_ATI+    , gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT+    , gl_ONE_MINUS_CONSTANT_ALPHA_EXT+    , gl_UNSIGNED_INT_8_24_REV_MESA+    , gl_MAX_PROGRAM_ENV_PARAMETERS_ARB+    , gl_MAX_VERTEX_VARYING_COMPONENTS_EXT+    , gl_CURRENT_TANGENT_EXT+    , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB+    , gl_ALPHA16+    , gl_MAP1_VERTEX_4+    , gl_SAMPLER_CUBE_SHADOW_NV+    , gl_SAMPLER_2D_SHADOW_ARB+    , gl_PROGRAM_LENGTH_NV+    , gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM+    , gl_IGNORE_BORDER_HP+    , gl_DEBUG_SOURCE_SHADER_COMPILER+    , gl_TEXTURE_BORDER_VALUES_NV+    , gl_FRAGMENT_SUBROUTINE+    , gl_MAX_DEPTH_TEXTURE_SAMPLES+    , gl_VERTEX_ATTRIB_ARRAY_POINTER+    , gl_COLOR_ATTACHMENT7+    , gl_LAST_VERTEX_CONVENTION_EXT+    , gl_TEXTURE_LO_SIZE_NV+    , gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER+    , gl_COMPRESSED_RGB8_ETC2_OES+    , gl_NORMAL_MAP_NV+    , gl_COLOR_ARRAY_COUNT_EXT+    , gl_TEXTURE_COMPARE_MODE_EXT+    , gl_BINORMAL_ARRAY_TYPE_EXT+    , gl_OPERAND0_RGB_EXT+    , gl_MAX_VERTEX_VARYING_COMPONENTS_ARB+    , gl_PIXEL_MIN_FILTER_EXT+    , gl_ACCUM_ADJACENT_PAIRS_NV+    , gl_BLEND_DST+    , gl_W_EXT+    , gl_RENDERBUFFER_COVERAGE_SAMPLES_NV+    , gl_STENCIL_FUNC+    , gl_MAX_VERTEX_STREAMS+    , gl_GEOMETRY_INPUT_TYPE+    , gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV+    , gl_MINMAX_SINK_EXT+    , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER+    , gl_DOUBLE_MAT2x3+    , gl_FRACTIONAL_EVEN_EXT+    , gl_VERTEX_ARRAY_TYPE_EXT+    , gl_BINORMAL_ARRAY_POINTER_EXT+    , gl_SAMPLE_MASK_EXT+    , gl_TESS_CONTROL_SHADER_EXT+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT+    , gl_TANGENT_ARRAY_STRIDE_EXT+    , gl_GET_TEXTURE_IMAGE_TYPE+    , gl_OFFSET+    , gl_ALL_STATIC_DATA_IBM+    , gl_READ_PIXEL_DATA_RANGE_LENGTH_NV+    , gl_CONSTANT_COLOR+    , gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT+    , gl_MATERIAL_SIDE_HINT_PGI+    , gl_UNPACK_RESAMPLE_OML+    , gl_SAMPLE_SHADING+    , gl_OUTPUT_TEXTURE_COORD13_EXT+    , gl_MAX_COLOR_MATRIX_STACK_DEPTH+    , gl_INT64_VEC3_NV+    , gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV+    , gl_TEXTURE_STACK_DEPTH+    , gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL+    , gl_FRAMEBUFFER_UNSUPPORTED_EXT+    , gl_QUERY_TARGET+    , gl_LUMINANCE4_ALPHA4+    , gl_TRANSFORM_FEEDBACK_BARRIER_BIT+    , gl_RGB32UI+    , gl_STATIC_DRAW+    , gl_MAX_COMPUTE_UNIFORM_BLOCKS+    , gl_PALETTE4_RGBA8_OES+    , gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL+    , gl_TEXTURE21+    , gl_RGB32I+    , gl_MAX_TEXTURE_LOD_BIAS_EXT+    , gl_PATH_GEN_COLOR_FORMAT_NV+    , gl_RGB10_A2UI+    , gl_GREEN_BITS+    , gl_POLYGON_MODE+    , gl_SUCCESS_NV+    , gl_RGBA12+    , gl_PATCHES+    , gl_ACCUM+    , gl_NUM_PASSES_ATI+    , gl_DEBUG_TYPE_ERROR_ARB+    , gl_TEXTURE_LIGHTING_MODE_HP+    , gl_HISTOGRAM_SINK_EXT+    , gl_POINT_SIZE_GRANULARITY+    , gl_R32F+    , gl_STATIC_COPY+    , gl_FOG_COORDINATE_ARRAY_TYPE_EXT+    , gl_SPARE0_NV+    , gl_3DC_XY_AMD+    , gl_LUMINANCE_ALPHA32F_ARB+    , gl_VERTEX_ARRAY_RANGE_VALID_NV+    , gl_DEPTH_BUFFER_BIT6_QCOM+    , gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX+    , gl_LINE_WIDTH+    , gl_FOG_OFFSET_SGIX+    , gl_GEOMETRY_SHADER_BIT_EXT+    , gl_TEXTURE_BLUE_SIZE+    , gl_TEXTURE_SHADER_NV+    , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV+    , gl_FRAMEZOOM_SGIX+    , gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT+    , gl_DEPTH_RENDERABLE+    , gl_MAX_TEXTURE_BUFFER_SIZE+    , gl_COLOR_ALPHA_PAIRING_ATI+    , gl_PACK_REVERSE_ROW_ORDER_ANGLE+    , gl_VERTEX_ATTRIB_ARRAY_NORMALIZED+    , gl_OP_MADD_EXT+    , gl_TEXTURE7+    , gl_RGB32I_EXT+    , gl_RED_BIAS+    , gl_FLOAT_VEC2+    , gl_HALF_APPLE+    , gl_SGX_BINARY_IMG+    , gl_CON_28_ATI+    , gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP+    , gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV+    , gl_MAP2_VERTEX_ATTRIB2_4_NV+    , gl_TRANSFORM_BIT+    , gl_R8+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV+    , gl_T+    , gl_TEXTURE_ENV_MODE+    , gl_HIGH_INT+    , gl_TEXTURE_UNSIGNED_REMAP_MODE_NV+    , gl_MAX_PROGRAM_LOOP_COUNT_NV+    , gl_PERFQUERY_WAIT_INTEL+    , gl_INVALID_FRAMEBUFFER_OPERATION_EXT+    , gl_TEXTURE_2D_BINDING_EXT+    , gl_TEXTURE_NUM_LEVELS_QCOM+    , gl_TEXTURE_BUFFER_ARB+    , gl_TRUE+    , gl_MAX_LAYERS+    , gl_MAX_TEXTURE_UNITS_ARB+    , gl_MAP2_NORMAL+    , gl_DUAL_ALPHA16_SGIS+    , gl_PROGRAM_OUTPUT+    , gl_OUTPUT_TEXTURE_COORD22_EXT+    , gl_SAMPLER_1D_ARB+    , gl_POST_CONVOLUTION_GREEN_BIAS+    , gl_INT_IMAGE_CUBE+    , gl_CURRENT_VERTEX_WEIGHT_EXT+    , gl_SIGNED_LUMINANCE8_NV+    , gl_TEXTURE_VIEW_NUM_LAYERS_EXT+    , gl_RG16F+    , gl_PROGRAM_POINT_SIZE_EXT+    , gl_FILE_NAME_NV+    , gl_INT_IMAGE_BUFFER_EXT+    , gl_TEXTURE_UPDATE_BARRIER_BIT+    , gl_HARDMIX_NV+    , gl_FLOAT_MAT3x4+    , gl_TEXTURE_INTERNAL_FORMAT_QCOM+    , gl_INTERNALFORMAT_BLUE_SIZE+    , gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV+    , gl_HSL_COLOR_NV+    , gl_CONDITION_SATISFIED+    , gl_UNIFORM_BUFFER_LENGTH_NV+    , gl_ALPHA8UI_EXT+    , gl_REG_23_ATI+    , gl_UNSIGNED_SHORT_5_6_5_EXT+    , gl_EDGE_FLAG_ARRAY_LENGTH_NV+    , gl_IMAGE_CLASS_1_X_16+    , gl_LUMINANCE8_ALPHA8_SNORM+    , gl_PATH_FILL_COVER_MODE_NV+    , gl_LUMINANCE_ALPHA_FLOAT32_APPLE+    , gl_INTENSITY16UI_EXT+    , gl_RENDERBUFFER_SAMPLES_APPLE+    , gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE+    , gl_LUMINANCE_ALPHA32I_EXT+    , gl_REGISTER_COMBINERS_NV+    , gl_R1UI_N3F_V3F_SUN+    , gl_FOG_COORDINATE_SOURCE+    , gl_DEBUG_SEVERITY_MEDIUM_AMD+    , gl_MODELVIEW30_ARB+    , gl_COMPRESSED_RGBA_S3TC_DXT5_EXT+    , gl_DRAW_BUFFER0_NV+    , gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT+    , gl_ELEMENT_ARRAY_BARRIER_BIT+    , gl_SHADER_PIXEL_LOCAL_STORAGE_EXT+    , gl_FRONT_LEFT+    , gl_UNIFORM_BUFFER_BINDING+    , gl_SIGNED_RGBA8_NV+    , gl_EYE_PLANE+    , gl_TEXTURE_1D+    , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT+    , gl_MALI_PROGRAM_BINARY_ARM+    , gl_SKIP_COMPONENTS3_NV+    , gl_LUMINANCE_ALPHA+    , gl_ACCUM_RED_BITS+    , gl_POLYGON_OFFSET_FACTOR+    , gl_SAMPLER_2D_ARRAY_SHADOW_NV+    , gl_VARIABLE_D_NV+    , gl_TEXTURE_LEQUAL_R_SGIX+    , gl_INT+    , gl_IMAGE_TRANSLATE_Y_HP+    , gl_POINT_TOKEN+    , gl_RESAMPLE_ZERO_FILL_OML+    , gl_DEBUG_SOURCE_THIRD_PARTY_KHR+    , gl_TEXTURE_MAG_SIZE_NV+    , gl_PER_STAGE_CONSTANTS_NV+    , gl_VIRTUAL_PAGE_SIZE_Y_ARB+    , gl_SPRITE_EYE_ALIGNED_SGIX+    , gl_EVAL_VERTEX_ATTRIB14_NV+    , gl_TRANSFORM_FEEDBACK_VARYINGS_NV+    , gl_RGB10+    , gl_MAX_VIEWPORT_DIMS+    , gl_BLUE_MAX_CLAMP_INGR+    , gl_INCR_WRAP+    , gl_VIRTUAL_PAGE_SIZE_X_AMD+    , gl_BOOL_VEC3+    , gl_CON_17_ATI+    , gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES+    , gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT+    , gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI+    , gl_MINMAX+    , gl_CONSTANT_BORDER_HP+    , gl_SRGB_WRITE+    , gl_MAX_TEXTURE_BUFFER_SIZE_ARB+    , gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV+    , gl_DECAL+    , gl_REG_7_ATI+    , gl_TESS_GEN_SPACING_EXT+    , gl_ELEMENT_ARRAY_LENGTH_NV+    , gl_MATRIX31_ARB+    , gl_TRANSFORM_FEEDBACK_VARYING+    , gl_VERTEX_ATTRIB_ARRAY_SIZE+    , gl_NOTEQUAL+    , gl_READ_PIXELS_TYPE+    , gl_MODELVIEW_STACK_DEPTH+    , gl_COMPRESSED_RGBA_ASTC_6x6x5_OES+    , gl_COMBINE_EXT+    , gl_NICEST+    , gl_MODELVIEW2_ARB+    , gl_UNPACK_IMAGE_HEIGHT+    , gl_TEXTURE_CUBE_MAP_ARRAY_ARB+    , gl_DRAW_BUFFER12+    , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET+    , gl_FRAMEBUFFER_DEFAULT_HEIGHT+    , gl_DT_BIAS_NV+    , gl_DSDT_NV+    , gl_IMAGE_CUBE_MAP_ARRAY+    , gl_STENCIL_INDEX4+    , gl_ROUND_NV+    , gl_Y_EXT+    , gl_PATH_DASH_CAPS_NV+    , gl_TEXTURE_PRIORITY+    , gl_TEXTURE_4D_BINDING_SGIS+    , gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD+    , gl_CULL_MODES_NV+    , gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE+    , gl_REFERENCED_BY_GEOMETRY_SHADER_EXT+    , gl_MODELVIEW_MATRIX+    , gl_VIDEO_BUFFER_NV+    , gl_TEXTURE12+    , gl_COLORBURN_NV+    , gl_COLOR_ARRAY_BUFFER_BINDING_ARB+    , gl_READ_BUFFER_EXT+    , gl_RENDERBUFFER_RED_SIZE_OES+    , gl_TEXTURE_SHARED_SIZE+    , gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS+    , gl_ALL_SHADER_BITS_EXT+    , gl_PERFQUERY_SINGLE_CONTEXT_INTEL+    , gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT+    , gl_PERFMON_RESULT_AMD+    , gl_GUILTY_CONTEXT_RESET+    , gl_PREVIOUS+    , gl_UNSIGNED_INT16_VEC3_NV+    , gl_VERTEX_ATTRIB_MAP1_APPLE+    , gl_LIGHT3+    , gl_TESS_EVALUATION_SUBROUTINE_UNIFORM+    , gl_DUAL_INTENSITY8_SGIS+    , gl_PARAMETER_BUFFER_BINDING_ARB+    , gl_CURRENT_SECONDARY_COLOR+    , gl_RENDERBUFFER_ALPHA_SIZE+    , gl_DUAL_INTENSITY12_SGIS+    , gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING+    , gl_OP_MAX_EXT+    , gl_EDGE_FLAG_ARRAY_EXT+    , gl_COLOR_TABLE_LUMINANCE_SIZE+    , gl_FOG_COORD_ARRAY_ADDRESS_NV+    , gl_COPY+    , gl_DRAW_BUFFER2_NV+    , gl_SAMPLER_BINDING+    , gl_COPY_WRITE_BUFFER+    , gl_PIXEL_UNPACK_BUFFER+    , gl_VIEW_CLASS_S3TC_DXT1_RGBA+    , gl_DRAW_FRAMEBUFFER_APPLE+    , gl_PIXEL_MAP_A_TO_A_SIZE+    , gl_EDGE_FLAG+    , gl_CLIP_DISTANCE2+    , gl_TEXTURE_GEN_MODE+    , gl_HALF_BIAS_NORMAL_NV+    , gl_RESAMPLE_ZERO_FILL_SGIX+    , gl_OUTPUT_TEXTURE_COORD12_EXT+    , gl_UNSIGNED_SHORT_8_8_REV_MESA+    , gl_PALETTE8_RGBA8_OES+    , gl_TEXTURE_4D_SGIS+    , gl_PIXEL_PACK_BUFFER_EXT+    , gl_MAP_ATTRIB_U_ORDER_NV+    , gl_FUNC_SUBTRACT+    , gl_PIXEL_SUBSAMPLE_4444_SGIX+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y+    , gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT+    , gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT+    , gl_DYNAMIC_COPY+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT+    , gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT+    , gl_PROGRAM_LENGTH_ARB+    , gl_MODELVIEW14_ARB+    , gl_ITALIC_BIT_NV+    , gl_OR_INVERTED+    , gl_CLIP_NEAR_HINT_PGI+    , gl_COVERAGE_EDGE_FRAGMENTS_NV+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR+    , gl_PROGRAM_BINARY_LENGTH_OES+    , gl_DRAW_BUFFER8_ARB+    , gl_DRAW_FRAMEBUFFER_EXT+    , gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET+    , gl_SYNC_CL_EVENT_ARB+    , gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE+    , gl_MAX_VERTEX_HINT_PGI+    , gl_UNPACK_IMAGE_HEIGHT_EXT+    , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV+    , gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE+    , gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB+    , gl_STENCIL_BACK_REF+    , gl_CLAMP_READ_COLOR_ARB+    , gl_INTERNALFORMAT_RED_SIZE+    , gl_PATCH_DEFAULT_INNER_LEVEL_EXT+    , gl_OUTPUT_TEXTURE_COORD27_EXT+    , gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD+    , gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS+    , gl_LOCATION+    , gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS+    , gl_POST_COLOR_MATRIX_GREEN_SCALE+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR+    , gl_POST_COLOR_MATRIX_ALPHA_SCALE+    , gl_HORIZONTAL_LINE_TO_NV+    , gl_MAX_FRAGMENT_INPUT_COMPONENTS+    , gl_PROGRAM_STRING_ARB+    , gl_EDGE_FLAG_ARRAY_ADDRESS_NV+    , gl_VENDOR+    , gl_CLIPPING_INPUT_PRIMITIVES_ARB+    , gl_TEXTURE_RENDERBUFFER_NV+    , gl_ELEMENT_ARRAY_ADDRESS_NV+    , gl_LOCAL_EXT+    , gl_GEOMETRY_SHADER_INVOCATIONS+    , gl_INT_VEC4_ARB+    , gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE+    , gl_SEPARATE_ATTRIBS_NV+    , gl_FLOAT_MAT4_ARB+    , gl_COLOR_ATTACHMENT_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE+    , gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB+    , gl_SHININESS+    , gl_INTERPOLATE_EXT+    , gl_TRANSFORM_FEEDBACK+    , gl_TEXTURE_DEPTH_QCOM+    , gl_DOUBLE_MAT4x2+    , gl_NORMAL_ARRAY_BUFFER_BINDING_ARB+    , gl_PIXEL_TEX_GEN_SGIX+    , gl_TRANSFORM_FEEDBACK_BUFFER_START+    , gl_GLYPH_WIDTH_BIT_NV+    , gl_STENCIL_ATTACHMENT_EXT+    , gl_VERTEX_ARRAY_RANGE_POINTER_APPLE+    , gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT+    , gl_MATRIX4_NV+    , gl_READ_FRAMEBUFFER_ANGLE+    , gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS+    , gl_VERTEX_ARRAY_POINTER_EXT+    , gl_RELATIVE_ROUNDED_RECT_NV+    , gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV+    , gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV+    , gl_TEXTURE_MEMORY_LAYOUT_INTEL+    , gl_REG_0_ATI+    , gl_VERTEX_ATTRIB_ARRAY15_NV+    , gl_RGB12_EXT+    , gl_FRAGMENT_LIGHT6_SGIX+    , gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV+    , gl_QUERY_ALL_EVENT_BITS_AMD+    , gl_INTENSITY_FLOAT32_APPLE+    , gl_LIST_INDEX+    , gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG+    , gl_REG_18_ATI+    , gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT+    , gl_COMPILE+    , gl_VIEW_CLASS_128_BITS+    , gl_4X_BIT_ATI+    , gl_CLIENT_PIXEL_STORE_BIT+    , gl_OPERAND2_RGB+    , gl_MINMAX_FORMAT_EXT+    , gl_UNSIGNED_INT_IMAGE_1D+    , gl_INSTRUMENT_MEASUREMENTS_SGIX+    , gl_VALIDATE_STATUS+    , gl_NORMAL_ARRAY_COUNT_EXT+    , gl_PATH_STENCIL_REF_NV+    , gl_DRAW_BUFFER5_NV+    , gl_COMPRESSED_RGBA_ARB+    , gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV+    , gl_MAX_3D_TEXTURE_SIZE+    , gl_FRAGMENT_NORMAL_EXT+    , gl_SHADER_KHR+    , gl_TEXTURE_DEPTH_TYPE+    , gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA+    , gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE+    , gl_TEXTURE_2D_STACK_BINDING_MESAX+    , gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB+    , gl_INT_SAMPLER_2D_EXT+    , gl_RGBA4_S3TC+    , gl_MAX_SPOT_EXPONENT_NV+    , gl_NEGATIVE_X_EXT+    , gl_SYNC_X11_FENCE_EXT+    , gl_OP_DOT3_EXT+    , gl_LUMINANCE8_SNORM+    , gl_SAMPLE_SHADING_ARB+    , gl_CONVOLUTION_2D_EXT+    , gl_MAP2_TEXTURE_COORD_2+    , gl_SHADER_IMAGE_LOAD+    , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV+    , gl_TEXTURE_VIEW_NUM_LEVELS_EXT+    , gl_ACTIVE_UNIFORMS+    , gl_ACCUM_GREEN_BITS+    , gl_TESS_EVALUATION_PROGRAM_NV+    , gl_COMPRESSED_SLUMINANCE+    , gl_COLOR_ATTACHMENT14_EXT+    , gl_VERTEX23_BIT_PGI+    , gl_BUMP_ROT_MATRIX_ATI+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT+    , gl_MAX_PALETTE_MATRICES_OES+    , gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV+    , gl_CONVOLUTION_BORDER_MODE_EXT+    , gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE+    , gl_INTENSITY32I_EXT+    , gl_RASTERIZER_DISCARD_EXT+    , gl_MAX_SAMPLES_EXT+    , gl_DRAW_BUFFER10_EXT+    , gl_INT_IMAGE_2D+    , gl_PROVOKING_VERTEX+    , gl_UNPACK_RESAMPLE_SGIX+    , gl_SAMPLE_POSITION_NV+    , gl_MAX_PROGRAM_MATRICES_ARB+    , gl_SHADER_STORAGE_BUFFER_BINDING+    , gl_TEXTURE0+    , gl_DSDT_MAG_VIB_NV+    , gl_DOUBLE_MAT4x3+    , gl_TEXTURE27_ARB+    , gl_ACTIVE_ATOMIC_COUNTER_BUFFERS+    , gl_LUMINANCE32I_EXT+    , gl_SAMPLER_KHR+    , gl_MITER_REVERT_NV+    , gl_RGB32UI_EXT+    , gl_DUAL_LUMINANCE12_SGIS+    , gl_BOOL_VEC2+    , gl_COLOR_ATTACHMENT1_NV+    , gl_MAX_CONVOLUTION_WIDTH+    , gl_DRAW_BUFFER14_NV+    , gl_BLEND_DST_RGB_EXT+    , gl_LUMINANCE12_ALPHA12_EXT+    , gl_DEPTH_BOUNDS_EXT+    , gl_CIRCULAR_CCW_ARC_TO_NV+    , gl_COMPRESSED_LUMINANCE_ALPHA+    , gl_SAMPLE_COVERAGE_VALUE_ARB+    , gl_DEPTH_STENCIL_TO_RGBA_NV+    , gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING+    , gl_NAME_LENGTH+    , gl_STENCIL_TEST_TWO_SIDE_EXT+    , gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES+    , gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB+    , gl_OUTPUT_TEXTURE_COORD30_EXT+    , gl_MAX_PROGRAM_SUBROUTINE_NUM_NV+    , gl_MULTIPLY_NV+    , gl_TEXTURE19+    , gl_INVERT_OVG_NV+    , gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES+    , gl_NEAREST_CLIPMAP_LINEAR_SGIX+    , gl_VARIABLE_A_NV+    , gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT+    , gl_TEXTURE_2D_MULTISAMPLE+    , gl_DEBUG_SOURCE_THIRD_PARTY+    , gl_DRAW_BUFFER7_ARB+    , gl_MAX_DRAW_BUFFERS+    , gl_MAX_SERVER_WAIT_TIMEOUT+    , gl_COMPRESSED_SIGNED_RG11_EAC+    , gl_VERTEX_PROGRAM_POINT_SIZE+    , gl_STENCIL_PASS_DEPTH_PASS+    , gl_RENDERBUFFER_STENCIL_SIZE+    , gl_TEXTURE_BINDING_2D+    , gl_DATA_BUFFER_AMD+    , gl_DEBUG_CATEGORY_APPLICATION_AMD+    , gl_ASYNC_HISTOGRAM_SGIX+    , gl_UNPACK_LSB_FIRST+    , gl_UNSIGNED_INT_SAMPLER_CUBE_EXT+    , gl_DEPTH_CLAMP_FAR_AMD+    , gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV+    , gl_VERTEX_ATTRIB_ARRAY_STRIDE+    , gl_UNSIGNED_INT16_VEC4_NV+    , gl_OBJECT_BUFFER_SIZE_ATI+    , gl_YCRCB_444_SGIX+    , gl_LOSE_CONTEXT_ON_RESET_KHR+    , gl_TEXTURE_VIEW_NUM_LAYERS+    , gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB+    , gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL+    , gl_OBJECT_DELETE_STATUS_ARB+    , gl_SQUARE_NV+    , gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT+    , gl_DEBUG_SEVERITY_NOTIFICATION_KHR+    , gl_EYE_LINEAR_NV+    , gl_REG_16_ATI+    , gl_LUMINANCE_ALPHA32UI_EXT+    , gl_OUTPUT_TEXTURE_COORD31_EXT+    , gl_COMPRESSED_RG_RGTC2+    , gl_FLOAT_MAT3+    , gl_INDEX_ARRAY_POINTER+    , gl_FOG_COORD+    , gl_DRAW_BUFFER13+    , gl_SCALED_RESOLVE_NICEST_EXT+    , gl_QUERY_RESULT_AVAILABLE+    , gl_UNPACK_SUBSAMPLE_RATE_SGIX+    , gl_3_BYTES_NV+    , gl_CLEAR+    , gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT+    , gl_R8UI+    , gl_OFFSET_TEXTURE_2D_MATRIX_NV+    , gl_BGRA_INTEGER+    , gl_MAX_ARRAY_TEXTURE_LAYERS+    , gl_COMPRESSED_RGB_ARB+    , gl_FOG_COORDINATE_ARRAY_POINTER_EXT+    , gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT+    , gl_TEXTURE_MAG_FILTER+    , gl_DEPTH_COMPONENT32+    , gl_VIEW_CLASS_S3TC_DXT1_RGB+    , gl_FRONT_RIGHT+    , gl_HISTOGRAM_WIDTH+    , gl_SAMPLER_CUBE_MAP_ARRAY_ARB+    , gl_WEIGHT_ARRAY_STRIDE_OES+    , gl_PIXEL_PACK_BUFFER_ARB+    , gl_DOT_PRODUCT_PASS_THROUGH_NV+    , gl_COMPRESSED_RG11_EAC+    , gl_SRGB_DECODE_ARB+    , gl_OP_SUB_EXT+    , gl_SLIM12S_SGIX+    , gl_SECONDARY_COLOR_NV+    , gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS+    , gl_MAP1_VERTEX_3+    , gl_RELATIVE_ROUNDED_RECT8_NV+    , gl_PALETTE4_R5_G6_B5_OES+    , gl_UNSIGNED_INT8_NV+    , gl_CURRENT_MATRIX_STACK_DEPTH_ARB+    , gl_PIXEL_MODE_BIT+    , gl_FONT_UNINTELLIGIBLE_NV+    , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT+    , gl_LUMINANCE8UI_EXT+    , gl_HILO16_NV+    , gl_MAP2_VERTEX_ATTRIB8_4_NV+    , gl_ATTACHED_SHADERS+    , gl_OBJECT_POINT_SGIS+    , gl_TEXTURE_CUBE_MAP_SEAMLESS+    , gl_COLOR_ATTACHMENT0+    , gl_POST_CONVOLUTION_ALPHA_BIAS_EXT+    , gl_SAMPLE_PATTERN_SGIS+    , gl_COPY_PIXEL_TOKEN+    , gl_BUFFER_SIZE_ARB+    , gl_DEPTH_BOUNDS_TEST_EXT+    , gl_SAMPLE_POSITION+    , gl_FULL_STIPPLE_HINT_PGI+    , gl_DEBUG_ASSERT_MESA+    , gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB+    , gl_RENDERBUFFER_WIDTH_OES+    , gl_FLOAT_RGBA16_NV+    , gl_MODELVIEW5_ARB+    , gl_VERSION+    , gl_TEXTURE17_ARB+    , gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT+    , gl_MODELVIEW0_STACK_DEPTH_EXT+    , gl_OUTPUT_TEXTURE_COORD1_EXT+    , gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES+    , gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX+    , gl_IMAGE_TRANSFORM_2D_HP+    , gl_HSL_SATURATION_NV+    , gl_UNSIGNED_SHORT_5_6_5_REV+    , gl_LINEAR_CLIPMAP_NEAREST_SGIX+    , gl_PREVIOUS_ARB+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT+    , gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL+    , gl_SLUMINANCE8_EXT+    , gl_RGBA16F_ARB+    , gl_PIXEL_UNPACK_BUFFER_ARB+    , gl_STENCIL_REF+    , gl_TEXTURE_VIEW_MIN_LAYER_EXT+    , gl_HISTOGRAM_RED_SIZE+    , gl_CLIP_PLANE1+    , gl_UNKNOWN_CONTEXT_RESET_ARB+    , gl_CMYK_EXT+    , gl_TEXTURE_COMPRESSED_BLOCK_SIZE+    , gl_RGBA8I+    , gl_TEXTURE29_ARB+    , gl_STENCIL_BUFFER_BIT2_QCOM+    , gl_RED_MIN_CLAMP_INGR+    , gl_ATC_RGBA_EXPLICIT_ALPHA_AMD+    , gl_ALL_COMPLETED_NV+    , gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE+    , gl_MATRIX10_ARB+    , gl_MAP1_VERTEX_ATTRIB1_4_NV+    , gl_MAX_4D_TEXTURE_SIZE_SGIS+    , gl_VIEW_CLASS_32_BITS+    , gl_TEXTURE7_ARB+    , gl_DEBUG_TYPE_PERFORMANCE_ARB+    , gl_ACTIVE_VARIABLES+    , gl_SOURCE2_RGB_EXT+    , gl_PACK_INVERT_MESA+    , gl_QUERY_BY_REGION_WAIT_NV+    , gl_VERTEX_ID_SWIZZLE_AMD+    , gl_SPRITE_TRANSLATION_SGIX+    , gl_RENDERBUFFER_HEIGHT+    , gl_CUBIC_EXT+    , gl_TEXTURE19_ARB+    , gl_T2F_N3F_V3F+    , gl_ATOMIC_COUNTER_BARRIER_BIT_EXT+    , gl_ARRAY_ELEMENT_LOCK_FIRST_EXT+    , gl_PROGRAM_RESULT_COMPONENTS_NV+    , gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB+    , gl_TRIANGLE_MESH_SUN+    , gl_TEXTURE_WRAP_Q_SGIS+    , gl_ATTRIB_ARRAY_SIZE_NV+    , gl_DEBUG_LOGGED_MESSAGES_AMD+    , gl_BOOL+    , gl_MIN_LOD_WARNING_AMD+    , gl_PACK_SKIP_PIXELS+    , gl_IMAGE_TEXEL_SIZE+    , gl_SRC_ALPHA+    , gl_DEPENDENT_HILO_TEXTURE_2D_NV+    , gl_FRAMEBUFFER_ATTACHMENT_LAYERED+    , gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR+    , gl_VERTEX_ARRAY_RANGE_LENGTH_NV+    , gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS+    , gl_POST_CONVOLUTION_GREEN_SCALE+    , gl_SEPARATE_ATTRIBS+    , gl_UNSIGNED_BYTE_3_3_2+    , gl_SCALAR_EXT+    , gl_POINT_SIZE_ARRAY_STRIDE_OES+    , gl_DOUBLE_MAT3x4+    , gl_SRC0_RGB+    , gl_VIEW_CLASS_BPTC_UNORM+    , gl_SYNC_FLAGS+    , gl_TEXTURE_SWIZZLE_RGBA_EXT+    , gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX+    , gl_TEXTURE29+    , gl_MEDIUM_INT+    , gl_CURRENT_QUERY_ARB+    , gl_DT_SCALE_NV+    , gl_CLAMP_VERTEX_COLOR_ARB+    , gl_DEPTH_BUFFER_BIT4_QCOM+    , gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2+    , gl_USE_MISSING_GLYPH_NV+    , gl_MAX_ASYNC_TEX_IMAGE_SGIX+    , gl_TESS_CONTROL_TEXTURE+    , gl_DEPTH_FUNC+    , gl_RG8I+    , gl_MAX_VERTEX_SHADER_VARIANTS_EXT+    , gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB+    , gl_COMPRESSED_SRGB+    , gl_PROGRAM_BINDING_ARB+    , gl_SAMPLER_2D_ARRAY+    , gl_IMAGE_CUBE_MAP_ARRAY_EXT+    , gl_BUFFER_ACCESS_FLAGS+    , gl_EIGHTH_BIT_ATI+    , gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV+    , gl_INT8_VEC4_NV+    , gl_CLEAR_TEXTURE+    , gl_TEXTURE_CUBE_MAP_OES+    , gl_FONT_NUM_GLYPH_INDICES_BIT_NV+    , gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV+    , gl_RENDERBUFFER_DEPTH_SIZE+    , gl_DOT_PRODUCT_TEXTURE_1D_NV+    , gl_DOUBLE_VEC3_EXT+    , gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV+    , gl_TEXTURE_LUMINANCE_TYPE+    , gl_CONTEXT_FLAGS+    , gl_NORMAL_ARRAY_BUFFER_BINDING+    , gl_PROGRAM_FORMAT_ARB+    , gl_MOVE_TO_CONTINUES_NV+    , gl_LO_BIAS_NV+    , gl_CONVOLUTION_WIDTH_EXT+    , gl_FRAGMENT_TEXTURE+    , gl_NORMAL_BIT_PGI+    , gl_COMPRESSED_SIGNED_RG11_EAC_OES+    , gl_FIRST_VERTEX_CONVENTION+    , gl_ROUNDED_RECT2_NV+    , gl_POST_COLOR_MATRIX_RED_BIAS+    , gl_UNIFORM_BUFFER+    , gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT+    , gl_NUM_SAMPLE_COUNTS+    , gl_FOG_OFFSET_VALUE_SGIX+    , gl_DIFFUSE+    , gl_CLIP_PLANE5+    , gl_OUTPUT_FOG_EXT+    , gl_PROGRAM_ATTRIB_COMPONENTS_NV+    , gl_RGBA_SIGNED_COMPONENTS_EXT+    , gl_COLOR_ARRAY_EXT+    , gl_PROXY_TEXTURE_1D_STACK_MESAX+    , gl_TEXTURE_COORD_ARRAY_POINTER+    , gl_MAX_COLOR_ATTACHMENTS+    , gl_TEXTURE28_ARB+    , gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX+    , gl_DEPTH24_STENCIL8_EXT+    , gl_MAX+    , gl_MODELVIEW12_ARB+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES+    , gl_PIXEL_MAP_I_TO_I_SIZE+    , gl_NORMAL_ARRAY_LIST_STRIDE_IBM+    , gl_SOURCE3_RGB_NV+    , gl_ALPHA12_EXT+    , gl_STREAM_COPY_ARB+    , gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI+    , gl_FRAGMENT_SUBROUTINE_UNIFORM+    , gl_IS_ROW_MAJOR+    , gl_UNPACK_SKIP_IMAGES+    , gl_NUM_GENERAL_COMBINERS_NV+    , gl_STENCIL_CLEAR_TAG_VALUE_EXT+    , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS+    , gl_DRAW_BUFFER12_ARB+    , gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV+    , gl_VERTEX_ARRAY_OBJECT_EXT+    , gl_PN_TRIANGLES_NORMAL_MODE_ATI+    , gl_C4UB_V3F+    , gl_REPEAT+    , gl_MAX_SAMPLE_MASK_WORDS_NV+    , gl_STORAGE_SHARED_APPLE+    , gl_TEXTURE9_ARB+    , gl_QUERY_BUFFER_BINDING+    , gl_UNSIGNED_SHORT_8_8_REV_APPLE+    , gl_MAX_FRAGMENT_UNIFORM_VECTORS+    , gl_UNDEFINED_APPLE+    , gl_TABLE_TOO_LARGE_EXT+    , gl_MAX_TESS_PATCH_COMPONENTS_EXT+    , gl_XOR_NV+    , gl_MAX_SHADER_BUFFER_ADDRESS_NV+    , gl_DEBUG_SOURCE_WINDOW_SYSTEM+    , gl_UNSIGNALED_APPLE+    , gl_SIGNED_LUMINANCE_NV+    , gl_FOG_DISTANCE_MODE_NV+    , gl_PN_TRIANGLES_POINT_MODE_ATI+    , gl_GEOMETRY_SUBROUTINE_UNIFORM+    , gl_NEGATIVE_Z_EXT+    , gl_PIXEL_MAP_R_TO_R+    , gl_OBJECT_LINK_STATUS_ARB+    , gl_NUM_ACTIVE_VARIABLES+    , gl_BUFFER_UPDATE_BARRIER_BIT_EXT+    , gl_IMAGE_CUBE_EXT+    , gl_RGB_INTEGER_EXT+    , gl_DRAW_BUFFER13_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT+    , gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE+    , gl_RGB_SCALE+    , gl_DOUBLE_MAT3x4_EXT+    , gl_EXP+    , gl_PERFMON_RESULT_AVAILABLE_AMD+    , gl_STENCIL_VALUE_MASK+    , gl_COLOR_ATTACHMENT12_NV+    , gl_VERTEX_STREAM2_ATI+    , gl_MAP_COHERENT_BIT+    , gl_COMPRESSED_SIGNED_RG_RGTC2+    , gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER+    , gl_FRAGMENT_PROGRAM_ARB+    , gl_COLOR_BUFFER_BIT6_QCOM+    , gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV+    , gl_WIDE_LINE_HINT_PGI+    , gl_FRAGMENT_LIGHT4_SGIX+    , gl_RGBA_FLOAT_MODE_ATI+    , gl_UNSIGNED_INT_10F_11F_11F_REV+    , gl_MODELVIEW1_STACK_DEPTH_EXT+    , gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV+    , gl_POINT_SIZE_MAX+    , gl_ALPHA_TEST_REF_QCOM+    , gl_RELATIVE_HORIZONTAL_LINE_TO_NV+    , gl_FILTER4_SGIS+    , gl_TEXTURE4+    , gl_INDEX_MATERIAL_EXT+    , gl_FETCH_PER_SAMPLE_ARM+    , gl_VARIANT_ARRAY_TYPE_EXT+    , gl_ALPHA_MAX_SGIX+    , gl_NUM_INSTRUCTIONS_TOTAL_ATI+    , gl_TEXTURE_IMAGE_TYPE+    , gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS+    , gl_DRAW_BUFFER11_NV+    , gl_SURFACE_STATE_NV+    , gl_BLEND_SRC_RGB+    , gl_OBJECT_ACTIVE_UNIFORMS_ARB+    , gl_COLORDODGE_NV+    , gl_PRIMITIVES_GENERATED_NV+    , gl_IMAGE_2D_ARRAY+    , gl_LOSE_CONTEXT_ON_RESET_ARB+    , gl_RG_INTEGER+    , gl_UNSIGNED_INT_SAMPLER_1D_EXT+    , gl_REFLECTION_MAP_ARB+    , gl_NORMAL_ARRAY_TYPE_EXT+    , gl_BLUE_BITS+    , gl_ATOMIC_COUNTER_BARRIER_BIT+    , gl_INTENSITY8I_EXT+    , gl_TEXTURE_BINDING_RECTANGLE_ARB+    , gl_SCALE_BY_TWO_NV+    , gl_PACK_IMAGE_HEIGHT+    , gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL+    , gl_DEPTH_COMPONENT24_SGIX+    , gl_NUM_FRAGMENT_CONSTANTS_ATI+    , gl_EDGE_FLAG_ARRAY_STRIDE_EXT+    , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT+    , gl_SAMPLE_ALPHA_TO_COVERAGE_ARB+    , gl_UNPACK_SKIP_IMAGES_EXT+    , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL+    , gl_RGBA8_OES+    , gl_STENCIL_INDEX8_OES+    , gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD+    , gl_COMPUTE_SHADER+    , gl_QUERY_WAIT_NV+    , gl_TEXTURE_COMPARE_FUNC_ARB+    , gl_SCREEN_COORDINATES_REND+    , gl_DRAW_BUFFER4_EXT+    , gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT+    , gl_TOP_LEVEL_ARRAY_SIZE+    , gl_STATIC_COPY_ARB+    , gl_MAP1_TANGENT_EXT+    , gl_MAP2_VERTEX_ATTRIB11_4_NV+    , gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX+    , gl_DRAW_BUFFER9+    , gl_COMPRESSED_INTENSITY_ARB+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB+    , gl_MATRIX19_ARB+    , gl_MAX_MULTIVIEW_BUFFERS_EXT+    , gl_CONJOINT_NV+    , gl_INTENSITY_SNORM+    , gl_DRAW_BUFFER14+    , gl_MAX_PROGRAM_INSTRUCTIONS_ARB+    , gl_TEXTURE_BINDING_RECTANGLE+    , gl_DEBUG_SOURCE_SHADER_COMPILER_ARB+    , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR+    , gl_MULTISAMPLE_EXT+    , gl_NEAREST_MIPMAP_NEAREST+    , gl_COLOR_ATTACHMENT7_EXT+    , gl_STENCIL_BUFFER_BIT6_QCOM+    , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT+    , gl_REG_29_ATI+    , gl_COVERAGE_SAMPLES_NV+    , gl_RELEASED_APPLE+    , gl_ALPHA_TEST_FUNC+    , gl_DRAW_BUFFER2+    , gl_VERTEX_PROGRAM_BINDING_NV+    , gl_IMAGE_2D_RECT+    , gl_COLOR_TABLE_BIAS_SGI+    , gl_CLIENT_ACTIVE_TEXTURE_ARB+    , gl_CURRENT_MATRIX_INDEX_ARB+    , gl_TEXTURE_COORD_ARRAY_STRIDE+    , gl_FILTER+    , gl_MAX_MODELVIEW_STACK_DEPTH+    , gl_VERTEX_ATTRIB_ARRAY5_NV+    , gl_UNSIGNED_BYTE+    , gl_DETAIL_TEXTURE_2D_SGIS+    , gl_POST_CONVOLUTION_BLUE_BIAS+    , gl_TYPE+    , gl_COMPRESSED_RG+    , gl_4PASS_1_SGIS+    , gl_SOURCE2_RGB+    , gl_TEXTURE_MAX_LOD+    , gl_EYE_DISTANCE_TO_LINE_SGIS+    , gl_LUMINANCE_ALPHA32F_EXT+    , gl_MATRIX_INDEX_ARRAY_STRIDE_ARB+    , gl_COLOR_ATTACHMENT4+    , gl_INDEX_ARRAY_BUFFER_BINDING+    , gl_UNSIGNED_INT_SAMPLER_2D_ARRAY+    , gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX+    , gl_SPECULAR+    , gl_PACK_IMAGE_DEPTH_SGIS+    , gl_PLUS_CLAMPED_NV+    , gl_INVALID_FRAMEBUFFER_OPERATION+    , gl_RG+    , gl_COLOR_ATTACHMENT11_NV+    , gl_UNPACK_SKIP_PIXELS+    , gl_SAMPLE_BUFFERS+    , gl_DRAW_BUFFER1_ARB+    , gl_COMBINER6_NV+    , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES+    , gl_TEXTURE_ENV+    , gl_QUAD_MESH_SUN+    , gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT+    , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV+    , gl_TIMEOUT_EXPIRED+    , gl_FLOAT_MAT4x2_NV+    , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES+    , gl_COMBINER1_NV+    , gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB+    , gl_RENDERBUFFER_SAMPLES_ANGLE+    , gl_VERTEX_ARRAY_SIZE+    , gl_TEXTURE2+    , gl_RELATIVE_MOVE_TO_NV+    , gl_ALPHA_TEST_FUNC_QCOM+    , gl_INNOCENT_CONTEXT_RESET_KHR+    , gl_MAP1_VERTEX_ATTRIB5_4_NV+    , gl_SAMPLER_1D_SHADOW+    , gl_TEXTURE_1D_ARRAY_EXT+    , gl_STENCIL_INDEX+    , gl_SOURCE2_ALPHA_EXT+    , gl_NORMAL_MAP_EXT+    , gl_FOG_COORDINATE_SOURCE_EXT+    , gl_TEXTURE_FILTER_CONTROL+    , gl_REPLACE_OLDEST_SUN+    , gl_PROGRAM_ADDRESS_REGISTERS_ARB+    , gl_2PASS_1_EXT+    , gl_LIGHT_ENV_MODE_SGIX+    , gl_OP_FRAC_EXT+    , gl_PROXY_TEXTURE_RECTANGLE_NV+    , gl_RENDERBUFFER+    , gl_MAP2_TEXTURE_COORD_4+    , gl_TEXTURE_BORDER_COLOR_EXT+    , gl_SEPARABLE_2D+    , gl_COMPRESSED_SRGB_S3TC_DXT1_EXT+    , gl_DRAW_BUFFER0_ATI+    , gl_TEXTURE_IMMUTABLE_LEVELS+    , gl_E_TIMES_F_NV+    , gl_MATRIX24_ARB+    , gl_PIXEL_GROUP_COLOR_SGIS+    , gl_CURRENT_RASTER_COLOR+    , gl_DOUBLE_MAT2x4_EXT+    , gl_BUMP_TEX_UNITS_ATI+    , gl_FOG_COORDINATE_ARRAY_EXT+    , gl_ALWAYS+    , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES+    , gl_MAP2_VERTEX_4+    , gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG+    , gl_MODULATE_SIGNED_ADD_ATI+    , gl_RG8+    , gl_ACTIVE_UNIFORM_BLOCKS+    , gl_MAX_SPARSE_TEXTURE_SIZE_AMD+    , gl_COLOR_ATTACHMENT11_EXT+    , gl_POST_CONVOLUTION_BLUE_BIAS_EXT+    , gl_BUFFER_OBJECT_APPLE+    , gl_UNIFORM_TYPE+    , gl_VARIABLE_E_NV+    , gl_MAX_COMPUTE_ATOMIC_COUNTERS+    , gl_COMPRESSED_RED_RGTC1+    , gl_LUMINANCE_INTEGER_EXT+    , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY+    , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE+    , gl_R16F_EXT+    , gl_MATRIX4_ARB+    , gl_MATRIX_INDEX_ARRAY_SIZE_OES+    , gl_POLYGON_STIPPLE+    , gl_DUAL_ALPHA12_SGIS+    , gl_PIXEL_MAP_I_TO_B+    , gl_VERTEX_ATTRIB_ARRAY6_NV+    , gl_REG_21_ATI+    , gl_PERFMON_RESULT_SIZE_AMD+    , gl_ALPHA8_OES+    , gl_OBJECT_BUFFER_USAGE_ATI+    , gl_PATH_STENCIL_FUNC_NV+    , gl_TEXTURE12_ARB+    , gl_DEPTH_COMPONENT16_OES+    , gl_MODELVIEW20_ARB+    , gl_ALPHA12+    , gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT+    , gl_MODULATE_ADD_ATI+    , gl_CLAMP_TO_BORDER_EXT+    , gl_CONSTANT_EXT+    , gl_OP_LOG_BASE_2_EXT+    , gl_SET_AMD+    , gl_ONE_MINUS_SRC_ALPHA+    , gl_COMPRESSED_LUMINANCE_ALPHA_ARB+    , gl_MAX_SERVER_WAIT_TIMEOUT_APPLE+    , gl_LINE_TOKEN+    , gl_PROXY_POST_CONVOLUTION_COLOR_TABLE+    , gl_TEXTURE_BINDING_3D+    , gl_INTENSITY16I_EXT+    , gl_DEPENDENT_AR_TEXTURE_2D_NV+    , gl_CURRENT_RASTER_NORMAL_SGIX+    , gl_TEXTURE_INTENSITY_TYPE+    , gl_TEXTURE_STORAGE_SPARSE_BIT_AMD+    , gl_RENDERBUFFER_INTERNAL_FORMAT_EXT+    , gl_VERTEX_ATTRIB_ARRAY1_NV+    , gl_TEXTURE_RED_SIZE+    , gl_CURRENT_COLOR+    , gl_COMPRESSED_RGBA_ASTC_8x5_KHR+    , gl_STENCIL_BUFFER_BIT7_QCOM+    , gl_CLIP_PLANE0_IMG+    , gl_ALPHA_TEST_REF+    , gl_POINT_SMOOTH+    , gl_WEIGHT_ARRAY_SIZE_OES+    , gl_DECODE_EXT+    , gl_SPARSE_BUFFER_PAGE_SIZE_ARB+    , gl_CLIENT_ATTRIB_STACK_DEPTH+    , gl_TEXTURE_BINDING_EXTERNAL_OES+    , gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT+    , gl_RENDERBUFFER_STENCIL_SIZE_OES+    , gl_POST_COLOR_MATRIX_ALPHA_BIAS+    , gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT+    , gl_HSL_LUMINOSITY_KHR+    , gl_MAX_VERTEX_STREAMS_ATI+    , gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL+    , gl_COMPRESSED_SIGNED_RED_RGTC1_EXT+    , gl_DEPTH_COMPONENT32_OES+    , gl_CON_3_ATI+    , gl_COMPRESSED_RGBA_S3TC_DXT1_EXT+    , gl_MATRIX6_ARB+    , gl_MAP2_VERTEX_ATTRIB5_4_NV+    , gl_LINE_WIDTH_RANGE+    , gl_GLYPH_VERTICAL_BEARING_X_BIT_NV+    , gl_FOG_COORDINATE_ARRAY+    , gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE+    , gl_CLAMP_FRAGMENT_COLOR+    , gl_COMPRESSED_RGBA_ASTC_10x5_KHR+    , gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB+    , gl_COLOR_BUFFER_BIT4_QCOM+    , gl_TEXTURE13+    , gl_MAX_DEBUG_MESSAGE_LENGTH_AMD+    , gl_EVAL_VERTEX_ATTRIB0_NV+    , gl_ALPHA_MIN_CLAMP_INGR+    , gl_SUB_ATI+    , gl_SECONDARY_COLOR_ARRAY_LIST_IBM+    , gl_RGBA_INTEGER_MODE_EXT+    , gl_DEBUG_TYPE_MARKER_KHR+    , gl_VERTEX_ATTRIB_ARRAY14_NV+    , gl_TEXTURE_MIN_LOD+    , gl_INDEX_TEST_REF_EXT+    , gl_AUX0+    , gl_UNSIGNED_INT_IMAGE_2D_RECT+    , gl_2_BYTES+    , gl_UNDEFINED_VERTEX+    , gl_LINE_STIPPLE_PATTERN+    , gl_FRAMEBUFFER_SRGB_CAPABLE_EXT+    , gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB+    , gl_UNSIGNED_INT_SAMPLER_1D_ARRAY+    , gl_LOAD+    , gl_SIGNED_ALPHA8_NV+    , gl_STENCIL_INDEX8_EXT+    , gl_VIEW_CLASS_24_BITS+    , gl_SHADER_STORAGE_BARRIER_BIT+    , gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD+    , gl_IMAGE_BINDING_LAYER+    , gl_MULTISAMPLE_FILTER_HINT_NV+    , gl_SPARE1_NV+    , gl_MAP_READ_BIT_EXT+    , gl_COMPRESSED_LUMINANCE+    , gl_COMPRESSED_TEXTURE_FORMATS+    , gl_UNIFORM_IS_ROW_MAJOR+    , gl_OFFSET_TEXTURE_2D_SCALE_NV+    , gl_RGBA_DXT5_S3TC+    , gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB+    , gl_MAX_UNIFORM_BUFFER_BINDINGS+    , gl_RGB16UI_EXT+    , gl_TEXTURE_COMPARE_OPERATOR_SGIX+    , gl_VIDEO_BUFFER_PITCH_NV+    , gl_RELATIVE_RECT_NV+    , gl_DRAW_BUFFER8_ATI+    , gl_SRC_COLOR+    , gl_SHADER_OBJECT_EXT+    , gl_GUILTY_CONTEXT_RESET_KHR+    , gl_EVAL_VERTEX_ATTRIB5_NV+    , gl_PALETTE4_RGBA4_OES+    , gl_LUMINANCE12_EXT+    , gl_DONT_CARE+    , gl_TEXTURE_BUFFER+    , gl_COMPRESSED_RGBA_ASTC_4x4x4_OES+    , gl_TEXTURE_BINDING_1D_ARRAY+    , gl_SEPARATE_SPECULAR_COLOR+    , gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED+    , gl_NORMAL_ARRAY_LIST_IBM+    , gl_CURRENT_MATRIX_STACK_DEPTH_NV+    , gl_INT_IMAGE_3D+    , gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV+    , gl_CONTEXT_FLAG_DEBUG_BIT+    , gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB+    , gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX+    , gl_VECTOR_EXT+    , gl_TEXTURE_BUFFER_DATA_STORE_BINDING+    , gl_TEXTURE_LOD_BIAS+    , gl_GEOMETRY_SHADER_EXT+    , gl_TEXTURE30+    , gl_VERTEX_SHADER_BIT+    , gl_HISTOGRAM_BLUE_SIZE_EXT+    , gl_PATH_COMMAND_COUNT_NV+    , gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV+    , gl_STENCIL_TAG_BITS_EXT+    , gl_MAX_PROGRAM_LOOP_DEPTH_NV+    , gl_FLOAT_MAT2x3_NV+    , gl_CURRENT_RASTER_DISTANCE+    , gl_COMPRESSED_SRGB8_ETC2_OES+    , gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES+    , gl_PIXEL_MAP_I_TO_G_SIZE+    , gl_COMBINE+    , gl_FOG_HINT+    , gl_COMPUTE_SUBROUTINE_UNIFORM+    , gl_FRAGMENT_LIGHT3_SGIX+    , gl_DEBUG_TYPE_PORTABILITY_ARB+    , gl_MIN_PROGRAM_TEXEL_OFFSET_EXT+    , gl_TRANSFORM_FEEDBACK_BUFFER_NV+    , gl_UNKNOWN_CONTEXT_RESET_EXT+    , gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB+    , gl_UNSIGNED_INT_24_8_NV+    , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY+    , gl_MANUAL_GENERATE_MIPMAP+    , gl_MAP2_VERTEX_ATTRIB6_4_NV+    , gl_FRAMEBUFFER_EXT+    , gl_INT16_NV+    , gl_FULL_RANGE_EXT+    , gl_MAP1_VERTEX_ATTRIB2_4_NV+    , gl_UNSIGNED_INT_8_8_8_8_EXT+    , gl_TESS_CONTROL_SUBROUTINE_UNIFORM+    , gl_PREVIOUS_TEXTURE_INPUT_NV+    , gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE+    , gl_SYNC_STATUS_APPLE+    , gl_4PASS_0_EXT+    , gl_POLYGON_SMOOTH+    , gl_FEEDBACK_BUFFER_SIZE+    , gl_COLORBURN_KHR+    , gl_DEPTH24_STENCIL8+    , gl_LINEAR_CLIPMAP_LINEAR_SGIX+    , gl_TEXTURE_MAX_LEVEL+    , gl_TEXTURE_WRAP_R_EXT+    , gl_OBJECT_SUBTYPE_ARB+    , gl_MATRIX18_ARB+    , gl_MATRIX_INDEX_ARRAY_POINTER_OES+    , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB+    , gl_ALPHA8_SNORM+    , gl_TESS_CONTROL_SUBROUTINE+    , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB+    , gl_POST_CONVOLUTION_ALPHA_SCALE_EXT+    , gl_RGB5_A1_EXT+    , gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS+    , gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM+    , gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV+    , gl_TEXTURE21_ARB+    , gl_SAMPLER_2D_RECT_SHADOW+    , gl_DEPTH_STENCIL_TEXTURE_MODE+    , gl_MAP1_VERTEX_ATTRIB10_4_NV+    , gl_PINLIGHT_NV+    , gl_TEXTURE_INTERNAL_FORMAT+    , gl_VERTEX_ARRAY_OBJECT_AMD+    , gl_OBJECT_LINEAR+    , gl_TEXTURE_IMMUTABLE_FORMAT_EXT+    , gl_COMBINER_COMPONENT_USAGE_NV+    , gl_RENDERBUFFER_GREEN_SIZE_EXT+    , gl_CONVOLUTION_FILTER_SCALE+    , gl_TEXTURE11+    , gl_BITMAP+    , gl_VIEW_COMPATIBILITY_CLASS+    , gl_TEXTURE26+    , gl_UNSIGNED_INT8_VEC4_NV+    , gl_UNSIGNED_INT_VEC3+    , gl_VERTEX_PRECLIP_SGIX+    , gl_PACK_LSB_FIRST+    , gl_NEGATIVE_Y_EXT+    , gl_FRAMEBUFFER_BINDING_ANGLE+    , gl_MAP_INVALIDATE_BUFFER_BIT_EXT+    , gl_NO_RESET_NOTIFICATION+    , gl_MINMAX_EXT+    , gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST+    , gl_QUARTER_BIT_ATI+    , gl_TEXTURE9+    , gl_FLOAT_R16_NV+    , gl_BLEND_ADVANCED_COHERENT_KHR+    , gl_MATRIX_INDEX_ARRAY_POINTER_ARB+    , gl_PROXY_TEXTURE_1D_EXT+    , gl_PERTURB_EXT+    , gl_IUI_N3F_V3F_EXT+    , gl_COMBINE_RGB_ARB+    , gl_DEBUG_SOURCE_APPLICATION_KHR+    , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS+    , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE+    , gl_PROGRAM_ALU_INSTRUCTIONS_ARB+    , gl_VERTEX_STREAM0_ATI+    , gl_EDGE_FLAG_ARRAY_POINTER_EXT+    , gl_INT_IMAGE_2D_EXT+    , gl_READ_FRAMEBUFFER_BINDING_EXT+    , gl_TEXTURE_CUBE_MAP_ARB+    , gl_LUMINANCE12_ALPHA12+    , gl_FUNC_ADD+    , gl_TRANSPOSE_COLOR_MATRIX_ARB+    , gl_COLOR_ATTACHMENT6+    , gl_GEOMETRY_SUBROUTINE+    , gl_MAX_ELEMENT_INDEX+    , gl_QUERY_OBJECT_AMD+    , gl_TEXTURE_CUBE_MAP_EXT+    , gl_CONSTANT_ATTENUATION+    , gl_LUMINANCE_FLOAT32_APPLE+    , gl_R32UI+    , gl_UNSIGNED_INT_VEC4_EXT+    , gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT+    , gl_SAMPLE_MASK_VALUE+    , gl_STRICT_DEPTHFUNC_HINT_PGI+    , gl_CONVOLUTION_HEIGHT_EXT+    , gl_DEPTH_BUFFER_BIT1_QCOM+    , gl_CLIP_DISTANCE_NV+    , gl_DISPATCH_INDIRECT_BUFFER+    , gl_LUMINANCE4+    , gl_CLAMP+    , gl_CONVOLUTION_FORMAT+    , gl_IMAGE_2D_MULTISAMPLE+    , gl_TRIANGLE_STRIP+    , gl_BGRA_INTEGER_EXT+    , gl_FRAGMENTS_INSTRUMENT_MAX_SGIX+    , gl_TESS_CONTROL_SHADER_BIT+    , gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES+    , gl_BACK_NORMALS_HINT_PGI+    , gl_FOG_COORD_ARRAY+    , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR+    , gl_OPERAND1_RGB_EXT+    , gl_LINEAR_SHARPEN_COLOR_SGIS+    , gl_POST_TEXTURE_FILTER_SCALE_SGIX+    , gl_FRAMEBUFFER_COMPLETE_OES+    , gl_SYNC_OBJECT_APPLE+    , gl_INDEX_WRITEMASK+    , gl_SIGNED_INTENSITY_NV+    , gl_SGX_PROGRAM_BINARY_IMG+    , gl_T4F_V4F+    , GLsync+    , GLsyncob()+    , GLhalf+    , GLhalfARB+    , GLintptrARB+    , GLsizeiptrARB+    , GLDEBUGPROC+    , GLDEBUGPROCARB+    , GLDEBUGPROCKHR+    , GLDEBUGPROCAMD+    , GLbyte+    , GLubyte+    , GLfloat+    , GLclampf+    , GLfixed+    , GLint64+    , GLuint64+    , GLint64EXT+    , GLuint64EXT+    , GLintptr+    , GLsizeiptr+    , GLhalfNV+    , GLvdpauSurfaceNV+    , GLenum+    , GLboolean+    , GLvoid+    , GLbitfield+    , GLshort+    , GLint+    , GLclampx+    , GLushort+    , GLuint+    , GLsizei+    , GLdouble+    , GLclampd+    , GLeglImageOESob()+    , GLeglImageOES+    , GLchar+    , GLcharARB+    , GLhandleARB+    )+    where++import Data.Typeable+import Data.IORef+import Data.Int+import Data.Word+import System.IO.Unsafe+import Control.Applicative+import Control.Exception+import Control.Monad+import Control.Monad.IO.Class+import Control.Monad.Trans.Except+import Foreign.C.Types+import Foreign.Ptr++#ifdef mingw32_HOST_OS+#define APIENTRY stdcall+#else+#define APIENTRY+#endif++data FlextInitResult = Failure { why :: String }+                     | Success+                     deriving ( Eq, Ord, Show, Read )++#ifdef __GLASGOW_HASKELL__+deriving instance Typeable FlextInitResult+instance Exception FlextInitResult+#endif++proc :: Either a a -> a+proc (Left x) = x+proc (Right x) = x++-- | Initializes OpenGL entry points in the current OpenGL context.+flextInit :: (String -> IO (Ptr ()))+          -> (String -> IO Bool)+          -> IO FlextInitResult+flextInit get_proc_address is_supported = fmap proc $ runExceptT $ do+    -- GL_VERSION_1_0++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCullFace"+        writeIORef glrefCullFace $ gldynCullFace addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFrontFace"+        writeIORef glrefFrontFace $ gldynFrontFace addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glHint"+        writeIORef glrefHint $ gldynHint addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLineWidth"+        writeIORef glrefLineWidth $ gldynLineWidth addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointSize"+        writeIORef glrefPointSize $ gldynPointSize addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPolygonMode"+        writeIORef glrefPolygonMode $ gldynPolygonMode addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glScissor"+        writeIORef glrefScissor $ gldynScissor addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterf"+        writeIORef glrefTexParameterf $ gldynTexParameterf addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterfv"+        writeIORef glrefTexParameterfv $ gldynTexParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameteri"+        writeIORef glrefTexParameteri $ gldynTexParameteri addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameteriv"+        writeIORef glrefTexParameteriv $ gldynTexParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage1D"+        writeIORef glrefTexImage1D $ gldynTexImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage2D"+        writeIORef glrefTexImage2D $ gldynTexImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawBuffer"+        writeIORef glrefDrawBuffer $ gldynDrawBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClear"+        writeIORef glrefClear $ gldynClear addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearColor"+        writeIORef glrefClearColor $ gldynClearColor addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearStencil"+        writeIORef glrefClearStencil $ gldynClearStencil addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearDepth"+        writeIORef glrefClearDepth $ gldynClearDepth addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilMask"+        writeIORef glrefStencilMask $ gldynStencilMask addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glColorMask"+        writeIORef glrefColorMask $ gldynColorMask addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthMask"+        writeIORef glrefDepthMask $ gldynDepthMask addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisable"+        writeIORef glrefDisable $ gldynDisable addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnable"+        writeIORef glrefEnable $ gldynEnable addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFinish"+        writeIORef glrefFinish $ gldynFinish addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlush"+        writeIORef glrefFlush $ gldynFlush addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendFunc"+        writeIORef glrefBlendFunc $ gldynBlendFunc addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLogicOp"+        writeIORef glrefLogicOp $ gldynLogicOp addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilFunc"+        writeIORef glrefStencilFunc $ gldynStencilFunc addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilOp"+        writeIORef glrefStencilOp $ gldynStencilOp addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthFunc"+        writeIORef glrefDepthFunc $ gldynDepthFunc addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPixelStoref"+        writeIORef glrefPixelStoref $ gldynPixelStoref addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPixelStorei"+        writeIORef glrefPixelStorei $ gldynPixelStorei addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glReadBuffer"+        writeIORef glrefReadBuffer $ gldynReadBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glReadPixels"+        writeIORef glrefReadPixels $ gldynReadPixels addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleanv"+        writeIORef glrefGetBooleanv $ gldynGetBooleanv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoublev"+        writeIORef glrefGetDoublev $ gldynGetDoublev addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetError"+        writeIORef glrefGetError $ gldynGetError addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloatv"+        writeIORef glrefGetFloatv $ gldynGetFloatv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegerv"+        writeIORef glrefGetIntegerv $ gldynGetIntegerv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetString"+        writeIORef glrefGetString $ gldynGetString addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexImage"+        writeIORef glrefGetTexImage $ gldynGetTexImage addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterfv"+        writeIORef glrefGetTexParameterfv $ gldynGetTexParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameteriv"+        writeIORef glrefGetTexParameteriv $ gldynGetTexParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexLevelParameterfv"+        writeIORef glrefGetTexLevelParameterfv $ gldynGetTexLevelParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexLevelParameteriv"+        writeIORef glrefGetTexLevelParameteriv $ gldynGetTexLevelParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabled"+        writeIORef glrefIsEnabled $ gldynIsEnabled addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthRange"+        writeIORef glrefDepthRange $ gldynDepthRange addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glViewport"+        writeIORef glrefViewport $ gldynViewport addr++    -- GL_VERSION_1_1++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawArrays"+        writeIORef glrefDrawArrays $ gldynDrawArrays addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElements"+        writeIORef glrefDrawElements $ gldynDrawElements addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPolygonOffset"+        writeIORef glrefPolygonOffset $ gldynPolygonOffset addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexImage1D"+        writeIORef glrefCopyTexImage1D $ gldynCopyTexImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexImage2D"+        writeIORef glrefCopyTexImage2D $ gldynCopyTexImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage1D"+        writeIORef glrefCopyTexSubImage1D $ gldynCopyTexSubImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage2D"+        writeIORef glrefCopyTexSubImage2D $ gldynCopyTexSubImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage1D"+        writeIORef glrefTexSubImage1D $ gldynTexSubImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage2D"+        writeIORef glrefTexSubImage2D $ gldynTexSubImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindTexture"+        writeIORef glrefBindTexture $ gldynBindTexture addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteTextures"+        writeIORef glrefDeleteTextures $ gldynDeleteTextures addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenTextures"+        writeIORef glrefGenTextures $ gldynGenTextures addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsTexture"+        writeIORef glrefIsTexture $ gldynIsTexture addr++    -- GL_VERSION_1_2++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawRangeElements"+        writeIORef glrefDrawRangeElements $ gldynDrawRangeElements addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage3D"+        writeIORef glrefTexImage3D $ gldynTexImage3D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage3D"+        writeIORef glrefTexSubImage3D $ gldynTexSubImage3D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage3D"+        writeIORef glrefCopyTexSubImage3D $ gldynCopyTexSubImage3D addr++    -- GL_VERSION_1_3++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glActiveTexture"+        writeIORef glrefActiveTexture $ gldynActiveTexture addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSampleCoverage"+        writeIORef glrefSampleCoverage $ gldynSampleCoverage addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage3D"+        writeIORef glrefCompressedTexImage3D $ gldynCompressedTexImage3D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage2D"+        writeIORef glrefCompressedTexImage2D $ gldynCompressedTexImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage1D"+        writeIORef glrefCompressedTexImage1D $ gldynCompressedTexImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage3D"+        writeIORef glrefCompressedTexSubImage3D $ gldynCompressedTexSubImage3D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage2D"+        writeIORef glrefCompressedTexSubImage2D $ gldynCompressedTexSubImage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage1D"+        writeIORef glrefCompressedTexSubImage1D $ gldynCompressedTexSubImage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedTexImage"+        writeIORef glrefGetCompressedTexImage $ gldynGetCompressedTexImage addr++    -- GL_VERSION_1_4++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendFuncSeparate"+        writeIORef glrefBlendFuncSeparate $ gldynBlendFuncSeparate addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawArrays"+        writeIORef glrefMultiDrawArrays $ gldynMultiDrawArrays addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawElements"+        writeIORef glrefMultiDrawElements $ gldynMultiDrawElements addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameterf"+        writeIORef glrefPointParameterf $ gldynPointParameterf addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameterfv"+        writeIORef glrefPointParameterfv $ gldynPointParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameteri"+        writeIORef glrefPointParameteri $ gldynPointParameteri addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameteriv"+        writeIORef glrefPointParameteriv $ gldynPointParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendColor"+        writeIORef glrefBlendColor $ gldynBlendColor addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendEquation"+        writeIORef glrefBlendEquation $ gldynBlendEquation addr++    -- GL_VERSION_1_5++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenQueries"+        writeIORef glrefGenQueries $ gldynGenQueries addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteQueries"+        writeIORef glrefDeleteQueries $ gldynDeleteQueries addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsQuery"+        writeIORef glrefIsQuery $ gldynIsQuery addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginQuery"+        writeIORef glrefBeginQuery $ gldynBeginQuery addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndQuery"+        writeIORef glrefEndQuery $ gldynEndQuery addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryiv"+        writeIORef glrefGetQueryiv $ gldynGetQueryiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectiv"+        writeIORef glrefGetQueryObjectiv $ gldynGetQueryObjectiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectuiv"+        writeIORef glrefGetQueryObjectuiv $ gldynGetQueryObjectuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBuffer"+        writeIORef glrefBindBuffer $ gldynBindBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteBuffers"+        writeIORef glrefDeleteBuffers $ gldynDeleteBuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenBuffers"+        writeIORef glrefGenBuffers $ gldynGenBuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsBuffer"+        writeIORef glrefIsBuffer $ gldynIsBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferData"+        writeIORef glrefBufferData $ gldynBufferData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferSubData"+        writeIORef glrefBufferSubData $ gldynBufferSubData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferSubData"+        writeIORef glrefGetBufferSubData $ gldynGetBufferSubData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapBuffer"+        writeIORef glrefMapBuffer $ gldynMapBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUnmapBuffer"+        writeIORef glrefUnmapBuffer $ gldynUnmapBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferParameteriv"+        writeIORef glrefGetBufferParameteriv $ gldynGetBufferParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferPointerv"+        writeIORef glrefGetBufferPointerv $ gldynGetBufferPointerv addr++    -- GL_VERSION_2_0++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendEquationSeparate"+        writeIORef glrefBlendEquationSeparate $ gldynBlendEquationSeparate addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawBuffers"+        writeIORef glrefDrawBuffers $ gldynDrawBuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilOpSeparate"+        writeIORef glrefStencilOpSeparate $ gldynStencilOpSeparate addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilFuncSeparate"+        writeIORef glrefStencilFuncSeparate $ gldynStencilFuncSeparate addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilMaskSeparate"+        writeIORef glrefStencilMaskSeparate $ gldynStencilMaskSeparate addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glAttachShader"+        writeIORef glrefAttachShader $ gldynAttachShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindAttribLocation"+        writeIORef glrefBindAttribLocation $ gldynBindAttribLocation addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompileShader"+        writeIORef glrefCompileShader $ gldynCompileShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateProgram"+        writeIORef glrefCreateProgram $ gldynCreateProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateShader"+        writeIORef glrefCreateShader $ gldynCreateShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteProgram"+        writeIORef glrefDeleteProgram $ gldynDeleteProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteShader"+        writeIORef glrefDeleteShader $ gldynDeleteShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDetachShader"+        writeIORef glrefDetachShader $ gldynDetachShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexAttribArray"+        writeIORef glrefDisableVertexAttribArray $ gldynDisableVertexAttribArray addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexAttribArray"+        writeIORef glrefEnableVertexAttribArray $ gldynEnableVertexAttribArray addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveAttrib"+        writeIORef glrefGetActiveAttrib $ gldynGetActiveAttrib addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniform"+        writeIORef glrefGetActiveUniform $ gldynGetActiveUniform addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetAttachedShaders"+        writeIORef glrefGetAttachedShaders $ gldynGetAttachedShaders addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetAttribLocation"+        writeIORef glrefGetAttribLocation $ gldynGetAttribLocation addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramiv"+        writeIORef glrefGetProgramiv $ gldynGetProgramiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramInfoLog"+        writeIORef glrefGetProgramInfoLog $ gldynGetProgramInfoLog addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderiv"+        writeIORef glrefGetShaderiv $ gldynGetShaderiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderInfoLog"+        writeIORef glrefGetShaderInfoLog $ gldynGetShaderInfoLog addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderSource"+        writeIORef glrefGetShaderSource $ gldynGetShaderSource addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformLocation"+        writeIORef glrefGetUniformLocation $ gldynGetUniformLocation addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformfv"+        writeIORef glrefGetUniformfv $ gldynGetUniformfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformiv"+        writeIORef glrefGetUniformiv $ gldynGetUniformiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribdv"+        writeIORef glrefGetVertexAttribdv $ gldynGetVertexAttribdv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribfv"+        writeIORef glrefGetVertexAttribfv $ gldynGetVertexAttribfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribiv"+        writeIORef glrefGetVertexAttribiv $ gldynGetVertexAttribiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribPointerv"+        writeIORef glrefGetVertexAttribPointerv $ gldynGetVertexAttribPointerv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsProgram"+        writeIORef glrefIsProgram $ gldynIsProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsShader"+        writeIORef glrefIsShader $ gldynIsShader addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLinkProgram"+        writeIORef glrefLinkProgram $ gldynLinkProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glShaderSource"+        writeIORef glrefShaderSource $ gldynShaderSource addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUseProgram"+        writeIORef glrefUseProgram $ gldynUseProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1f"+        writeIORef glrefUniform1f $ gldynUniform1f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2f"+        writeIORef glrefUniform2f $ gldynUniform2f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3f"+        writeIORef glrefUniform3f $ gldynUniform3f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4f"+        writeIORef glrefUniform4f $ gldynUniform4f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1i"+        writeIORef glrefUniform1i $ gldynUniform1i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2i"+        writeIORef glrefUniform2i $ gldynUniform2i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3i"+        writeIORef glrefUniform3i $ gldynUniform3i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4i"+        writeIORef glrefUniform4i $ gldynUniform4i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1fv"+        writeIORef glrefUniform1fv $ gldynUniform1fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2fv"+        writeIORef glrefUniform2fv $ gldynUniform2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3fv"+        writeIORef glrefUniform3fv $ gldynUniform3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4fv"+        writeIORef glrefUniform4fv $ gldynUniform4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1iv"+        writeIORef glrefUniform1iv $ gldynUniform1iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2iv"+        writeIORef glrefUniform2iv $ gldynUniform2iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3iv"+        writeIORef glrefUniform3iv $ gldynUniform3iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4iv"+        writeIORef glrefUniform4iv $ gldynUniform4iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2fv"+        writeIORef glrefUniformMatrix2fv $ gldynUniformMatrix2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3fv"+        writeIORef glrefUniformMatrix3fv $ gldynUniformMatrix3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4fv"+        writeIORef glrefUniformMatrix4fv $ gldynUniformMatrix4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glValidateProgram"+        writeIORef glrefValidateProgram $ gldynValidateProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1d"+        writeIORef glrefVertexAttrib1d $ gldynVertexAttrib1d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1dv"+        writeIORef glrefVertexAttrib1dv $ gldynVertexAttrib1dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1f"+        writeIORef glrefVertexAttrib1f $ gldynVertexAttrib1f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1fv"+        writeIORef glrefVertexAttrib1fv $ gldynVertexAttrib1fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1s"+        writeIORef glrefVertexAttrib1s $ gldynVertexAttrib1s addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1sv"+        writeIORef glrefVertexAttrib1sv $ gldynVertexAttrib1sv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2d"+        writeIORef glrefVertexAttrib2d $ gldynVertexAttrib2d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2dv"+        writeIORef glrefVertexAttrib2dv $ gldynVertexAttrib2dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2f"+        writeIORef glrefVertexAttrib2f $ gldynVertexAttrib2f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2fv"+        writeIORef glrefVertexAttrib2fv $ gldynVertexAttrib2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2s"+        writeIORef glrefVertexAttrib2s $ gldynVertexAttrib2s addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2sv"+        writeIORef glrefVertexAttrib2sv $ gldynVertexAttrib2sv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3d"+        writeIORef glrefVertexAttrib3d $ gldynVertexAttrib3d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3dv"+        writeIORef glrefVertexAttrib3dv $ gldynVertexAttrib3dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3f"+        writeIORef glrefVertexAttrib3f $ gldynVertexAttrib3f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3fv"+        writeIORef glrefVertexAttrib3fv $ gldynVertexAttrib3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3s"+        writeIORef glrefVertexAttrib3s $ gldynVertexAttrib3s addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3sv"+        writeIORef glrefVertexAttrib3sv $ gldynVertexAttrib3sv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nbv"+        writeIORef glrefVertexAttrib4Nbv $ gldynVertexAttrib4Nbv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Niv"+        writeIORef glrefVertexAttrib4Niv $ gldynVertexAttrib4Niv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nsv"+        writeIORef glrefVertexAttrib4Nsv $ gldynVertexAttrib4Nsv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nub"+        writeIORef glrefVertexAttrib4Nub $ gldynVertexAttrib4Nub addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nubv"+        writeIORef glrefVertexAttrib4Nubv $ gldynVertexAttrib4Nubv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nuiv"+        writeIORef glrefVertexAttrib4Nuiv $ gldynVertexAttrib4Nuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nusv"+        writeIORef glrefVertexAttrib4Nusv $ gldynVertexAttrib4Nusv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4bv"+        writeIORef glrefVertexAttrib4bv $ gldynVertexAttrib4bv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4d"+        writeIORef glrefVertexAttrib4d $ gldynVertexAttrib4d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4dv"+        writeIORef glrefVertexAttrib4dv $ gldynVertexAttrib4dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4f"+        writeIORef glrefVertexAttrib4f $ gldynVertexAttrib4f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4fv"+        writeIORef glrefVertexAttrib4fv $ gldynVertexAttrib4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4iv"+        writeIORef glrefVertexAttrib4iv $ gldynVertexAttrib4iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4s"+        writeIORef glrefVertexAttrib4s $ gldynVertexAttrib4s addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4sv"+        writeIORef glrefVertexAttrib4sv $ gldynVertexAttrib4sv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4ubv"+        writeIORef glrefVertexAttrib4ubv $ gldynVertexAttrib4ubv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4uiv"+        writeIORef glrefVertexAttrib4uiv $ gldynVertexAttrib4uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4usv"+        writeIORef glrefVertexAttrib4usv $ gldynVertexAttrib4usv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribPointer"+        writeIORef glrefVertexAttribPointer $ gldynVertexAttribPointer addr++    -- GL_VERSION_2_1++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2x3fv"+        writeIORef glrefUniformMatrix2x3fv $ gldynUniformMatrix2x3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3x2fv"+        writeIORef glrefUniformMatrix3x2fv $ gldynUniformMatrix3x2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2x4fv"+        writeIORef glrefUniformMatrix2x4fv $ gldynUniformMatrix2x4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4x2fv"+        writeIORef glrefUniformMatrix4x2fv $ gldynUniformMatrix4x2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3x4fv"+        writeIORef glrefUniformMatrix3x4fv $ gldynUniformMatrix3x4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4x3fv"+        writeIORef glrefUniformMatrix4x3fv $ gldynUniformMatrix4x3fv addr++    -- GL_VERSION_3_0++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glColorMaski"+        writeIORef glrefColorMaski $ gldynColorMaski addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleani_v"+        writeIORef glrefGetBooleani_v $ gldynGetBooleani_v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegeri_v"+        writeIORef glrefGetIntegeri_v $ gldynGetIntegeri_v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnablei"+        writeIORef glrefEnablei $ gldynEnablei addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisablei"+        writeIORef glrefDisablei $ gldynDisablei addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabledi"+        writeIORef glrefIsEnabledi $ gldynIsEnabledi addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginTransformFeedback"+        writeIORef glrefBeginTransformFeedback $ gldynBeginTransformFeedback addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndTransformFeedback"+        writeIORef glrefEndTransformFeedback $ gldynEndTransformFeedback addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBufferRange"+        writeIORef glrefBindBufferRange $ gldynBindBufferRange addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBufferBase"+        writeIORef glrefBindBufferBase $ gldynBindBufferBase addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTransformFeedbackVaryings"+        writeIORef glrefTransformFeedbackVaryings $ gldynTransformFeedbackVaryings addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTransformFeedbackVarying"+        writeIORef glrefGetTransformFeedbackVarying $ gldynGetTransformFeedbackVarying addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClampColor"+        writeIORef glrefClampColor $ gldynClampColor addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginConditionalRender"+        writeIORef glrefBeginConditionalRender $ gldynBeginConditionalRender addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndConditionalRender"+        writeIORef glrefEndConditionalRender $ gldynEndConditionalRender addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribIPointer"+        writeIORef glrefVertexAttribIPointer $ gldynVertexAttribIPointer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribIiv"+        writeIORef glrefGetVertexAttribIiv $ gldynGetVertexAttribIiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribIuiv"+        writeIORef glrefGetVertexAttribIuiv $ gldynGetVertexAttribIuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1i"+        writeIORef glrefVertexAttribI1i $ gldynVertexAttribI1i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2i"+        writeIORef glrefVertexAttribI2i $ gldynVertexAttribI2i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3i"+        writeIORef glrefVertexAttribI3i $ gldynVertexAttribI3i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4i"+        writeIORef glrefVertexAttribI4i $ gldynVertexAttribI4i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1ui"+        writeIORef glrefVertexAttribI1ui $ gldynVertexAttribI1ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2ui"+        writeIORef glrefVertexAttribI2ui $ gldynVertexAttribI2ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3ui"+        writeIORef glrefVertexAttribI3ui $ gldynVertexAttribI3ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4ui"+        writeIORef glrefVertexAttribI4ui $ gldynVertexAttribI4ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1iv"+        writeIORef glrefVertexAttribI1iv $ gldynVertexAttribI1iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2iv"+        writeIORef glrefVertexAttribI2iv $ gldynVertexAttribI2iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3iv"+        writeIORef glrefVertexAttribI3iv $ gldynVertexAttribI3iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4iv"+        writeIORef glrefVertexAttribI4iv $ gldynVertexAttribI4iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1uiv"+        writeIORef glrefVertexAttribI1uiv $ gldynVertexAttribI1uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2uiv"+        writeIORef glrefVertexAttribI2uiv $ gldynVertexAttribI2uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3uiv"+        writeIORef glrefVertexAttribI3uiv $ gldynVertexAttribI3uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4uiv"+        writeIORef glrefVertexAttribI4uiv $ gldynVertexAttribI4uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4bv"+        writeIORef glrefVertexAttribI4bv $ gldynVertexAttribI4bv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4sv"+        writeIORef glrefVertexAttribI4sv $ gldynVertexAttribI4sv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4ubv"+        writeIORef glrefVertexAttribI4ubv $ gldynVertexAttribI4ubv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4usv"+        writeIORef glrefVertexAttribI4usv $ gldynVertexAttribI4usv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformuiv"+        writeIORef glrefGetUniformuiv $ gldynGetUniformuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFragDataLocation"+        writeIORef glrefBindFragDataLocation $ gldynBindFragDataLocation addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFragDataLocation"+        writeIORef glrefGetFragDataLocation $ gldynGetFragDataLocation addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1ui"+        writeIORef glrefUniform1ui $ gldynUniform1ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2ui"+        writeIORef glrefUniform2ui $ gldynUniform2ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3ui"+        writeIORef glrefUniform3ui $ gldynUniform3ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4ui"+        writeIORef glrefUniform4ui $ gldynUniform4ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1uiv"+        writeIORef glrefUniform1uiv $ gldynUniform1uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2uiv"+        writeIORef glrefUniform2uiv $ gldynUniform2uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3uiv"+        writeIORef glrefUniform3uiv $ gldynUniform3uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4uiv"+        writeIORef glrefUniform4uiv $ gldynUniform4uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterIiv"+        writeIORef glrefTexParameterIiv $ gldynTexParameterIiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterIuiv"+        writeIORef glrefTexParameterIuiv $ gldynTexParameterIuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterIiv"+        writeIORef glrefGetTexParameterIiv $ gldynGetTexParameterIiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterIuiv"+        writeIORef glrefGetTexParameterIuiv $ gldynGetTexParameterIuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferiv"+        writeIORef glrefClearBufferiv $ gldynClearBufferiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferuiv"+        writeIORef glrefClearBufferuiv $ gldynClearBufferuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferfv"+        writeIORef glrefClearBufferfv $ gldynClearBufferfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferfi"+        writeIORef glrefClearBufferfi $ gldynClearBufferfi addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetStringi"+        writeIORef glrefGetStringi $ gldynGetStringi addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsRenderbuffer"+        writeIORef glrefIsRenderbuffer $ gldynIsRenderbuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindRenderbuffer"+        writeIORef glrefBindRenderbuffer $ gldynBindRenderbuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteRenderbuffers"+        writeIORef glrefDeleteRenderbuffers $ gldynDeleteRenderbuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenRenderbuffers"+        writeIORef glrefGenRenderbuffers $ gldynGenRenderbuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glRenderbufferStorage"+        writeIORef glrefRenderbufferStorage $ gldynRenderbufferStorage addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetRenderbufferParameteriv"+        writeIORef glrefGetRenderbufferParameteriv $ gldynGetRenderbufferParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsFramebuffer"+        writeIORef glrefIsFramebuffer $ gldynIsFramebuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFramebuffer"+        writeIORef glrefBindFramebuffer $ gldynBindFramebuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteFramebuffers"+        writeIORef glrefDeleteFramebuffers $ gldynDeleteFramebuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenFramebuffers"+        writeIORef glrefGenFramebuffers $ gldynGenFramebuffers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCheckFramebufferStatus"+        writeIORef glrefCheckFramebufferStatus $ gldynCheckFramebufferStatus addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture1D"+        writeIORef glrefFramebufferTexture1D $ gldynFramebufferTexture1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture2D"+        writeIORef glrefFramebufferTexture2D $ gldynFramebufferTexture2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture3D"+        writeIORef glrefFramebufferTexture3D $ gldynFramebufferTexture3D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferRenderbuffer"+        writeIORef glrefFramebufferRenderbuffer $ gldynFramebufferRenderbuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFramebufferAttachmentParameteriv"+        writeIORef glrefGetFramebufferAttachmentParameteriv $ gldynGetFramebufferAttachmentParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateMipmap"+        writeIORef glrefGenerateMipmap $ gldynGenerateMipmap addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlitFramebuffer"+        writeIORef glrefBlitFramebuffer $ gldynBlitFramebuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glRenderbufferStorageMultisample"+        writeIORef glrefRenderbufferStorageMultisample $ gldynRenderbufferStorageMultisample addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTextureLayer"+        writeIORef glrefFramebufferTextureLayer $ gldynFramebufferTextureLayer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapBufferRange"+        writeIORef glrefMapBufferRange $ gldynMapBufferRange addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlushMappedBufferRange"+        writeIORef glrefFlushMappedBufferRange $ gldynFlushMappedBufferRange addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindVertexArray"+        writeIORef glrefBindVertexArray $ gldynBindVertexArray addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteVertexArrays"+        writeIORef glrefDeleteVertexArrays $ gldynDeleteVertexArrays addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenVertexArrays"+        writeIORef glrefGenVertexArrays $ gldynGenVertexArrays addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsVertexArray"+        writeIORef glrefIsVertexArray $ gldynIsVertexArray addr++    -- GL_VERSION_3_1++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawArraysInstanced"+        writeIORef glrefDrawArraysInstanced $ gldynDrawArraysInstanced addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsInstanced"+        writeIORef glrefDrawElementsInstanced $ gldynDrawElementsInstanced addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexBuffer"+        writeIORef glrefTexBuffer $ gldynTexBuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPrimitiveRestartIndex"+        writeIORef glrefPrimitiveRestartIndex $ gldynPrimitiveRestartIndex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyBufferSubData"+        writeIORef glrefCopyBufferSubData $ gldynCopyBufferSubData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformIndices"+        writeIORef glrefGetUniformIndices $ gldynGetUniformIndices addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformsiv"+        writeIORef glrefGetActiveUniformsiv $ gldynGetActiveUniformsiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformName"+        writeIORef glrefGetActiveUniformName $ gldynGetActiveUniformName addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformBlockIndex"+        writeIORef glrefGetUniformBlockIndex $ gldynGetUniformBlockIndex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformBlockiv"+        writeIORef glrefGetActiveUniformBlockiv $ gldynGetActiveUniformBlockiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformBlockName"+        writeIORef glrefGetActiveUniformBlockName $ gldynGetActiveUniformBlockName addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformBlockBinding"+        writeIORef glrefUniformBlockBinding $ gldynUniformBlockBinding addr++    -- GL_VERSION_3_2++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsBaseVertex"+        writeIORef glrefDrawElementsBaseVertex $ gldynDrawElementsBaseVertex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawRangeElementsBaseVertex"+        writeIORef glrefDrawRangeElementsBaseVertex $ gldynDrawRangeElementsBaseVertex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsInstancedBaseVertex"+        writeIORef glrefDrawElementsInstancedBaseVertex $ gldynDrawElementsInstancedBaseVertex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawElementsBaseVertex"+        writeIORef glrefMultiDrawElementsBaseVertex $ gldynMultiDrawElementsBaseVertex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProvokingVertex"+        writeIORef glrefProvokingVertex $ gldynProvokingVertex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFenceSync"+        writeIORef glrefFenceSync $ gldynFenceSync addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsSync"+        writeIORef glrefIsSync $ gldynIsSync addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteSync"+        writeIORef glrefDeleteSync $ gldynDeleteSync addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClientWaitSync"+        writeIORef glrefClientWaitSync $ gldynClientWaitSync addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glWaitSync"+        writeIORef glrefWaitSync $ gldynWaitSync addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetInteger64v"+        writeIORef glrefGetInteger64v $ gldynGetInteger64v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSynciv"+        writeIORef glrefGetSynciv $ gldynGetSynciv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetInteger64i_v"+        writeIORef glrefGetInteger64i_v $ gldynGetInteger64i_v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferParameteri64v"+        writeIORef glrefGetBufferParameteri64v $ gldynGetBufferParameteri64v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture"+        writeIORef glrefFramebufferTexture $ gldynFramebufferTexture addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage2DMultisample"+        writeIORef glrefTexImage2DMultisample $ gldynTexImage2DMultisample addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage3DMultisample"+        writeIORef glrefTexImage3DMultisample $ gldynTexImage3DMultisample addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultisamplefv"+        writeIORef glrefGetMultisamplefv $ gldynGetMultisamplefv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSampleMaski"+        writeIORef glrefSampleMaski $ gldynSampleMaski addr++    -- GL_VERSION_3_3++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFragDataLocationIndexed"+        writeIORef glrefBindFragDataLocationIndexed $ gldynBindFragDataLocationIndexed addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFragDataIndex"+        writeIORef glrefGetFragDataIndex $ gldynGetFragDataIndex addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenSamplers"+        writeIORef glrefGenSamplers $ gldynGenSamplers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteSamplers"+        writeIORef glrefDeleteSamplers $ gldynDeleteSamplers addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsSampler"+        writeIORef glrefIsSampler $ gldynIsSampler addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindSampler"+        writeIORef glrefBindSampler $ gldynBindSampler addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameteri"+        writeIORef glrefSamplerParameteri $ gldynSamplerParameteri addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameteriv"+        writeIORef glrefSamplerParameteriv $ gldynSamplerParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterf"+        writeIORef glrefSamplerParameterf $ gldynSamplerParameterf addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterfv"+        writeIORef glrefSamplerParameterfv $ gldynSamplerParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterIiv"+        writeIORef glrefSamplerParameterIiv $ gldynSamplerParameterIiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterIuiv"+        writeIORef glrefSamplerParameterIuiv $ gldynSamplerParameterIuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameteriv"+        writeIORef glrefGetSamplerParameteriv $ gldynGetSamplerParameteriv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterIiv"+        writeIORef glrefGetSamplerParameterIiv $ gldynGetSamplerParameterIiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterfv"+        writeIORef glrefGetSamplerParameterfv $ gldynGetSamplerParameterfv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterIuiv"+        writeIORef glrefGetSamplerParameterIuiv $ gldynGetSamplerParameterIuiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glQueryCounter"+        writeIORef glrefQueryCounter $ gldynQueryCounter addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjecti64v"+        writeIORef glrefGetQueryObjecti64v $ gldynGetQueryObjecti64v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectui64v"+        writeIORef glrefGetQueryObjectui64v $ gldynGetQueryObjectui64v addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribDivisor"+        writeIORef glrefVertexAttribDivisor $ gldynVertexAttribDivisor addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP1ui"+        writeIORef glrefVertexAttribP1ui $ gldynVertexAttribP1ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP1uiv"+        writeIORef glrefVertexAttribP1uiv $ gldynVertexAttribP1uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP2ui"+        writeIORef glrefVertexAttribP2ui $ gldynVertexAttribP2ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP2uiv"+        writeIORef glrefVertexAttribP2uiv $ gldynVertexAttribP2uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP3ui"+        writeIORef glrefVertexAttribP3ui $ gldynVertexAttribP3ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP3uiv"+        writeIORef glrefVertexAttribP3uiv $ gldynVertexAttribP3uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP4ui"+        writeIORef glrefVertexAttribP4ui $ gldynVertexAttribP4ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP4uiv"+        writeIORef glrefVertexAttribP4uiv $ gldynVertexAttribP4uiv addr++    -- GL_ARB_texture_storage++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage1D"+        writeIORef glrefTexStorage1D $ gldynTexStorage1D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage2D"+        writeIORef glrefTexStorage2D $ gldynTexStorage2D addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage3D"+        writeIORef glrefTexStorage3D $ gldynTexStorage3D addr++    -- GL_KHR_debug++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageControl"+        writeIORef glrefDebugMessageControl $ gldynDebugMessageControl addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageInsert"+        writeIORef glrefDebugMessageInsert $ gldynDebugMessageInsert addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageCallback"+        writeIORef glrefDebugMessageCallback $ gldynDebugMessageCallback addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDebugMessageLog"+        writeIORef glrefGetDebugMessageLog $ gldynGetDebugMessageLog addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushDebugGroup"+        writeIORef glrefPushDebugGroup $ gldynPushDebugGroup addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPopDebugGroup"+        writeIORef glrefPopDebugGroup $ gldynPopDebugGroup addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectLabel"+        writeIORef glrefObjectLabel $ gldynObjectLabel addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectLabel"+        writeIORef glrefGetObjectLabel $ gldynGetObjectLabel addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectPtrLabel"+        writeIORef glrefObjectPtrLabel $ gldynObjectPtrLabel addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectPtrLabel"+        writeIORef glrefGetObjectPtrLabel $ gldynGetObjectPtrLabel addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointerv"+        writeIORef glrefGetPointerv $ gldynGetPointerv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageControlKHR"+        writeIORef glrefDebugMessageControlKHR $ gldynDebugMessageControlKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageInsertKHR"+        writeIORef glrefDebugMessageInsertKHR $ gldynDebugMessageInsertKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageCallbackKHR"+        writeIORef glrefDebugMessageCallbackKHR $ gldynDebugMessageCallbackKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDebugMessageLogKHR"+        writeIORef glrefGetDebugMessageLogKHR $ gldynGetDebugMessageLogKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushDebugGroupKHR"+        writeIORef glrefPushDebugGroupKHR $ gldynPushDebugGroupKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPopDebugGroupKHR"+        writeIORef glrefPopDebugGroupKHR $ gldynPopDebugGroupKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectLabelKHR"+        writeIORef glrefObjectLabelKHR $ gldynObjectLabelKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectLabelKHR"+        writeIORef glrefGetObjectLabelKHR $ gldynGetObjectLabelKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectPtrLabelKHR"+        writeIORef glrefObjectPtrLabelKHR $ gldynObjectPtrLabelKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectPtrLabelKHR"+        writeIORef glrefGetObjectPtrLabelKHR $ gldynGetObjectPtrLabelKHR addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointervKHR"+        writeIORef glrefGetPointervKHR $ gldynGetPointervKHR addr++    -- GL_EXT_direct_state_access++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadfEXT"+        writeIORef glrefMatrixLoadfEXT $ gldynMatrixLoadfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoaddEXT"+        writeIORef glrefMatrixLoaddEXT $ gldynMatrixLoaddEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultfEXT"+        writeIORef glrefMatrixMultfEXT $ gldynMatrixMultfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultdEXT"+        writeIORef glrefMatrixMultdEXT $ gldynMatrixMultdEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadIdentityEXT"+        writeIORef glrefMatrixLoadIdentityEXT $ gldynMatrixLoadIdentityEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixRotatefEXT"+        writeIORef glrefMatrixRotatefEXT $ gldynMatrixRotatefEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixRotatedEXT"+        writeIORef glrefMatrixRotatedEXT $ gldynMatrixRotatedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixScalefEXT"+        writeIORef glrefMatrixScalefEXT $ gldynMatrixScalefEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixScaledEXT"+        writeIORef glrefMatrixScaledEXT $ gldynMatrixScaledEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixTranslatefEXT"+        writeIORef glrefMatrixTranslatefEXT $ gldynMatrixTranslatefEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixTranslatedEXT"+        writeIORef glrefMatrixTranslatedEXT $ gldynMatrixTranslatedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixFrustumEXT"+        writeIORef glrefMatrixFrustumEXT $ gldynMatrixFrustumEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixOrthoEXT"+        writeIORef glrefMatrixOrthoEXT $ gldynMatrixOrthoEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixPopEXT"+        writeIORef glrefMatrixPopEXT $ gldynMatrixPopEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixPushEXT"+        writeIORef glrefMatrixPushEXT $ gldynMatrixPushEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClientAttribDefaultEXT"+        writeIORef glrefClientAttribDefaultEXT $ gldynClientAttribDefaultEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushClientAttribDefaultEXT"+        writeIORef glrefPushClientAttribDefaultEXT $ gldynPushClientAttribDefaultEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterfEXT"+        writeIORef glrefTextureParameterfEXT $ gldynTextureParameterfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterfvEXT"+        writeIORef glrefTextureParameterfvEXT $ gldynTextureParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameteriEXT"+        writeIORef glrefTextureParameteriEXT $ gldynTextureParameteriEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterivEXT"+        writeIORef glrefTextureParameterivEXT $ gldynTextureParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage1DEXT"+        writeIORef glrefTextureImage1DEXT $ gldynTextureImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage2DEXT"+        writeIORef glrefTextureImage2DEXT $ gldynTextureImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage1DEXT"+        writeIORef glrefTextureSubImage1DEXT $ gldynTextureSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage2DEXT"+        writeIORef glrefTextureSubImage2DEXT $ gldynTextureSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureImage1DEXT"+        writeIORef glrefCopyTextureImage1DEXT $ gldynCopyTextureImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureImage2DEXT"+        writeIORef glrefCopyTextureImage2DEXT $ gldynCopyTextureImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage1DEXT"+        writeIORef glrefCopyTextureSubImage1DEXT $ gldynCopyTextureSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage2DEXT"+        writeIORef glrefCopyTextureSubImage2DEXT $ gldynCopyTextureSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureImageEXT"+        writeIORef glrefGetTextureImageEXT $ gldynGetTextureImageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterfvEXT"+        writeIORef glrefGetTextureParameterfvEXT $ gldynGetTextureParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterivEXT"+        writeIORef glrefGetTextureParameterivEXT $ gldynGetTextureParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureLevelParameterfvEXT"+        writeIORef glrefGetTextureLevelParameterfvEXT $ gldynGetTextureLevelParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureLevelParameterivEXT"+        writeIORef glrefGetTextureLevelParameterivEXT $ gldynGetTextureLevelParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage3DEXT"+        writeIORef glrefTextureImage3DEXT $ gldynTextureImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage3DEXT"+        writeIORef glrefTextureSubImage3DEXT $ gldynTextureSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage3DEXT"+        writeIORef glrefCopyTextureSubImage3DEXT $ gldynCopyTextureSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindMultiTextureEXT"+        writeIORef glrefBindMultiTextureEXT $ gldynBindMultiTextureEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexCoordPointerEXT"+        writeIORef glrefMultiTexCoordPointerEXT $ gldynMultiTexCoordPointerEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvfEXT"+        writeIORef glrefMultiTexEnvfEXT $ gldynMultiTexEnvfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvfvEXT"+        writeIORef glrefMultiTexEnvfvEXT $ gldynMultiTexEnvfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnviEXT"+        writeIORef glrefMultiTexEnviEXT $ gldynMultiTexEnviEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvivEXT"+        writeIORef glrefMultiTexEnvivEXT $ gldynMultiTexEnvivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGendEXT"+        writeIORef glrefMultiTexGendEXT $ gldynMultiTexGendEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGendvEXT"+        writeIORef glrefMultiTexGendvEXT $ gldynMultiTexGendvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenfEXT"+        writeIORef glrefMultiTexGenfEXT $ gldynMultiTexGenfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenfvEXT"+        writeIORef glrefMultiTexGenfvEXT $ gldynMultiTexGenfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGeniEXT"+        writeIORef glrefMultiTexGeniEXT $ gldynMultiTexGeniEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenivEXT"+        writeIORef glrefMultiTexGenivEXT $ gldynMultiTexGenivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexEnvfvEXT"+        writeIORef glrefGetMultiTexEnvfvEXT $ gldynGetMultiTexEnvfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexEnvivEXT"+        writeIORef glrefGetMultiTexEnvivEXT $ gldynGetMultiTexEnvivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGendvEXT"+        writeIORef glrefGetMultiTexGendvEXT $ gldynGetMultiTexGendvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGenfvEXT"+        writeIORef glrefGetMultiTexGenfvEXT $ gldynGetMultiTexGenfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGenivEXT"+        writeIORef glrefGetMultiTexGenivEXT $ gldynGetMultiTexGenivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameteriEXT"+        writeIORef glrefMultiTexParameteriEXT $ gldynMultiTexParameteriEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterivEXT"+        writeIORef glrefMultiTexParameterivEXT $ gldynMultiTexParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterfEXT"+        writeIORef glrefMultiTexParameterfEXT $ gldynMultiTexParameterfEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterfvEXT"+        writeIORef glrefMultiTexParameterfvEXT $ gldynMultiTexParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage1DEXT"+        writeIORef glrefMultiTexImage1DEXT $ gldynMultiTexImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage2DEXT"+        writeIORef glrefMultiTexImage2DEXT $ gldynMultiTexImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage1DEXT"+        writeIORef glrefMultiTexSubImage1DEXT $ gldynMultiTexSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage2DEXT"+        writeIORef glrefMultiTexSubImage2DEXT $ gldynMultiTexSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexImage1DEXT"+        writeIORef glrefCopyMultiTexImage1DEXT $ gldynCopyMultiTexImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexImage2DEXT"+        writeIORef glrefCopyMultiTexImage2DEXT $ gldynCopyMultiTexImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage1DEXT"+        writeIORef glrefCopyMultiTexSubImage1DEXT $ gldynCopyMultiTexSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage2DEXT"+        writeIORef glrefCopyMultiTexSubImage2DEXT $ gldynCopyMultiTexSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexImageEXT"+        writeIORef glrefGetMultiTexImageEXT $ gldynGetMultiTexImageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterfvEXT"+        writeIORef glrefGetMultiTexParameterfvEXT $ gldynGetMultiTexParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterivEXT"+        writeIORef glrefGetMultiTexParameterivEXT $ gldynGetMultiTexParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexLevelParameterfvEXT"+        writeIORef glrefGetMultiTexLevelParameterfvEXT $ gldynGetMultiTexLevelParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexLevelParameterivEXT"+        writeIORef glrefGetMultiTexLevelParameterivEXT $ gldynGetMultiTexLevelParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage3DEXT"+        writeIORef glrefMultiTexImage3DEXT $ gldynMultiTexImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage3DEXT"+        writeIORef glrefMultiTexSubImage3DEXT $ gldynMultiTexSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage3DEXT"+        writeIORef glrefCopyMultiTexSubImage3DEXT $ gldynCopyMultiTexSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableClientStateIndexedEXT"+        writeIORef glrefEnableClientStateIndexedEXT $ gldynEnableClientStateIndexedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableClientStateIndexedEXT"+        writeIORef glrefDisableClientStateIndexedEXT $ gldynDisableClientStateIndexedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloatIndexedvEXT"+        writeIORef glrefGetFloatIndexedvEXT $ gldynGetFloatIndexedvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoubleIndexedvEXT"+        writeIORef glrefGetDoubleIndexedvEXT $ gldynGetDoubleIndexedvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointerIndexedvEXT"+        writeIORef glrefGetPointerIndexedvEXT $ gldynGetPointerIndexedvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableIndexedEXT"+        writeIORef glrefEnableIndexedEXT $ gldynEnableIndexedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableIndexedEXT"+        writeIORef glrefDisableIndexedEXT $ gldynDisableIndexedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabledIndexedEXT"+        writeIORef glrefIsEnabledIndexedEXT $ gldynIsEnabledIndexedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegerIndexedvEXT"+        writeIORef glrefGetIntegerIndexedvEXT $ gldynGetIntegerIndexedvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleanIndexedvEXT"+        writeIORef glrefGetBooleanIndexedvEXT $ gldynGetBooleanIndexedvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage3DEXT"+        writeIORef glrefCompressedTextureImage3DEXT $ gldynCompressedTextureImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage2DEXT"+        writeIORef glrefCompressedTextureImage2DEXT $ gldynCompressedTextureImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage1DEXT"+        writeIORef glrefCompressedTextureImage1DEXT $ gldynCompressedTextureImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage3DEXT"+        writeIORef glrefCompressedTextureSubImage3DEXT $ gldynCompressedTextureSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage2DEXT"+        writeIORef glrefCompressedTextureSubImage2DEXT $ gldynCompressedTextureSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage1DEXT"+        writeIORef glrefCompressedTextureSubImage1DEXT $ gldynCompressedTextureSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedTextureImageEXT"+        writeIORef glrefGetCompressedTextureImageEXT $ gldynGetCompressedTextureImageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage3DEXT"+        writeIORef glrefCompressedMultiTexImage3DEXT $ gldynCompressedMultiTexImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage2DEXT"+        writeIORef glrefCompressedMultiTexImage2DEXT $ gldynCompressedMultiTexImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage1DEXT"+        writeIORef glrefCompressedMultiTexImage1DEXT $ gldynCompressedMultiTexImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage3DEXT"+        writeIORef glrefCompressedMultiTexSubImage3DEXT $ gldynCompressedMultiTexSubImage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage2DEXT"+        writeIORef glrefCompressedMultiTexSubImage2DEXT $ gldynCompressedMultiTexSubImage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage1DEXT"+        writeIORef glrefCompressedMultiTexSubImage1DEXT $ gldynCompressedMultiTexSubImage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedMultiTexImageEXT"+        writeIORef glrefGetCompressedMultiTexImageEXT $ gldynGetCompressedMultiTexImageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadTransposefEXT"+        writeIORef glrefMatrixLoadTransposefEXT $ gldynMatrixLoadTransposefEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadTransposedEXT"+        writeIORef glrefMatrixLoadTransposedEXT $ gldynMatrixLoadTransposedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultTransposefEXT"+        writeIORef glrefMatrixMultTransposefEXT $ gldynMatrixMultTransposefEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultTransposedEXT"+        writeIORef glrefMatrixMultTransposedEXT $ gldynMatrixMultTransposedEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferDataEXT"+        writeIORef glrefNamedBufferDataEXT $ gldynNamedBufferDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferSubDataEXT"+        writeIORef glrefNamedBufferSubDataEXT $ gldynNamedBufferSubDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapNamedBufferEXT"+        writeIORef glrefMapNamedBufferEXT $ gldynMapNamedBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUnmapNamedBufferEXT"+        writeIORef glrefUnmapNamedBufferEXT $ gldynUnmapNamedBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferParameterivEXT"+        writeIORef glrefGetNamedBufferParameterivEXT $ gldynGetNamedBufferParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferPointervEXT"+        writeIORef glrefGetNamedBufferPointervEXT $ gldynGetNamedBufferPointervEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferSubDataEXT"+        writeIORef glrefGetNamedBufferSubDataEXT $ gldynGetNamedBufferSubDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fEXT"+        writeIORef glrefProgramUniform1fEXT $ gldynProgramUniform1fEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fEXT"+        writeIORef glrefProgramUniform2fEXT $ gldynProgramUniform2fEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fEXT"+        writeIORef glrefProgramUniform3fEXT $ gldynProgramUniform3fEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fEXT"+        writeIORef glrefProgramUniform4fEXT $ gldynProgramUniform4fEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1iEXT"+        writeIORef glrefProgramUniform1iEXT $ gldynProgramUniform1iEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2iEXT"+        writeIORef glrefProgramUniform2iEXT $ gldynProgramUniform2iEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3iEXT"+        writeIORef glrefProgramUniform3iEXT $ gldynProgramUniform3iEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4iEXT"+        writeIORef glrefProgramUniform4iEXT $ gldynProgramUniform4iEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fvEXT"+        writeIORef glrefProgramUniform1fvEXT $ gldynProgramUniform1fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fvEXT"+        writeIORef glrefProgramUniform2fvEXT $ gldynProgramUniform2fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fvEXT"+        writeIORef glrefProgramUniform3fvEXT $ gldynProgramUniform3fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fvEXT"+        writeIORef glrefProgramUniform4fvEXT $ gldynProgramUniform4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1ivEXT"+        writeIORef glrefProgramUniform1ivEXT $ gldynProgramUniform1ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2ivEXT"+        writeIORef glrefProgramUniform2ivEXT $ gldynProgramUniform2ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3ivEXT"+        writeIORef glrefProgramUniform3ivEXT $ gldynProgramUniform3ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4ivEXT"+        writeIORef glrefProgramUniform4ivEXT $ gldynProgramUniform4ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2fvEXT"+        writeIORef glrefProgramUniformMatrix2fvEXT $ gldynProgramUniformMatrix2fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3fvEXT"+        writeIORef glrefProgramUniformMatrix3fvEXT $ gldynProgramUniformMatrix3fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4fvEXT"+        writeIORef glrefProgramUniformMatrix4fvEXT $ gldynProgramUniformMatrix4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3fvEXT"+        writeIORef glrefProgramUniformMatrix2x3fvEXT $ gldynProgramUniformMatrix2x3fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2fvEXT"+        writeIORef glrefProgramUniformMatrix3x2fvEXT $ gldynProgramUniformMatrix3x2fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4fvEXT"+        writeIORef glrefProgramUniformMatrix2x4fvEXT $ gldynProgramUniformMatrix2x4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2fvEXT"+        writeIORef glrefProgramUniformMatrix4x2fvEXT $ gldynProgramUniformMatrix4x2fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4fvEXT"+        writeIORef glrefProgramUniformMatrix3x4fvEXT $ gldynProgramUniformMatrix3x4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3fvEXT"+        writeIORef glrefProgramUniformMatrix4x3fvEXT $ gldynProgramUniformMatrix4x3fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureBufferEXT"+        writeIORef glrefTextureBufferEXT $ gldynTextureBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexBufferEXT"+        writeIORef glrefMultiTexBufferEXT $ gldynMultiTexBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterIivEXT"+        writeIORef glrefTextureParameterIivEXT $ gldynTextureParameterIivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterIuivEXT"+        writeIORef glrefTextureParameterIuivEXT $ gldynTextureParameterIuivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterIivEXT"+        writeIORef glrefGetTextureParameterIivEXT $ gldynGetTextureParameterIivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterIuivEXT"+        writeIORef glrefGetTextureParameterIuivEXT $ gldynGetTextureParameterIuivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterIivEXT"+        writeIORef glrefMultiTexParameterIivEXT $ gldynMultiTexParameterIivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterIuivEXT"+        writeIORef glrefMultiTexParameterIuivEXT $ gldynMultiTexParameterIuivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterIivEXT"+        writeIORef glrefGetMultiTexParameterIivEXT $ gldynGetMultiTexParameterIivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterIuivEXT"+        writeIORef glrefGetMultiTexParameterIuivEXT $ gldynGetMultiTexParameterIuivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uiEXT"+        writeIORef glrefProgramUniform1uiEXT $ gldynProgramUniform1uiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uiEXT"+        writeIORef glrefProgramUniform2uiEXT $ gldynProgramUniform2uiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uiEXT"+        writeIORef glrefProgramUniform3uiEXT $ gldynProgramUniform3uiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uiEXT"+        writeIORef glrefProgramUniform4uiEXT $ gldynProgramUniform4uiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uivEXT"+        writeIORef glrefProgramUniform1uivEXT $ gldynProgramUniform1uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uivEXT"+        writeIORef glrefProgramUniform2uivEXT $ gldynProgramUniform2uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uivEXT"+        writeIORef glrefProgramUniform3uivEXT $ gldynProgramUniform3uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uivEXT"+        writeIORef glrefProgramUniform4uivEXT $ gldynProgramUniform4uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameters4fvEXT"+        writeIORef glrefNamedProgramLocalParameters4fvEXT $ gldynNamedProgramLocalParameters4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4iEXT"+        writeIORef glrefNamedProgramLocalParameterI4iEXT $ gldynNamedProgramLocalParameterI4iEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4ivEXT"+        writeIORef glrefNamedProgramLocalParameterI4ivEXT $ gldynNamedProgramLocalParameterI4ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParametersI4ivEXT"+        writeIORef glrefNamedProgramLocalParametersI4ivEXT $ gldynNamedProgramLocalParametersI4ivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4uiEXT"+        writeIORef glrefNamedProgramLocalParameterI4uiEXT $ gldynNamedProgramLocalParameterI4uiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4uivEXT"+        writeIORef glrefNamedProgramLocalParameterI4uivEXT $ gldynNamedProgramLocalParameterI4uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParametersI4uivEXT"+        writeIORef glrefNamedProgramLocalParametersI4uivEXT $ gldynNamedProgramLocalParametersI4uivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterIivEXT"+        writeIORef glrefGetNamedProgramLocalParameterIivEXT $ gldynGetNamedProgramLocalParameterIivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterIuivEXT"+        writeIORef glrefGetNamedProgramLocalParameterIuivEXT $ gldynGetNamedProgramLocalParameterIuivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableClientStateiEXT"+        writeIORef glrefEnableClientStateiEXT $ gldynEnableClientStateiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableClientStateiEXT"+        writeIORef glrefDisableClientStateiEXT $ gldynDisableClientStateiEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloati_vEXT"+        writeIORef glrefGetFloati_vEXT $ gldynGetFloati_vEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoublei_vEXT"+        writeIORef glrefGetDoublei_vEXT $ gldynGetDoublei_vEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointeri_vEXT"+        writeIORef glrefGetPointeri_vEXT $ gldynGetPointeri_vEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramStringEXT"+        writeIORef glrefNamedProgramStringEXT $ gldynNamedProgramStringEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4dEXT"+        writeIORef glrefNamedProgramLocalParameter4dEXT $ gldynNamedProgramLocalParameter4dEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4dvEXT"+        writeIORef glrefNamedProgramLocalParameter4dvEXT $ gldynNamedProgramLocalParameter4dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4fEXT"+        writeIORef glrefNamedProgramLocalParameter4fEXT $ gldynNamedProgramLocalParameter4fEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4fvEXT"+        writeIORef glrefNamedProgramLocalParameter4fvEXT $ gldynNamedProgramLocalParameter4fvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterdvEXT"+        writeIORef glrefGetNamedProgramLocalParameterdvEXT $ gldynGetNamedProgramLocalParameterdvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterfvEXT"+        writeIORef glrefGetNamedProgramLocalParameterfvEXT $ gldynGetNamedProgramLocalParameterfvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramivEXT"+        writeIORef glrefGetNamedProgramivEXT $ gldynGetNamedProgramivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramStringEXT"+        writeIORef glrefGetNamedProgramStringEXT $ gldynGetNamedProgramStringEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageEXT"+        writeIORef glrefNamedRenderbufferStorageEXT $ gldynNamedRenderbufferStorageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedRenderbufferParameterivEXT"+        writeIORef glrefGetNamedRenderbufferParameterivEXT $ gldynGetNamedRenderbufferParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageMultisampleEXT"+        writeIORef glrefNamedRenderbufferStorageMultisampleEXT $ gldynNamedRenderbufferStorageMultisampleEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageMultisampleCoverageEXT"+        writeIORef glrefNamedRenderbufferStorageMultisampleCoverageEXT $ gldynNamedRenderbufferStorageMultisampleCoverageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCheckNamedFramebufferStatusEXT"+        writeIORef glrefCheckNamedFramebufferStatusEXT $ gldynCheckNamedFramebufferStatusEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture1DEXT"+        writeIORef glrefNamedFramebufferTexture1DEXT $ gldynNamedFramebufferTexture1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture2DEXT"+        writeIORef glrefNamedFramebufferTexture2DEXT $ gldynNamedFramebufferTexture2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture3DEXT"+        writeIORef glrefNamedFramebufferTexture3DEXT $ gldynNamedFramebufferTexture3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferRenderbufferEXT"+        writeIORef glrefNamedFramebufferRenderbufferEXT $ gldynNamedFramebufferRenderbufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedFramebufferAttachmentParameterivEXT"+        writeIORef glrefGetNamedFramebufferAttachmentParameterivEXT $ gldynGetNamedFramebufferAttachmentParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateTextureMipmapEXT"+        writeIORef glrefGenerateTextureMipmapEXT $ gldynGenerateTextureMipmapEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateMultiTexMipmapEXT"+        writeIORef glrefGenerateMultiTexMipmapEXT $ gldynGenerateMultiTexMipmapEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferDrawBufferEXT"+        writeIORef glrefFramebufferDrawBufferEXT $ gldynFramebufferDrawBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferDrawBuffersEXT"+        writeIORef glrefFramebufferDrawBuffersEXT $ gldynFramebufferDrawBuffersEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferReadBufferEXT"+        writeIORef glrefFramebufferReadBufferEXT $ gldynFramebufferReadBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFramebufferParameterivEXT"+        writeIORef glrefGetFramebufferParameterivEXT $ gldynGetFramebufferParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedCopyBufferSubDataEXT"+        writeIORef glrefNamedCopyBufferSubDataEXT $ gldynNamedCopyBufferSubDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureEXT"+        writeIORef glrefNamedFramebufferTextureEXT $ gldynNamedFramebufferTextureEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureLayerEXT"+        writeIORef glrefNamedFramebufferTextureLayerEXT $ gldynNamedFramebufferTextureLayerEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureFaceEXT"+        writeIORef glrefNamedFramebufferTextureFaceEXT $ gldynNamedFramebufferTextureFaceEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureRenderbufferEXT"+        writeIORef glrefTextureRenderbufferEXT $ gldynTextureRenderbufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexRenderbufferEXT"+        writeIORef glrefMultiTexRenderbufferEXT $ gldynMultiTexRenderbufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexOffsetEXT"+        writeIORef glrefVertexArrayVertexOffsetEXT $ gldynVertexArrayVertexOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayColorOffsetEXT"+        writeIORef glrefVertexArrayColorOffsetEXT $ gldynVertexArrayColorOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayEdgeFlagOffsetEXT"+        writeIORef glrefVertexArrayEdgeFlagOffsetEXT $ gldynVertexArrayEdgeFlagOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayIndexOffsetEXT"+        writeIORef glrefVertexArrayIndexOffsetEXT $ gldynVertexArrayIndexOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayNormalOffsetEXT"+        writeIORef glrefVertexArrayNormalOffsetEXT $ gldynVertexArrayNormalOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayTexCoordOffsetEXT"+        writeIORef glrefVertexArrayTexCoordOffsetEXT $ gldynVertexArrayTexCoordOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayMultiTexCoordOffsetEXT"+        writeIORef glrefVertexArrayMultiTexCoordOffsetEXT $ gldynVertexArrayMultiTexCoordOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayFogCoordOffsetEXT"+        writeIORef glrefVertexArrayFogCoordOffsetEXT $ gldynVertexArrayFogCoordOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArraySecondaryColorOffsetEXT"+        writeIORef glrefVertexArraySecondaryColorOffsetEXT $ gldynVertexArraySecondaryColorOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribOffsetEXT"+        writeIORef glrefVertexArrayVertexAttribOffsetEXT $ gldynVertexArrayVertexAttribOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribIOffsetEXT"+        writeIORef glrefVertexArrayVertexAttribIOffsetEXT $ gldynVertexArrayVertexAttribIOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexArrayEXT"+        writeIORef glrefEnableVertexArrayEXT $ gldynEnableVertexArrayEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexArrayEXT"+        writeIORef glrefDisableVertexArrayEXT $ gldynDisableVertexArrayEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexArrayAttribEXT"+        writeIORef glrefEnableVertexArrayAttribEXT $ gldynEnableVertexArrayAttribEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexArrayAttribEXT"+        writeIORef glrefDisableVertexArrayAttribEXT $ gldynDisableVertexArrayAttribEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayIntegervEXT"+        writeIORef glrefGetVertexArrayIntegervEXT $ gldynGetVertexArrayIntegervEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayPointervEXT"+        writeIORef glrefGetVertexArrayPointervEXT $ gldynGetVertexArrayPointervEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayIntegeri_vEXT"+        writeIORef glrefGetVertexArrayIntegeri_vEXT $ gldynGetVertexArrayIntegeri_vEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayPointeri_vEXT"+        writeIORef glrefGetVertexArrayPointeri_vEXT $ gldynGetVertexArrayPointeri_vEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapNamedBufferRangeEXT"+        writeIORef glrefMapNamedBufferRangeEXT $ gldynMapNamedBufferRangeEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlushMappedNamedBufferRangeEXT"+        writeIORef glrefFlushMappedNamedBufferRangeEXT $ gldynFlushMappedNamedBufferRangeEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferStorageEXT"+        writeIORef glrefNamedBufferStorageEXT $ gldynNamedBufferStorageEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearNamedBufferDataEXT"+        writeIORef glrefClearNamedBufferDataEXT $ gldynClearNamedBufferDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearNamedBufferSubDataEXT"+        writeIORef glrefClearNamedBufferSubDataEXT $ gldynClearNamedBufferSubDataEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferParameteriEXT"+        writeIORef glrefNamedFramebufferParameteriEXT $ gldynNamedFramebufferParameteriEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedFramebufferParameterivEXT"+        writeIORef glrefGetNamedFramebufferParameterivEXT $ gldynGetNamedFramebufferParameterivEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dEXT"+        writeIORef glrefProgramUniform1dEXT $ gldynProgramUniform1dEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dEXT"+        writeIORef glrefProgramUniform2dEXT $ gldynProgramUniform2dEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dEXT"+        writeIORef glrefProgramUniform3dEXT $ gldynProgramUniform3dEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dEXT"+        writeIORef glrefProgramUniform4dEXT $ gldynProgramUniform4dEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dvEXT"+        writeIORef glrefProgramUniform1dvEXT $ gldynProgramUniform1dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dvEXT"+        writeIORef glrefProgramUniform2dvEXT $ gldynProgramUniform2dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dvEXT"+        writeIORef glrefProgramUniform3dvEXT $ gldynProgramUniform3dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dvEXT"+        writeIORef glrefProgramUniform4dvEXT $ gldynProgramUniform4dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2dvEXT"+        writeIORef glrefProgramUniformMatrix2dvEXT $ gldynProgramUniformMatrix2dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3dvEXT"+        writeIORef glrefProgramUniformMatrix3dvEXT $ gldynProgramUniformMatrix3dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4dvEXT"+        writeIORef glrefProgramUniformMatrix4dvEXT $ gldynProgramUniformMatrix4dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3dvEXT"+        writeIORef glrefProgramUniformMatrix2x3dvEXT $ gldynProgramUniformMatrix2x3dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4dvEXT"+        writeIORef glrefProgramUniformMatrix2x4dvEXT $ gldynProgramUniformMatrix2x4dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2dvEXT"+        writeIORef glrefProgramUniformMatrix3x2dvEXT $ gldynProgramUniformMatrix3x2dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4dvEXT"+        writeIORef glrefProgramUniformMatrix3x4dvEXT $ gldynProgramUniformMatrix3x4dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2dvEXT"+        writeIORef glrefProgramUniformMatrix4x2dvEXT $ gldynProgramUniformMatrix4x2dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3dvEXT"+        writeIORef glrefProgramUniformMatrix4x3dvEXT $ gldynProgramUniformMatrix4x3dvEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureBufferRangeEXT"+        writeIORef glrefTextureBufferRangeEXT $ gldynTextureBufferRangeEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage1DEXT"+        writeIORef glrefTextureStorage1DEXT $ gldynTextureStorage1DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage2DEXT"+        writeIORef glrefTextureStorage2DEXT $ gldynTextureStorage2DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage3DEXT"+        writeIORef glrefTextureStorage3DEXT $ gldynTextureStorage3DEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage2DMultisampleEXT"+        writeIORef glrefTextureStorage2DMultisampleEXT $ gldynTextureStorage2DMultisampleEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage3DMultisampleEXT"+        writeIORef glrefTextureStorage3DMultisampleEXT $ gldynTextureStorage3DMultisampleEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayBindVertexBufferEXT"+        writeIORef glrefVertexArrayBindVertexBufferEXT $ gldynVertexArrayBindVertexBufferEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribFormatEXT"+        writeIORef glrefVertexArrayVertexAttribFormatEXT $ gldynVertexArrayVertexAttribFormatEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribIFormatEXT"+        writeIORef glrefVertexArrayVertexAttribIFormatEXT $ gldynVertexArrayVertexAttribIFormatEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribLFormatEXT"+        writeIORef glrefVertexArrayVertexAttribLFormatEXT $ gldynVertexArrayVertexAttribLFormatEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribBindingEXT"+        writeIORef glrefVertexArrayVertexAttribBindingEXT $ gldynVertexArrayVertexAttribBindingEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexBindingDivisorEXT"+        writeIORef glrefVertexArrayVertexBindingDivisorEXT $ gldynVertexArrayVertexBindingDivisorEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribLOffsetEXT"+        writeIORef glrefVertexArrayVertexAttribLOffsetEXT $ gldynVertexArrayVertexAttribLOffsetEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexturePageCommitmentEXT"+        writeIORef glrefTexturePageCommitmentEXT $ gldynTexturePageCommitmentEXT addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribDivisorEXT"+        writeIORef glrefVertexArrayVertexAttribDivisorEXT $ gldynVertexArrayVertexAttribDivisorEXT addr++    -- GL_ARB_buffer_storage++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferStorage"+        writeIORef glrefBufferStorage $ gldynBufferStorage addr++    -- GL_ARB_separate_shader_objects++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUseProgramStages"+        writeIORef glrefUseProgramStages $ gldynUseProgramStages addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glActiveShaderProgram"+        writeIORef glrefActiveShaderProgram $ gldynActiveShaderProgram addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateShaderProgramv"+        writeIORef glrefCreateShaderProgramv $ gldynCreateShaderProgramv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindProgramPipeline"+        writeIORef glrefBindProgramPipeline $ gldynBindProgramPipeline addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteProgramPipelines"+        writeIORef glrefDeleteProgramPipelines $ gldynDeleteProgramPipelines addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenProgramPipelines"+        writeIORef glrefGenProgramPipelines $ gldynGenProgramPipelines addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsProgramPipeline"+        writeIORef glrefIsProgramPipeline $ gldynIsProgramPipeline addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramPipelineiv"+        writeIORef glrefGetProgramPipelineiv $ gldynGetProgramPipelineiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1i"+        writeIORef glrefProgramUniform1i $ gldynProgramUniform1i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1iv"+        writeIORef glrefProgramUniform1iv $ gldynProgramUniform1iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1f"+        writeIORef glrefProgramUniform1f $ gldynProgramUniform1f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fv"+        writeIORef glrefProgramUniform1fv $ gldynProgramUniform1fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1d"+        writeIORef glrefProgramUniform1d $ gldynProgramUniform1d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dv"+        writeIORef glrefProgramUniform1dv $ gldynProgramUniform1dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1ui"+        writeIORef glrefProgramUniform1ui $ gldynProgramUniform1ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uiv"+        writeIORef glrefProgramUniform1uiv $ gldynProgramUniform1uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2i"+        writeIORef glrefProgramUniform2i $ gldynProgramUniform2i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2iv"+        writeIORef glrefProgramUniform2iv $ gldynProgramUniform2iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2f"+        writeIORef glrefProgramUniform2f $ gldynProgramUniform2f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fv"+        writeIORef glrefProgramUniform2fv $ gldynProgramUniform2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2d"+        writeIORef glrefProgramUniform2d $ gldynProgramUniform2d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dv"+        writeIORef glrefProgramUniform2dv $ gldynProgramUniform2dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2ui"+        writeIORef glrefProgramUniform2ui $ gldynProgramUniform2ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uiv"+        writeIORef glrefProgramUniform2uiv $ gldynProgramUniform2uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3i"+        writeIORef glrefProgramUniform3i $ gldynProgramUniform3i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3iv"+        writeIORef glrefProgramUniform3iv $ gldynProgramUniform3iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3f"+        writeIORef glrefProgramUniform3f $ gldynProgramUniform3f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fv"+        writeIORef glrefProgramUniform3fv $ gldynProgramUniform3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3d"+        writeIORef glrefProgramUniform3d $ gldynProgramUniform3d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dv"+        writeIORef glrefProgramUniform3dv $ gldynProgramUniform3dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3ui"+        writeIORef glrefProgramUniform3ui $ gldynProgramUniform3ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uiv"+        writeIORef glrefProgramUniform3uiv $ gldynProgramUniform3uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4i"+        writeIORef glrefProgramUniform4i $ gldynProgramUniform4i addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4iv"+        writeIORef glrefProgramUniform4iv $ gldynProgramUniform4iv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4f"+        writeIORef glrefProgramUniform4f $ gldynProgramUniform4f addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fv"+        writeIORef glrefProgramUniform4fv $ gldynProgramUniform4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4d"+        writeIORef glrefProgramUniform4d $ gldynProgramUniform4d addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dv"+        writeIORef glrefProgramUniform4dv $ gldynProgramUniform4dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4ui"+        writeIORef glrefProgramUniform4ui $ gldynProgramUniform4ui addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uiv"+        writeIORef glrefProgramUniform4uiv $ gldynProgramUniform4uiv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2fv"+        writeIORef glrefProgramUniformMatrix2fv $ gldynProgramUniformMatrix2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3fv"+        writeIORef glrefProgramUniformMatrix3fv $ gldynProgramUniformMatrix3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4fv"+        writeIORef glrefProgramUniformMatrix4fv $ gldynProgramUniformMatrix4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2dv"+        writeIORef glrefProgramUniformMatrix2dv $ gldynProgramUniformMatrix2dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3dv"+        writeIORef glrefProgramUniformMatrix3dv $ gldynProgramUniformMatrix3dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4dv"+        writeIORef glrefProgramUniformMatrix4dv $ gldynProgramUniformMatrix4dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3fv"+        writeIORef glrefProgramUniformMatrix2x3fv $ gldynProgramUniformMatrix2x3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2fv"+        writeIORef glrefProgramUniformMatrix3x2fv $ gldynProgramUniformMatrix3x2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4fv"+        writeIORef glrefProgramUniformMatrix2x4fv $ gldynProgramUniformMatrix2x4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2fv"+        writeIORef glrefProgramUniformMatrix4x2fv $ gldynProgramUniformMatrix4x2fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4fv"+        writeIORef glrefProgramUniformMatrix3x4fv $ gldynProgramUniformMatrix3x4fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3fv"+        writeIORef glrefProgramUniformMatrix4x3fv $ gldynProgramUniformMatrix4x3fv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3dv"+        writeIORef glrefProgramUniformMatrix2x3dv $ gldynProgramUniformMatrix2x3dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2dv"+        writeIORef glrefProgramUniformMatrix3x2dv $ gldynProgramUniformMatrix3x2dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4dv"+        writeIORef glrefProgramUniformMatrix2x4dv $ gldynProgramUniformMatrix2x4dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2dv"+        writeIORef glrefProgramUniformMatrix4x2dv $ gldynProgramUniformMatrix4x2dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4dv"+        writeIORef glrefProgramUniformMatrix3x4dv $ gldynProgramUniformMatrix3x4dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3dv"+        writeIORef glrefProgramUniformMatrix4x3dv $ gldynProgramUniformMatrix4x3dv addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glValidateProgramPipeline"+        writeIORef glrefValidateProgramPipeline $ gldynValidateProgramPipeline addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramPipelineInfoLog"+        writeIORef glrefGetProgramPipelineInfoLog $ gldynGetProgramPipelineInfoLog addr++    -- GL_ATI_meminfo+++    -- GL_NVX_gpu_memory_info+++    -- GL_ARB_invalidate_subdata++    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateTexSubImage"+        writeIORef glrefInvalidateTexSubImage $ gldynInvalidateTexSubImage addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateTexImage"+        writeIORef glrefInvalidateTexImage $ gldynInvalidateTexImage addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateBufferSubData"+        writeIORef glrefInvalidateBufferSubData $ gldynInvalidateBufferSubData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateBufferData"+        writeIORef glrefInvalidateBufferData $ gldynInvalidateBufferData addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateFramebuffer"+        writeIORef glrefInvalidateFramebuffer $ gldynInvalidateFramebuffer addr+    when True $ liftIO $ do+        addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateSubFramebuffer"+        writeIORef glrefInvalidateSubFramebuffer $ gldynInvalidateSubFramebuffer addr++++    when True $ do+        result <- liftIO $ is_supported "GL_ARB_texture_storage"+        unless result $ do+            throwE $ Failure $ "Missing OpenGL extension: " ++ "GL_ARB_texture_storage"+    when True $ do+        result <- liftIO $ is_supported "GL_KHR_debug"+        liftIO $ writeIORef hasref_GL_KHR_debug result+    when True $ do+        result <- liftIO $ is_supported "GL_EXT_direct_state_access"+        liftIO $ writeIORef hasref_GL_EXT_direct_state_access result+    when True $ do+        result <- liftIO $ is_supported "GL_ARB_buffer_storage"+        liftIO $ writeIORef hasref_GL_ARB_buffer_storage result+    when True $ do+        result <- liftIO $ is_supported "GL_ARB_separate_shader_objects"+        liftIO $ writeIORef hasref_GL_ARB_separate_shader_objects result+    when True $ do+        result <- liftIO $ is_supported "GL_ATI_meminfo"+        liftIO $ writeIORef hasref_GL_ATI_meminfo result+    when True $ do+        result <- liftIO $ is_supported "GL_NVX_gpu_memory_info"+        liftIO $ writeIORef hasref_GL_NVX_gpu_memory_info result+    when True $ do+        result <- liftIO $ is_supported "GL_ARB_invalidate_subdata"+        liftIO $ writeIORef hasref_GL_ARB_invalidate_subdata result++    return Success++has_GL_ARB_texture_storage :: IO Bool+has_GL_ARB_texture_storage = readIORef hasref_GL_ARB_texture_storage+{-# INLINE has_GL_ARB_texture_storage #-}+hasref_GL_ARB_texture_storage :: IORef Bool+hasref_GL_ARB_texture_storage = unsafePerformIO $ newIORef True+{-# NOINLINE hasref_GL_ARB_texture_storage #-}+has_GL_KHR_debug :: IO Bool+has_GL_KHR_debug = readIORef hasref_GL_KHR_debug+{-# INLINE has_GL_KHR_debug #-}+hasref_GL_KHR_debug :: IORef Bool+hasref_GL_KHR_debug = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_KHR_debug #-}+has_GL_EXT_direct_state_access :: IO Bool+has_GL_EXT_direct_state_access = readIORef hasref_GL_EXT_direct_state_access+{-# INLINE has_GL_EXT_direct_state_access #-}+hasref_GL_EXT_direct_state_access :: IORef Bool+hasref_GL_EXT_direct_state_access = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_EXT_direct_state_access #-}+has_GL_ARB_buffer_storage :: IO Bool+has_GL_ARB_buffer_storage = readIORef hasref_GL_ARB_buffer_storage+{-# INLINE has_GL_ARB_buffer_storage #-}+hasref_GL_ARB_buffer_storage :: IORef Bool+hasref_GL_ARB_buffer_storage = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_ARB_buffer_storage #-}+has_GL_ARB_separate_shader_objects :: IO Bool+has_GL_ARB_separate_shader_objects = readIORef hasref_GL_ARB_separate_shader_objects+{-# INLINE has_GL_ARB_separate_shader_objects #-}+hasref_GL_ARB_separate_shader_objects :: IORef Bool+hasref_GL_ARB_separate_shader_objects = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_ARB_separate_shader_objects #-}+has_GL_ATI_meminfo :: IO Bool+has_GL_ATI_meminfo = readIORef hasref_GL_ATI_meminfo+{-# INLINE has_GL_ATI_meminfo #-}+hasref_GL_ATI_meminfo :: IORef Bool+hasref_GL_ATI_meminfo = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_ATI_meminfo #-}+has_GL_NVX_gpu_memory_info :: IO Bool+has_GL_NVX_gpu_memory_info = readIORef hasref_GL_NVX_gpu_memory_info+{-# INLINE has_GL_NVX_gpu_memory_info #-}+hasref_GL_NVX_gpu_memory_info :: IORef Bool+hasref_GL_NVX_gpu_memory_info = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_NVX_gpu_memory_info #-}+has_GL_ARB_invalidate_subdata :: IO Bool+has_GL_ARB_invalidate_subdata = readIORef hasref_GL_ARB_invalidate_subdata+{-# INLINE has_GL_ARB_invalidate_subdata #-}+hasref_GL_ARB_invalidate_subdata :: IORef Bool+hasref_GL_ARB_invalidate_subdata = unsafePerformIO $ newIORef False+{-# NOINLINE hasref_GL_ARB_invalidate_subdata #-}+++-- GL_VERSION_1_0++type FuntypeCullFace =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCullFace :: FunPtr FuntypeCullFace -> FuntypeCullFace+glrefCullFace :: IORef FuntypeCullFace+glrefCullFace = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCullFace #-}+glCullFace :: FuntypeCullFace+glCullFace = unsafePerformIO $ readIORef glrefCullFace+{-# INLINE glCullFace #-}+type FuntypeFrontFace =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFrontFace :: FunPtr FuntypeFrontFace -> FuntypeFrontFace+glrefFrontFace :: IORef FuntypeFrontFace+glrefFrontFace = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFrontFace #-}+glFrontFace :: FuntypeFrontFace+glFrontFace = unsafePerformIO $ readIORef glrefFrontFace+{-# INLINE glFrontFace #-}+type FuntypeHint =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynHint :: FunPtr FuntypeHint -> FuntypeHint+glrefHint :: IORef FuntypeHint+glrefHint = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefHint #-}+glHint :: FuntypeHint+glHint = unsafePerformIO $ readIORef glrefHint+{-# INLINE glHint #-}+type FuntypeLineWidth =+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynLineWidth :: FunPtr FuntypeLineWidth -> FuntypeLineWidth+glrefLineWidth :: IORef FuntypeLineWidth+glrefLineWidth = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefLineWidth #-}+glLineWidth :: FuntypeLineWidth+glLineWidth = unsafePerformIO $ readIORef glrefLineWidth+{-# INLINE glLineWidth #-}+type FuntypePointSize =+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPointSize :: FunPtr FuntypePointSize -> FuntypePointSize+glrefPointSize :: IORef FuntypePointSize+glrefPointSize = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPointSize #-}+glPointSize :: FuntypePointSize+glPointSize = unsafePerformIO $ readIORef glrefPointSize+{-# INLINE glPointSize #-}+type FuntypePolygonMode =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPolygonMode :: FunPtr FuntypePolygonMode -> FuntypePolygonMode+glrefPolygonMode :: IORef FuntypePolygonMode+glrefPolygonMode = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPolygonMode #-}+glPolygonMode :: FuntypePolygonMode+glPolygonMode = unsafePerformIO $ readIORef glrefPolygonMode+{-# INLINE glPolygonMode #-}+type FuntypeScissor =+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynScissor :: FunPtr FuntypeScissor -> FuntypeScissor+glrefScissor :: IORef FuntypeScissor+glrefScissor = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefScissor #-}+glScissor :: FuntypeScissor+glScissor = unsafePerformIO $ readIORef glrefScissor+{-# INLINE glScissor #-}+type FuntypeTexParameterf =+    GLenum ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameterf :: FunPtr FuntypeTexParameterf -> FuntypeTexParameterf+glrefTexParameterf :: IORef FuntypeTexParameterf+glrefTexParameterf = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameterf #-}+glTexParameterf :: FuntypeTexParameterf+glTexParameterf = unsafePerformIO $ readIORef glrefTexParameterf+{-# INLINE glTexParameterf #-}+type FuntypeTexParameterfv =+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameterfv :: FunPtr FuntypeTexParameterfv -> FuntypeTexParameterfv+glrefTexParameterfv :: IORef FuntypeTexParameterfv+glrefTexParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameterfv #-}+glTexParameterfv :: FuntypeTexParameterfv+glTexParameterfv = unsafePerformIO $ readIORef glrefTexParameterfv+{-# INLINE glTexParameterfv #-}+type FuntypeTexParameteri =+    GLenum ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameteri :: FunPtr FuntypeTexParameteri -> FuntypeTexParameteri+glrefTexParameteri :: IORef FuntypeTexParameteri+glrefTexParameteri = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameteri #-}+glTexParameteri :: FuntypeTexParameteri+glTexParameteri = unsafePerformIO $ readIORef glrefTexParameteri+{-# INLINE glTexParameteri #-}+type FuntypeTexParameteriv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameteriv :: FunPtr FuntypeTexParameteriv -> FuntypeTexParameteriv+glrefTexParameteriv :: IORef FuntypeTexParameteriv+glrefTexParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameteriv #-}+glTexParameteriv :: FuntypeTexParameteriv+glTexParameteriv = unsafePerformIO $ readIORef glrefTexParameteriv+{-# INLINE glTexParameteriv #-}+type FuntypeTexImage1D =+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexImage1D :: FunPtr FuntypeTexImage1D -> FuntypeTexImage1D+glrefTexImage1D :: IORef FuntypeTexImage1D+glrefTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexImage1D #-}+glTexImage1D :: FuntypeTexImage1D+glTexImage1D = unsafePerformIO $ readIORef glrefTexImage1D+{-# INLINE glTexImage1D #-}+type FuntypeTexImage2D =+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexImage2D :: FunPtr FuntypeTexImage2D -> FuntypeTexImage2D+glrefTexImage2D :: IORef FuntypeTexImage2D+glrefTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexImage2D #-}+glTexImage2D :: FuntypeTexImage2D+glTexImage2D = unsafePerformIO $ readIORef glrefTexImage2D+{-# INLINE glTexImage2D #-}+type FuntypeDrawBuffer =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawBuffer :: FunPtr FuntypeDrawBuffer -> FuntypeDrawBuffer+glrefDrawBuffer :: IORef FuntypeDrawBuffer+glrefDrawBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawBuffer #-}+glDrawBuffer :: FuntypeDrawBuffer+glDrawBuffer = unsafePerformIO $ readIORef glrefDrawBuffer+{-# INLINE glDrawBuffer #-}+type FuntypeClear =+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClear :: FunPtr FuntypeClear -> FuntypeClear+glrefClear :: IORef FuntypeClear+glrefClear = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClear #-}+glClear :: FuntypeClear+glClear = unsafePerformIO $ readIORef glrefClear+{-# INLINE glClear #-}+type FuntypeClearColor =+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearColor :: FunPtr FuntypeClearColor -> FuntypeClearColor+glrefClearColor :: IORef FuntypeClearColor+glrefClearColor = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearColor #-}+glClearColor :: FuntypeClearColor+glClearColor = unsafePerformIO $ readIORef glrefClearColor+{-# INLINE glClearColor #-}+type FuntypeClearStencil =+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearStencil :: FunPtr FuntypeClearStencil -> FuntypeClearStencil+glrefClearStencil :: IORef FuntypeClearStencil+glrefClearStencil = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearStencil #-}+glClearStencil :: FuntypeClearStencil+glClearStencil = unsafePerformIO $ readIORef glrefClearStencil+{-# INLINE glClearStencil #-}+type FuntypeClearDepth =+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearDepth :: FunPtr FuntypeClearDepth -> FuntypeClearDepth+glrefClearDepth :: IORef FuntypeClearDepth+glrefClearDepth = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearDepth #-}+glClearDepth :: FuntypeClearDepth+glClearDepth = unsafePerformIO $ readIORef glrefClearDepth+{-# INLINE glClearDepth #-}+type FuntypeStencilMask =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilMask :: FunPtr FuntypeStencilMask -> FuntypeStencilMask+glrefStencilMask :: IORef FuntypeStencilMask+glrefStencilMask = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilMask #-}+glStencilMask :: FuntypeStencilMask+glStencilMask = unsafePerformIO $ readIORef glrefStencilMask+{-# INLINE glStencilMask #-}+type FuntypeColorMask =+    GLboolean ->+    GLboolean ->+    GLboolean ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynColorMask :: FunPtr FuntypeColorMask -> FuntypeColorMask+glrefColorMask :: IORef FuntypeColorMask+glrefColorMask = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefColorMask #-}+glColorMask :: FuntypeColorMask+glColorMask = unsafePerformIO $ readIORef glrefColorMask+{-# INLINE glColorMask #-}+type FuntypeDepthMask =+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDepthMask :: FunPtr FuntypeDepthMask -> FuntypeDepthMask+glrefDepthMask :: IORef FuntypeDepthMask+glrefDepthMask = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDepthMask #-}+glDepthMask :: FuntypeDepthMask+glDepthMask = unsafePerformIO $ readIORef glrefDepthMask+{-# INLINE glDepthMask #-}+type FuntypeDisable =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisable :: FunPtr FuntypeDisable -> FuntypeDisable+glrefDisable :: IORef FuntypeDisable+glrefDisable = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisable #-}+glDisable :: FuntypeDisable+glDisable = unsafePerformIO $ readIORef glrefDisable+{-# INLINE glDisable #-}+type FuntypeEnable =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnable :: FunPtr FuntypeEnable -> FuntypeEnable+glrefEnable :: IORef FuntypeEnable+glrefEnable = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnable #-}+glEnable :: FuntypeEnable+glEnable = unsafePerformIO $ readIORef glrefEnable+{-# INLINE glEnable #-}+type FuntypeFinish =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFinish :: FunPtr FuntypeFinish -> FuntypeFinish+glrefFinish :: IORef FuntypeFinish+glrefFinish = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFinish #-}+glFinish :: FuntypeFinish+glFinish = unsafePerformIO $ readIORef glrefFinish+{-# INLINE glFinish #-}+type FuntypeFlush =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFlush :: FunPtr FuntypeFlush -> FuntypeFlush+glrefFlush :: IORef FuntypeFlush+glrefFlush = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFlush #-}+glFlush :: FuntypeFlush+glFlush = unsafePerformIO $ readIORef glrefFlush+{-# INLINE glFlush #-}+type FuntypeBlendFunc =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlendFunc :: FunPtr FuntypeBlendFunc -> FuntypeBlendFunc+glrefBlendFunc :: IORef FuntypeBlendFunc+glrefBlendFunc = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlendFunc #-}+glBlendFunc :: FuntypeBlendFunc+glBlendFunc = unsafePerformIO $ readIORef glrefBlendFunc+{-# INLINE glBlendFunc #-}+type FuntypeLogicOp =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynLogicOp :: FunPtr FuntypeLogicOp -> FuntypeLogicOp+glrefLogicOp :: IORef FuntypeLogicOp+glrefLogicOp = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefLogicOp #-}+glLogicOp :: FuntypeLogicOp+glLogicOp = unsafePerformIO $ readIORef glrefLogicOp+{-# INLINE glLogicOp #-}+type FuntypeStencilFunc =+    GLenum ->+    GLint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilFunc :: FunPtr FuntypeStencilFunc -> FuntypeStencilFunc+glrefStencilFunc :: IORef FuntypeStencilFunc+glrefStencilFunc = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilFunc #-}+glStencilFunc :: FuntypeStencilFunc+glStencilFunc = unsafePerformIO $ readIORef glrefStencilFunc+{-# INLINE glStencilFunc #-}+type FuntypeStencilOp =+    GLenum ->+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilOp :: FunPtr FuntypeStencilOp -> FuntypeStencilOp+glrefStencilOp :: IORef FuntypeStencilOp+glrefStencilOp = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilOp #-}+glStencilOp :: FuntypeStencilOp+glStencilOp = unsafePerformIO $ readIORef glrefStencilOp+{-# INLINE glStencilOp #-}+type FuntypeDepthFunc =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDepthFunc :: FunPtr FuntypeDepthFunc -> FuntypeDepthFunc+glrefDepthFunc :: IORef FuntypeDepthFunc+glrefDepthFunc = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDepthFunc #-}+glDepthFunc :: FuntypeDepthFunc+glDepthFunc = unsafePerformIO $ readIORef glrefDepthFunc+{-# INLINE glDepthFunc #-}+type FuntypePixelStoref =+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPixelStoref :: FunPtr FuntypePixelStoref -> FuntypePixelStoref+glrefPixelStoref :: IORef FuntypePixelStoref+glrefPixelStoref = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPixelStoref #-}+glPixelStoref :: FuntypePixelStoref+glPixelStoref = unsafePerformIO $ readIORef glrefPixelStoref+{-# INLINE glPixelStoref #-}+type FuntypePixelStorei =+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPixelStorei :: FunPtr FuntypePixelStorei -> FuntypePixelStorei+glrefPixelStorei :: IORef FuntypePixelStorei+glrefPixelStorei = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPixelStorei #-}+glPixelStorei :: FuntypePixelStorei+glPixelStorei = unsafePerformIO $ readIORef glrefPixelStorei+{-# INLINE glPixelStorei #-}+type FuntypeReadBuffer =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynReadBuffer :: FunPtr FuntypeReadBuffer -> FuntypeReadBuffer+glrefReadBuffer :: IORef FuntypeReadBuffer+glrefReadBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefReadBuffer #-}+glReadBuffer :: FuntypeReadBuffer+glReadBuffer = unsafePerformIO $ readIORef glrefReadBuffer+{-# INLINE glReadBuffer #-}+type FuntypeReadPixels =+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynReadPixels :: FunPtr FuntypeReadPixels -> FuntypeReadPixels+glrefReadPixels :: IORef FuntypeReadPixels+glrefReadPixels = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefReadPixels #-}+glReadPixels :: FuntypeReadPixels+glReadPixels = unsafePerformIO $ readIORef glrefReadPixels+{-# INLINE glReadPixels #-}+type FuntypeGetBooleanv =+    GLenum ->+    Ptr (GLboolean) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBooleanv :: FunPtr FuntypeGetBooleanv -> FuntypeGetBooleanv+glrefGetBooleanv :: IORef FuntypeGetBooleanv+glrefGetBooleanv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBooleanv #-}+glGetBooleanv :: FuntypeGetBooleanv+glGetBooleanv = unsafePerformIO $ readIORef glrefGetBooleanv+{-# INLINE glGetBooleanv #-}+type FuntypeGetDoublev =+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetDoublev :: FunPtr FuntypeGetDoublev -> FuntypeGetDoublev+glrefGetDoublev :: IORef FuntypeGetDoublev+glrefGetDoublev = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetDoublev #-}+glGetDoublev :: FuntypeGetDoublev+glGetDoublev = unsafePerformIO $ readIORef glrefGetDoublev+{-# INLINE glGetDoublev #-}+type FuntypeGetError =+    IO ( GLenum )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetError :: FunPtr FuntypeGetError -> FuntypeGetError+glrefGetError :: IORef FuntypeGetError+glrefGetError = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetError #-}+glGetError :: FuntypeGetError+glGetError = unsafePerformIO $ readIORef glrefGetError+{-# INLINE glGetError #-}+type FuntypeGetFloatv =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFloatv :: FunPtr FuntypeGetFloatv -> FuntypeGetFloatv+glrefGetFloatv :: IORef FuntypeGetFloatv+glrefGetFloatv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFloatv #-}+glGetFloatv :: FuntypeGetFloatv+glGetFloatv = unsafePerformIO $ readIORef glrefGetFloatv+{-# INLINE glGetFloatv #-}+type FuntypeGetIntegerv =+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetIntegerv :: FunPtr FuntypeGetIntegerv -> FuntypeGetIntegerv+glrefGetIntegerv :: IORef FuntypeGetIntegerv+glrefGetIntegerv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetIntegerv #-}+glGetIntegerv :: FuntypeGetIntegerv+glGetIntegerv = unsafePerformIO $ readIORef glrefGetIntegerv+{-# INLINE glGetIntegerv #-}+type FuntypeGetString =+    GLenum ->+    IO ( Ptr (GLubyte) )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetString :: FunPtr FuntypeGetString -> FuntypeGetString+glrefGetString :: IORef FuntypeGetString+glrefGetString = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetString #-}+glGetString :: FuntypeGetString+glGetString = unsafePerformIO $ readIORef glrefGetString+{-# INLINE glGetString #-}+type FuntypeGetTexImage =+    GLenum ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexImage :: FunPtr FuntypeGetTexImage -> FuntypeGetTexImage+glrefGetTexImage :: IORef FuntypeGetTexImage+glrefGetTexImage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexImage #-}+glGetTexImage :: FuntypeGetTexImage+glGetTexImage = unsafePerformIO $ readIORef glrefGetTexImage+{-# INLINE glGetTexImage #-}+type FuntypeGetTexParameterfv =+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexParameterfv :: FunPtr FuntypeGetTexParameterfv -> FuntypeGetTexParameterfv+glrefGetTexParameterfv :: IORef FuntypeGetTexParameterfv+glrefGetTexParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexParameterfv #-}+glGetTexParameterfv :: FuntypeGetTexParameterfv+glGetTexParameterfv = unsafePerformIO $ readIORef glrefGetTexParameterfv+{-# INLINE glGetTexParameterfv #-}+type FuntypeGetTexParameteriv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexParameteriv :: FunPtr FuntypeGetTexParameteriv -> FuntypeGetTexParameteriv+glrefGetTexParameteriv :: IORef FuntypeGetTexParameteriv+glrefGetTexParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexParameteriv #-}+glGetTexParameteriv :: FuntypeGetTexParameteriv+glGetTexParameteriv = unsafePerformIO $ readIORef glrefGetTexParameteriv+{-# INLINE glGetTexParameteriv #-}+type FuntypeGetTexLevelParameterfv =+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexLevelParameterfv :: FunPtr FuntypeGetTexLevelParameterfv -> FuntypeGetTexLevelParameterfv+glrefGetTexLevelParameterfv :: IORef FuntypeGetTexLevelParameterfv+glrefGetTexLevelParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexLevelParameterfv #-}+glGetTexLevelParameterfv :: FuntypeGetTexLevelParameterfv+glGetTexLevelParameterfv = unsafePerformIO $ readIORef glrefGetTexLevelParameterfv+{-# INLINE glGetTexLevelParameterfv #-}+type FuntypeGetTexLevelParameteriv =+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexLevelParameteriv :: FunPtr FuntypeGetTexLevelParameteriv -> FuntypeGetTexLevelParameteriv+glrefGetTexLevelParameteriv :: IORef FuntypeGetTexLevelParameteriv+glrefGetTexLevelParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexLevelParameteriv #-}+glGetTexLevelParameteriv :: FuntypeGetTexLevelParameteriv+glGetTexLevelParameteriv = unsafePerformIO $ readIORef glrefGetTexLevelParameteriv+{-# INLINE glGetTexLevelParameteriv #-}+type FuntypeIsEnabled =+    GLenum ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsEnabled :: FunPtr FuntypeIsEnabled -> FuntypeIsEnabled+glrefIsEnabled :: IORef FuntypeIsEnabled+glrefIsEnabled = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsEnabled #-}+glIsEnabled :: FuntypeIsEnabled+glIsEnabled = unsafePerformIO $ readIORef glrefIsEnabled+{-# INLINE glIsEnabled #-}+type FuntypeDepthRange =+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDepthRange :: FunPtr FuntypeDepthRange -> FuntypeDepthRange+glrefDepthRange :: IORef FuntypeDepthRange+glrefDepthRange = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDepthRange #-}+glDepthRange :: FuntypeDepthRange+glDepthRange = unsafePerformIO $ readIORef glrefDepthRange+{-# INLINE glDepthRange #-}+type FuntypeViewport =+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynViewport :: FunPtr FuntypeViewport -> FuntypeViewport+glrefViewport :: IORef FuntypeViewport+glrefViewport = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefViewport #-}+glViewport :: FuntypeViewport+glViewport = unsafePerformIO $ readIORef glrefViewport+{-# INLINE glViewport #-}++-- GL_VERSION_1_1++type FuntypeDrawArrays =+    GLenum ->+    GLint ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawArrays :: FunPtr FuntypeDrawArrays -> FuntypeDrawArrays+glrefDrawArrays :: IORef FuntypeDrawArrays+glrefDrawArrays = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawArrays #-}+glDrawArrays :: FuntypeDrawArrays+glDrawArrays = unsafePerformIO $ readIORef glrefDrawArrays+{-# INLINE glDrawArrays #-}+type FuntypeDrawElements =+    GLenum ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawElements :: FunPtr FuntypeDrawElements -> FuntypeDrawElements+glrefDrawElements :: IORef FuntypeDrawElements+glrefDrawElements = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawElements #-}+glDrawElements :: FuntypeDrawElements+glDrawElements = unsafePerformIO $ readIORef glrefDrawElements+{-# INLINE glDrawElements #-}+type FuntypePolygonOffset =+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPolygonOffset :: FunPtr FuntypePolygonOffset -> FuntypePolygonOffset+glrefPolygonOffset :: IORef FuntypePolygonOffset+glrefPolygonOffset = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPolygonOffset #-}+glPolygonOffset :: FuntypePolygonOffset+glPolygonOffset = unsafePerformIO $ readIORef glrefPolygonOffset+{-# INLINE glPolygonOffset #-}+type FuntypeCopyTexImage1D =+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTexImage1D :: FunPtr FuntypeCopyTexImage1D -> FuntypeCopyTexImage1D+glrefCopyTexImage1D :: IORef FuntypeCopyTexImage1D+glrefCopyTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTexImage1D #-}+glCopyTexImage1D :: FuntypeCopyTexImage1D+glCopyTexImage1D = unsafePerformIO $ readIORef glrefCopyTexImage1D+{-# INLINE glCopyTexImage1D #-}+type FuntypeCopyTexImage2D =+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTexImage2D :: FunPtr FuntypeCopyTexImage2D -> FuntypeCopyTexImage2D+glrefCopyTexImage2D :: IORef FuntypeCopyTexImage2D+glrefCopyTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTexImage2D #-}+glCopyTexImage2D :: FuntypeCopyTexImage2D+glCopyTexImage2D = unsafePerformIO $ readIORef glrefCopyTexImage2D+{-# INLINE glCopyTexImage2D #-}+type FuntypeCopyTexSubImage1D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTexSubImage1D :: FunPtr FuntypeCopyTexSubImage1D -> FuntypeCopyTexSubImage1D+glrefCopyTexSubImage1D :: IORef FuntypeCopyTexSubImage1D+glrefCopyTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTexSubImage1D #-}+glCopyTexSubImage1D :: FuntypeCopyTexSubImage1D+glCopyTexSubImage1D = unsafePerformIO $ readIORef glrefCopyTexSubImage1D+{-# INLINE glCopyTexSubImage1D #-}+type FuntypeCopyTexSubImage2D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTexSubImage2D :: FunPtr FuntypeCopyTexSubImage2D -> FuntypeCopyTexSubImage2D+glrefCopyTexSubImage2D :: IORef FuntypeCopyTexSubImage2D+glrefCopyTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTexSubImage2D #-}+glCopyTexSubImage2D :: FuntypeCopyTexSubImage2D+glCopyTexSubImage2D = unsafePerformIO $ readIORef glrefCopyTexSubImage2D+{-# INLINE glCopyTexSubImage2D #-}+type FuntypeTexSubImage1D =+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexSubImage1D :: FunPtr FuntypeTexSubImage1D -> FuntypeTexSubImage1D+glrefTexSubImage1D :: IORef FuntypeTexSubImage1D+glrefTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexSubImage1D #-}+glTexSubImage1D :: FuntypeTexSubImage1D+glTexSubImage1D = unsafePerformIO $ readIORef glrefTexSubImage1D+{-# INLINE glTexSubImage1D #-}+type FuntypeTexSubImage2D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexSubImage2D :: FunPtr FuntypeTexSubImage2D -> FuntypeTexSubImage2D+glrefTexSubImage2D :: IORef FuntypeTexSubImage2D+glrefTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexSubImage2D #-}+glTexSubImage2D :: FuntypeTexSubImage2D+glTexSubImage2D = unsafePerformIO $ readIORef glrefTexSubImage2D+{-# INLINE glTexSubImage2D #-}+type FuntypeBindTexture =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindTexture :: FunPtr FuntypeBindTexture -> FuntypeBindTexture+glrefBindTexture :: IORef FuntypeBindTexture+glrefBindTexture = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindTexture #-}+glBindTexture :: FuntypeBindTexture+glBindTexture = unsafePerformIO $ readIORef glrefBindTexture+{-# INLINE glBindTexture #-}+type FuntypeDeleteTextures =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteTextures :: FunPtr FuntypeDeleteTextures -> FuntypeDeleteTextures+glrefDeleteTextures :: IORef FuntypeDeleteTextures+glrefDeleteTextures = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteTextures #-}+glDeleteTextures :: FuntypeDeleteTextures+glDeleteTextures = unsafePerformIO $ readIORef glrefDeleteTextures+{-# INLINE glDeleteTextures #-}+type FuntypeGenTextures =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenTextures :: FunPtr FuntypeGenTextures -> FuntypeGenTextures+glrefGenTextures :: IORef FuntypeGenTextures+glrefGenTextures = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenTextures #-}+glGenTextures :: FuntypeGenTextures+glGenTextures = unsafePerformIO $ readIORef glrefGenTextures+{-# INLINE glGenTextures #-}+type FuntypeIsTexture =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsTexture :: FunPtr FuntypeIsTexture -> FuntypeIsTexture+glrefIsTexture :: IORef FuntypeIsTexture+glrefIsTexture = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsTexture #-}+glIsTexture :: FuntypeIsTexture+glIsTexture = unsafePerformIO $ readIORef glrefIsTexture+{-# INLINE glIsTexture #-}++-- GL_VERSION_1_2++type FuntypeDrawRangeElements =+    GLenum ->+    GLuint ->+    GLuint ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawRangeElements :: FunPtr FuntypeDrawRangeElements -> FuntypeDrawRangeElements+glrefDrawRangeElements :: IORef FuntypeDrawRangeElements+glrefDrawRangeElements = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawRangeElements #-}+glDrawRangeElements :: FuntypeDrawRangeElements+glDrawRangeElements = unsafePerformIO $ readIORef glrefDrawRangeElements+{-# INLINE glDrawRangeElements #-}+type FuntypeTexImage3D =+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexImage3D :: FunPtr FuntypeTexImage3D -> FuntypeTexImage3D+glrefTexImage3D :: IORef FuntypeTexImage3D+glrefTexImage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexImage3D #-}+glTexImage3D :: FuntypeTexImage3D+glTexImage3D = unsafePerformIO $ readIORef glrefTexImage3D+{-# INLINE glTexImage3D #-}+type FuntypeTexSubImage3D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexSubImage3D :: FunPtr FuntypeTexSubImage3D -> FuntypeTexSubImage3D+glrefTexSubImage3D :: IORef FuntypeTexSubImage3D+glrefTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexSubImage3D #-}+glTexSubImage3D :: FuntypeTexSubImage3D+glTexSubImage3D = unsafePerformIO $ readIORef glrefTexSubImage3D+{-# INLINE glTexSubImage3D #-}+type FuntypeCopyTexSubImage3D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTexSubImage3D :: FunPtr FuntypeCopyTexSubImage3D -> FuntypeCopyTexSubImage3D+glrefCopyTexSubImage3D :: IORef FuntypeCopyTexSubImage3D+glrefCopyTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTexSubImage3D #-}+glCopyTexSubImage3D :: FuntypeCopyTexSubImage3D+glCopyTexSubImage3D = unsafePerformIO $ readIORef glrefCopyTexSubImage3D+{-# INLINE glCopyTexSubImage3D #-}++-- GL_VERSION_1_3++type FuntypeActiveTexture =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynActiveTexture :: FunPtr FuntypeActiveTexture -> FuntypeActiveTexture+glrefActiveTexture :: IORef FuntypeActiveTexture+glrefActiveTexture = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefActiveTexture #-}+glActiveTexture :: FuntypeActiveTexture+glActiveTexture = unsafePerformIO $ readIORef glrefActiveTexture+{-# INLINE glActiveTexture #-}+type FuntypeSampleCoverage =+    GLfloat ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSampleCoverage :: FunPtr FuntypeSampleCoverage -> FuntypeSampleCoverage+glrefSampleCoverage :: IORef FuntypeSampleCoverage+glrefSampleCoverage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSampleCoverage #-}+glSampleCoverage :: FuntypeSampleCoverage+glSampleCoverage = unsafePerformIO $ readIORef glrefSampleCoverage+{-# INLINE glSampleCoverage #-}+type FuntypeCompressedTexImage3D =+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexImage3D :: FunPtr FuntypeCompressedTexImage3D -> FuntypeCompressedTexImage3D+glrefCompressedTexImage3D :: IORef FuntypeCompressedTexImage3D+glrefCompressedTexImage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexImage3D #-}+glCompressedTexImage3D :: FuntypeCompressedTexImage3D+glCompressedTexImage3D = unsafePerformIO $ readIORef glrefCompressedTexImage3D+{-# INLINE glCompressedTexImage3D #-}+type FuntypeCompressedTexImage2D =+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexImage2D :: FunPtr FuntypeCompressedTexImage2D -> FuntypeCompressedTexImage2D+glrefCompressedTexImage2D :: IORef FuntypeCompressedTexImage2D+glrefCompressedTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexImage2D #-}+glCompressedTexImage2D :: FuntypeCompressedTexImage2D+glCompressedTexImage2D = unsafePerformIO $ readIORef glrefCompressedTexImage2D+{-# INLINE glCompressedTexImage2D #-}+type FuntypeCompressedTexImage1D =+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexImage1D :: FunPtr FuntypeCompressedTexImage1D -> FuntypeCompressedTexImage1D+glrefCompressedTexImage1D :: IORef FuntypeCompressedTexImage1D+glrefCompressedTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexImage1D #-}+glCompressedTexImage1D :: FuntypeCompressedTexImage1D+glCompressedTexImage1D = unsafePerformIO $ readIORef glrefCompressedTexImage1D+{-# INLINE glCompressedTexImage1D #-}+type FuntypeCompressedTexSubImage3D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexSubImage3D :: FunPtr FuntypeCompressedTexSubImage3D -> FuntypeCompressedTexSubImage3D+glrefCompressedTexSubImage3D :: IORef FuntypeCompressedTexSubImage3D+glrefCompressedTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexSubImage3D #-}+glCompressedTexSubImage3D :: FuntypeCompressedTexSubImage3D+glCompressedTexSubImage3D = unsafePerformIO $ readIORef glrefCompressedTexSubImage3D+{-# INLINE glCompressedTexSubImage3D #-}+type FuntypeCompressedTexSubImage2D =+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexSubImage2D :: FunPtr FuntypeCompressedTexSubImage2D -> FuntypeCompressedTexSubImage2D+glrefCompressedTexSubImage2D :: IORef FuntypeCompressedTexSubImage2D+glrefCompressedTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexSubImage2D #-}+glCompressedTexSubImage2D :: FuntypeCompressedTexSubImage2D+glCompressedTexSubImage2D = unsafePerformIO $ readIORef glrefCompressedTexSubImage2D+{-# INLINE glCompressedTexSubImage2D #-}+type FuntypeCompressedTexSubImage1D =+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTexSubImage1D :: FunPtr FuntypeCompressedTexSubImage1D -> FuntypeCompressedTexSubImage1D+glrefCompressedTexSubImage1D :: IORef FuntypeCompressedTexSubImage1D+glrefCompressedTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTexSubImage1D #-}+glCompressedTexSubImage1D :: FuntypeCompressedTexSubImage1D+glCompressedTexSubImage1D = unsafePerformIO $ readIORef glrefCompressedTexSubImage1D+{-# INLINE glCompressedTexSubImage1D #-}+type FuntypeGetCompressedTexImage =+    GLenum ->+    GLint ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetCompressedTexImage :: FunPtr FuntypeGetCompressedTexImage -> FuntypeGetCompressedTexImage+glrefGetCompressedTexImage :: IORef FuntypeGetCompressedTexImage+glrefGetCompressedTexImage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetCompressedTexImage #-}+glGetCompressedTexImage :: FuntypeGetCompressedTexImage+glGetCompressedTexImage = unsafePerformIO $ readIORef glrefGetCompressedTexImage+{-# INLINE glGetCompressedTexImage #-}++-- GL_VERSION_1_4++type FuntypeBlendFuncSeparate =+    GLenum ->+    GLenum ->+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlendFuncSeparate :: FunPtr FuntypeBlendFuncSeparate -> FuntypeBlendFuncSeparate+glrefBlendFuncSeparate :: IORef FuntypeBlendFuncSeparate+glrefBlendFuncSeparate = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlendFuncSeparate #-}+glBlendFuncSeparate :: FuntypeBlendFuncSeparate+glBlendFuncSeparate = unsafePerformIO $ readIORef glrefBlendFuncSeparate+{-# INLINE glBlendFuncSeparate #-}+type FuntypeMultiDrawArrays =+    GLenum ->+    Ptr (GLint) ->+    Ptr (GLsizei) ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiDrawArrays :: FunPtr FuntypeMultiDrawArrays -> FuntypeMultiDrawArrays+glrefMultiDrawArrays :: IORef FuntypeMultiDrawArrays+glrefMultiDrawArrays = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiDrawArrays #-}+glMultiDrawArrays :: FuntypeMultiDrawArrays+glMultiDrawArrays = unsafePerformIO $ readIORef glrefMultiDrawArrays+{-# INLINE glMultiDrawArrays #-}+type FuntypeMultiDrawElements =+    GLenum ->+    Ptr (GLsizei) ->+    GLenum ->+    Ptr (Ptr ()) ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiDrawElements :: FunPtr FuntypeMultiDrawElements -> FuntypeMultiDrawElements+glrefMultiDrawElements :: IORef FuntypeMultiDrawElements+glrefMultiDrawElements = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiDrawElements #-}+glMultiDrawElements :: FuntypeMultiDrawElements+glMultiDrawElements = unsafePerformIO $ readIORef glrefMultiDrawElements+{-# INLINE glMultiDrawElements #-}+type FuntypePointParameterf =+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPointParameterf :: FunPtr FuntypePointParameterf -> FuntypePointParameterf+glrefPointParameterf :: IORef FuntypePointParameterf+glrefPointParameterf = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPointParameterf #-}+glPointParameterf :: FuntypePointParameterf+glPointParameterf = unsafePerformIO $ readIORef glrefPointParameterf+{-# INLINE glPointParameterf #-}+type FuntypePointParameterfv =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPointParameterfv :: FunPtr FuntypePointParameterfv -> FuntypePointParameterfv+glrefPointParameterfv :: IORef FuntypePointParameterfv+glrefPointParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPointParameterfv #-}+glPointParameterfv :: FuntypePointParameterfv+glPointParameterfv = unsafePerformIO $ readIORef glrefPointParameterfv+{-# INLINE glPointParameterfv #-}+type FuntypePointParameteri =+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPointParameteri :: FunPtr FuntypePointParameteri -> FuntypePointParameteri+glrefPointParameteri :: IORef FuntypePointParameteri+glrefPointParameteri = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPointParameteri #-}+glPointParameteri :: FuntypePointParameteri+glPointParameteri = unsafePerformIO $ readIORef glrefPointParameteri+{-# INLINE glPointParameteri #-}+type FuntypePointParameteriv =+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPointParameteriv :: FunPtr FuntypePointParameteriv -> FuntypePointParameteriv+glrefPointParameteriv :: IORef FuntypePointParameteriv+glrefPointParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPointParameteriv #-}+glPointParameteriv :: FuntypePointParameteriv+glPointParameteriv = unsafePerformIO $ readIORef glrefPointParameteriv+{-# INLINE glPointParameteriv #-}+type FuntypeBlendColor =+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlendColor :: FunPtr FuntypeBlendColor -> FuntypeBlendColor+glrefBlendColor :: IORef FuntypeBlendColor+glrefBlendColor = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlendColor #-}+glBlendColor :: FuntypeBlendColor+glBlendColor = unsafePerformIO $ readIORef glrefBlendColor+{-# INLINE glBlendColor #-}+type FuntypeBlendEquation =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlendEquation :: FunPtr FuntypeBlendEquation -> FuntypeBlendEquation+glrefBlendEquation :: IORef FuntypeBlendEquation+glrefBlendEquation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlendEquation #-}+glBlendEquation :: FuntypeBlendEquation+glBlendEquation = unsafePerformIO $ readIORef glrefBlendEquation+{-# INLINE glBlendEquation #-}++-- GL_VERSION_1_5++type FuntypeGenQueries =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenQueries :: FunPtr FuntypeGenQueries -> FuntypeGenQueries+glrefGenQueries :: IORef FuntypeGenQueries+glrefGenQueries = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenQueries #-}+glGenQueries :: FuntypeGenQueries+glGenQueries = unsafePerformIO $ readIORef glrefGenQueries+{-# INLINE glGenQueries #-}+type FuntypeDeleteQueries =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteQueries :: FunPtr FuntypeDeleteQueries -> FuntypeDeleteQueries+glrefDeleteQueries :: IORef FuntypeDeleteQueries+glrefDeleteQueries = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteQueries #-}+glDeleteQueries :: FuntypeDeleteQueries+glDeleteQueries = unsafePerformIO $ readIORef glrefDeleteQueries+{-# INLINE glDeleteQueries #-}+type FuntypeIsQuery =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsQuery :: FunPtr FuntypeIsQuery -> FuntypeIsQuery+glrefIsQuery :: IORef FuntypeIsQuery+glrefIsQuery = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsQuery #-}+glIsQuery :: FuntypeIsQuery+glIsQuery = unsafePerformIO $ readIORef glrefIsQuery+{-# INLINE glIsQuery #-}+type FuntypeBeginQuery =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBeginQuery :: FunPtr FuntypeBeginQuery -> FuntypeBeginQuery+glrefBeginQuery :: IORef FuntypeBeginQuery+glrefBeginQuery = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBeginQuery #-}+glBeginQuery :: FuntypeBeginQuery+glBeginQuery = unsafePerformIO $ readIORef glrefBeginQuery+{-# INLINE glBeginQuery #-}+type FuntypeEndQuery =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEndQuery :: FunPtr FuntypeEndQuery -> FuntypeEndQuery+glrefEndQuery :: IORef FuntypeEndQuery+glrefEndQuery = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEndQuery #-}+glEndQuery :: FuntypeEndQuery+glEndQuery = unsafePerformIO $ readIORef glrefEndQuery+{-# INLINE glEndQuery #-}+type FuntypeGetQueryiv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetQueryiv :: FunPtr FuntypeGetQueryiv -> FuntypeGetQueryiv+glrefGetQueryiv :: IORef FuntypeGetQueryiv+glrefGetQueryiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetQueryiv #-}+glGetQueryiv :: FuntypeGetQueryiv+glGetQueryiv = unsafePerformIO $ readIORef glrefGetQueryiv+{-# INLINE glGetQueryiv #-}+type FuntypeGetQueryObjectiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetQueryObjectiv :: FunPtr FuntypeGetQueryObjectiv -> FuntypeGetQueryObjectiv+glrefGetQueryObjectiv :: IORef FuntypeGetQueryObjectiv+glrefGetQueryObjectiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetQueryObjectiv #-}+glGetQueryObjectiv :: FuntypeGetQueryObjectiv+glGetQueryObjectiv = unsafePerformIO $ readIORef glrefGetQueryObjectiv+{-# INLINE glGetQueryObjectiv #-}+type FuntypeGetQueryObjectuiv =+    GLuint ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetQueryObjectuiv :: FunPtr FuntypeGetQueryObjectuiv -> FuntypeGetQueryObjectuiv+glrefGetQueryObjectuiv :: IORef FuntypeGetQueryObjectuiv+glrefGetQueryObjectuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetQueryObjectuiv #-}+glGetQueryObjectuiv :: FuntypeGetQueryObjectuiv+glGetQueryObjectuiv = unsafePerformIO $ readIORef glrefGetQueryObjectuiv+{-# INLINE glGetQueryObjectuiv #-}+type FuntypeBindBuffer =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindBuffer :: FunPtr FuntypeBindBuffer -> FuntypeBindBuffer+glrefBindBuffer :: IORef FuntypeBindBuffer+glrefBindBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindBuffer #-}+glBindBuffer :: FuntypeBindBuffer+glBindBuffer = unsafePerformIO $ readIORef glrefBindBuffer+{-# INLINE glBindBuffer #-}+type FuntypeDeleteBuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteBuffers :: FunPtr FuntypeDeleteBuffers -> FuntypeDeleteBuffers+glrefDeleteBuffers :: IORef FuntypeDeleteBuffers+glrefDeleteBuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteBuffers #-}+glDeleteBuffers :: FuntypeDeleteBuffers+glDeleteBuffers = unsafePerformIO $ readIORef glrefDeleteBuffers+{-# INLINE glDeleteBuffers #-}+type FuntypeGenBuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenBuffers :: FunPtr FuntypeGenBuffers -> FuntypeGenBuffers+glrefGenBuffers :: IORef FuntypeGenBuffers+glrefGenBuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenBuffers #-}+glGenBuffers :: FuntypeGenBuffers+glGenBuffers = unsafePerformIO $ readIORef glrefGenBuffers+{-# INLINE glGenBuffers #-}+type FuntypeIsBuffer =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsBuffer :: FunPtr FuntypeIsBuffer -> FuntypeIsBuffer+glrefIsBuffer :: IORef FuntypeIsBuffer+glrefIsBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsBuffer #-}+glIsBuffer :: FuntypeIsBuffer+glIsBuffer = unsafePerformIO $ readIORef glrefIsBuffer+{-# INLINE glIsBuffer #-}+type FuntypeBufferData =+    GLenum ->+    GLsizeiptr ->+    Ptr () ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBufferData :: FunPtr FuntypeBufferData -> FuntypeBufferData+glrefBufferData :: IORef FuntypeBufferData+glrefBufferData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBufferData #-}+glBufferData :: FuntypeBufferData+glBufferData = unsafePerformIO $ readIORef glrefBufferData+{-# INLINE glBufferData #-}+type FuntypeBufferSubData =+    GLenum ->+    GLintptr ->+    GLsizeiptr ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBufferSubData :: FunPtr FuntypeBufferSubData -> FuntypeBufferSubData+glrefBufferSubData :: IORef FuntypeBufferSubData+glrefBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBufferSubData #-}+glBufferSubData :: FuntypeBufferSubData+glBufferSubData = unsafePerformIO $ readIORef glrefBufferSubData+{-# INLINE glBufferSubData #-}+type FuntypeGetBufferSubData =+    GLenum ->+    GLintptr ->+    GLsizeiptr ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBufferSubData :: FunPtr FuntypeGetBufferSubData -> FuntypeGetBufferSubData+glrefGetBufferSubData :: IORef FuntypeGetBufferSubData+glrefGetBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBufferSubData #-}+glGetBufferSubData :: FuntypeGetBufferSubData+glGetBufferSubData = unsafePerformIO $ readIORef glrefGetBufferSubData+{-# INLINE glGetBufferSubData #-}+type FuntypeMapBuffer =+    GLenum ->+    GLenum ->+    IO ( Ptr () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMapBuffer :: FunPtr FuntypeMapBuffer -> FuntypeMapBuffer+glrefMapBuffer :: IORef FuntypeMapBuffer+glrefMapBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMapBuffer #-}+glMapBuffer :: FuntypeMapBuffer+glMapBuffer = unsafePerformIO $ readIORef glrefMapBuffer+{-# INLINE glMapBuffer #-}+type FuntypeUnmapBuffer =+    GLenum ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUnmapBuffer :: FunPtr FuntypeUnmapBuffer -> FuntypeUnmapBuffer+glrefUnmapBuffer :: IORef FuntypeUnmapBuffer+glrefUnmapBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUnmapBuffer #-}+glUnmapBuffer :: FuntypeUnmapBuffer+glUnmapBuffer = unsafePerformIO $ readIORef glrefUnmapBuffer+{-# INLINE glUnmapBuffer #-}+type FuntypeGetBufferParameteriv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBufferParameteriv :: FunPtr FuntypeGetBufferParameteriv -> FuntypeGetBufferParameteriv+glrefGetBufferParameteriv :: IORef FuntypeGetBufferParameteriv+glrefGetBufferParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBufferParameteriv #-}+glGetBufferParameteriv :: FuntypeGetBufferParameteriv+glGetBufferParameteriv = unsafePerformIO $ readIORef glrefGetBufferParameteriv+{-# INLINE glGetBufferParameteriv #-}+type FuntypeGetBufferPointerv =+    GLenum ->+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBufferPointerv :: FunPtr FuntypeGetBufferPointerv -> FuntypeGetBufferPointerv+glrefGetBufferPointerv :: IORef FuntypeGetBufferPointerv+glrefGetBufferPointerv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBufferPointerv #-}+glGetBufferPointerv :: FuntypeGetBufferPointerv+glGetBufferPointerv = unsafePerformIO $ readIORef glrefGetBufferPointerv+{-# INLINE glGetBufferPointerv #-}++-- GL_VERSION_2_0++type FuntypeBlendEquationSeparate =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlendEquationSeparate :: FunPtr FuntypeBlendEquationSeparate -> FuntypeBlendEquationSeparate+glrefBlendEquationSeparate :: IORef FuntypeBlendEquationSeparate+glrefBlendEquationSeparate = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlendEquationSeparate #-}+glBlendEquationSeparate :: FuntypeBlendEquationSeparate+glBlendEquationSeparate = unsafePerformIO $ readIORef glrefBlendEquationSeparate+{-# INLINE glBlendEquationSeparate #-}+type FuntypeDrawBuffers =+    GLsizei ->+    Ptr (GLenum) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawBuffers :: FunPtr FuntypeDrawBuffers -> FuntypeDrawBuffers+glrefDrawBuffers :: IORef FuntypeDrawBuffers+glrefDrawBuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawBuffers #-}+glDrawBuffers :: FuntypeDrawBuffers+glDrawBuffers = unsafePerformIO $ readIORef glrefDrawBuffers+{-# INLINE glDrawBuffers #-}+type FuntypeStencilOpSeparate =+    GLenum ->+    GLenum ->+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilOpSeparate :: FunPtr FuntypeStencilOpSeparate -> FuntypeStencilOpSeparate+glrefStencilOpSeparate :: IORef FuntypeStencilOpSeparate+glrefStencilOpSeparate = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilOpSeparate #-}+glStencilOpSeparate :: FuntypeStencilOpSeparate+glStencilOpSeparate = unsafePerformIO $ readIORef glrefStencilOpSeparate+{-# INLINE glStencilOpSeparate #-}+type FuntypeStencilFuncSeparate =+    GLenum ->+    GLenum ->+    GLint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilFuncSeparate :: FunPtr FuntypeStencilFuncSeparate -> FuntypeStencilFuncSeparate+glrefStencilFuncSeparate :: IORef FuntypeStencilFuncSeparate+glrefStencilFuncSeparate = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilFuncSeparate #-}+glStencilFuncSeparate :: FuntypeStencilFuncSeparate+glStencilFuncSeparate = unsafePerformIO $ readIORef glrefStencilFuncSeparate+{-# INLINE glStencilFuncSeparate #-}+type FuntypeStencilMaskSeparate =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynStencilMaskSeparate :: FunPtr FuntypeStencilMaskSeparate -> FuntypeStencilMaskSeparate+glrefStencilMaskSeparate :: IORef FuntypeStencilMaskSeparate+glrefStencilMaskSeparate = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefStencilMaskSeparate #-}+glStencilMaskSeparate :: FuntypeStencilMaskSeparate+glStencilMaskSeparate = unsafePerformIO $ readIORef glrefStencilMaskSeparate+{-# INLINE glStencilMaskSeparate #-}+type FuntypeAttachShader =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynAttachShader :: FunPtr FuntypeAttachShader -> FuntypeAttachShader+glrefAttachShader :: IORef FuntypeAttachShader+glrefAttachShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefAttachShader #-}+glAttachShader :: FuntypeAttachShader+glAttachShader = unsafePerformIO $ readIORef glrefAttachShader+{-# INLINE glAttachShader #-}+type FuntypeBindAttribLocation =+    GLuint ->+    GLuint ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindAttribLocation :: FunPtr FuntypeBindAttribLocation -> FuntypeBindAttribLocation+glrefBindAttribLocation :: IORef FuntypeBindAttribLocation+glrefBindAttribLocation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindAttribLocation #-}+glBindAttribLocation :: FuntypeBindAttribLocation+glBindAttribLocation = unsafePerformIO $ readIORef glrefBindAttribLocation+{-# INLINE glBindAttribLocation #-}+type FuntypeCompileShader =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompileShader :: FunPtr FuntypeCompileShader -> FuntypeCompileShader+glrefCompileShader :: IORef FuntypeCompileShader+glrefCompileShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompileShader #-}+glCompileShader :: FuntypeCompileShader+glCompileShader = unsafePerformIO $ readIORef glrefCompileShader+{-# INLINE glCompileShader #-}+type FuntypeCreateProgram =+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCreateProgram :: FunPtr FuntypeCreateProgram -> FuntypeCreateProgram+glrefCreateProgram :: IORef FuntypeCreateProgram+glrefCreateProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCreateProgram #-}+glCreateProgram :: FuntypeCreateProgram+glCreateProgram = unsafePerformIO $ readIORef glrefCreateProgram+{-# INLINE glCreateProgram #-}+type FuntypeCreateShader =+    GLenum ->+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCreateShader :: FunPtr FuntypeCreateShader -> FuntypeCreateShader+glrefCreateShader :: IORef FuntypeCreateShader+glrefCreateShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCreateShader #-}+glCreateShader :: FuntypeCreateShader+glCreateShader = unsafePerformIO $ readIORef glrefCreateShader+{-# INLINE glCreateShader #-}+type FuntypeDeleteProgram =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteProgram :: FunPtr FuntypeDeleteProgram -> FuntypeDeleteProgram+glrefDeleteProgram :: IORef FuntypeDeleteProgram+glrefDeleteProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteProgram #-}+glDeleteProgram :: FuntypeDeleteProgram+glDeleteProgram = unsafePerformIO $ readIORef glrefDeleteProgram+{-# INLINE glDeleteProgram #-}+type FuntypeDeleteShader =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteShader :: FunPtr FuntypeDeleteShader -> FuntypeDeleteShader+glrefDeleteShader :: IORef FuntypeDeleteShader+glrefDeleteShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteShader #-}+glDeleteShader :: FuntypeDeleteShader+glDeleteShader = unsafePerformIO $ readIORef glrefDeleteShader+{-# INLINE glDeleteShader #-}+type FuntypeDetachShader =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDetachShader :: FunPtr FuntypeDetachShader -> FuntypeDetachShader+glrefDetachShader :: IORef FuntypeDetachShader+glrefDetachShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDetachShader #-}+glDetachShader :: FuntypeDetachShader+glDetachShader = unsafePerformIO $ readIORef glrefDetachShader+{-# INLINE glDetachShader #-}+type FuntypeDisableVertexAttribArray =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableVertexAttribArray :: FunPtr FuntypeDisableVertexAttribArray -> FuntypeDisableVertexAttribArray+glrefDisableVertexAttribArray :: IORef FuntypeDisableVertexAttribArray+glrefDisableVertexAttribArray = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableVertexAttribArray #-}+glDisableVertexAttribArray :: FuntypeDisableVertexAttribArray+glDisableVertexAttribArray = unsafePerformIO $ readIORef glrefDisableVertexAttribArray+{-# INLINE glDisableVertexAttribArray #-}+type FuntypeEnableVertexAttribArray =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableVertexAttribArray :: FunPtr FuntypeEnableVertexAttribArray -> FuntypeEnableVertexAttribArray+glrefEnableVertexAttribArray :: IORef FuntypeEnableVertexAttribArray+glrefEnableVertexAttribArray = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableVertexAttribArray #-}+glEnableVertexAttribArray :: FuntypeEnableVertexAttribArray+glEnableVertexAttribArray = unsafePerformIO $ readIORef glrefEnableVertexAttribArray+{-# INLINE glEnableVertexAttribArray #-}+type FuntypeGetActiveAttrib =+    GLuint ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLint) ->+    Ptr (GLenum) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveAttrib :: FunPtr FuntypeGetActiveAttrib -> FuntypeGetActiveAttrib+glrefGetActiveAttrib :: IORef FuntypeGetActiveAttrib+glrefGetActiveAttrib = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveAttrib #-}+glGetActiveAttrib :: FuntypeGetActiveAttrib+glGetActiveAttrib = unsafePerformIO $ readIORef glrefGetActiveAttrib+{-# INLINE glGetActiveAttrib #-}+type FuntypeGetActiveUniform =+    GLuint ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLint) ->+    Ptr (GLenum) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveUniform :: FunPtr FuntypeGetActiveUniform -> FuntypeGetActiveUniform+glrefGetActiveUniform :: IORef FuntypeGetActiveUniform+glrefGetActiveUniform = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveUniform #-}+glGetActiveUniform :: FuntypeGetActiveUniform+glGetActiveUniform = unsafePerformIO $ readIORef glrefGetActiveUniform+{-# INLINE glGetActiveUniform #-}+type FuntypeGetAttachedShaders =+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetAttachedShaders :: FunPtr FuntypeGetAttachedShaders -> FuntypeGetAttachedShaders+glrefGetAttachedShaders :: IORef FuntypeGetAttachedShaders+glrefGetAttachedShaders = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetAttachedShaders #-}+glGetAttachedShaders :: FuntypeGetAttachedShaders+glGetAttachedShaders = unsafePerformIO $ readIORef glrefGetAttachedShaders+{-# INLINE glGetAttachedShaders #-}+type FuntypeGetAttribLocation =+    GLuint ->+    Ptr (GLchar) ->+    IO ( GLint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetAttribLocation :: FunPtr FuntypeGetAttribLocation -> FuntypeGetAttribLocation+glrefGetAttribLocation :: IORef FuntypeGetAttribLocation+glrefGetAttribLocation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetAttribLocation #-}+glGetAttribLocation :: FuntypeGetAttribLocation+glGetAttribLocation = unsafePerformIO $ readIORef glrefGetAttribLocation+{-# INLINE glGetAttribLocation #-}+type FuntypeGetProgramiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetProgramiv :: FunPtr FuntypeGetProgramiv -> FuntypeGetProgramiv+glrefGetProgramiv :: IORef FuntypeGetProgramiv+glrefGetProgramiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetProgramiv #-}+glGetProgramiv :: FuntypeGetProgramiv+glGetProgramiv = unsafePerformIO $ readIORef glrefGetProgramiv+{-# INLINE glGetProgramiv #-}+type FuntypeGetProgramInfoLog =+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetProgramInfoLog :: FunPtr FuntypeGetProgramInfoLog -> FuntypeGetProgramInfoLog+glrefGetProgramInfoLog :: IORef FuntypeGetProgramInfoLog+glrefGetProgramInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetProgramInfoLog #-}+glGetProgramInfoLog :: FuntypeGetProgramInfoLog+glGetProgramInfoLog = unsafePerformIO $ readIORef glrefGetProgramInfoLog+{-# INLINE glGetProgramInfoLog #-}+type FuntypeGetShaderiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetShaderiv :: FunPtr FuntypeGetShaderiv -> FuntypeGetShaderiv+glrefGetShaderiv :: IORef FuntypeGetShaderiv+glrefGetShaderiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetShaderiv #-}+glGetShaderiv :: FuntypeGetShaderiv+glGetShaderiv = unsafePerformIO $ readIORef glrefGetShaderiv+{-# INLINE glGetShaderiv #-}+type FuntypeGetShaderInfoLog =+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetShaderInfoLog :: FunPtr FuntypeGetShaderInfoLog -> FuntypeGetShaderInfoLog+glrefGetShaderInfoLog :: IORef FuntypeGetShaderInfoLog+glrefGetShaderInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetShaderInfoLog #-}+glGetShaderInfoLog :: FuntypeGetShaderInfoLog+glGetShaderInfoLog = unsafePerformIO $ readIORef glrefGetShaderInfoLog+{-# INLINE glGetShaderInfoLog #-}+type FuntypeGetShaderSource =+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetShaderSource :: FunPtr FuntypeGetShaderSource -> FuntypeGetShaderSource+glrefGetShaderSource :: IORef FuntypeGetShaderSource+glrefGetShaderSource = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetShaderSource #-}+glGetShaderSource :: FuntypeGetShaderSource+glGetShaderSource = unsafePerformIO $ readIORef glrefGetShaderSource+{-# INLINE glGetShaderSource #-}+type FuntypeGetUniformLocation =+    GLuint ->+    Ptr (GLchar) ->+    IO ( GLint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformLocation :: FunPtr FuntypeGetUniformLocation -> FuntypeGetUniformLocation+glrefGetUniformLocation :: IORef FuntypeGetUniformLocation+glrefGetUniformLocation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformLocation #-}+glGetUniformLocation :: FuntypeGetUniformLocation+glGetUniformLocation = unsafePerformIO $ readIORef glrefGetUniformLocation+{-# INLINE glGetUniformLocation #-}+type FuntypeGetUniformfv =+    GLuint ->+    GLint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformfv :: FunPtr FuntypeGetUniformfv -> FuntypeGetUniformfv+glrefGetUniformfv :: IORef FuntypeGetUniformfv+glrefGetUniformfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformfv #-}+glGetUniformfv :: FuntypeGetUniformfv+glGetUniformfv = unsafePerformIO $ readIORef glrefGetUniformfv+{-# INLINE glGetUniformfv #-}+type FuntypeGetUniformiv =+    GLuint ->+    GLint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformiv :: FunPtr FuntypeGetUniformiv -> FuntypeGetUniformiv+glrefGetUniformiv :: IORef FuntypeGetUniformiv+glrefGetUniformiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformiv #-}+glGetUniformiv :: FuntypeGetUniformiv+glGetUniformiv = unsafePerformIO $ readIORef glrefGetUniformiv+{-# INLINE glGetUniformiv #-}+type FuntypeGetVertexAttribdv =+    GLuint ->+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribdv :: FunPtr FuntypeGetVertexAttribdv -> FuntypeGetVertexAttribdv+glrefGetVertexAttribdv :: IORef FuntypeGetVertexAttribdv+glrefGetVertexAttribdv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribdv #-}+glGetVertexAttribdv :: FuntypeGetVertexAttribdv+glGetVertexAttribdv = unsafePerformIO $ readIORef glrefGetVertexAttribdv+{-# INLINE glGetVertexAttribdv #-}+type FuntypeGetVertexAttribfv =+    GLuint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribfv :: FunPtr FuntypeGetVertexAttribfv -> FuntypeGetVertexAttribfv+glrefGetVertexAttribfv :: IORef FuntypeGetVertexAttribfv+glrefGetVertexAttribfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribfv #-}+glGetVertexAttribfv :: FuntypeGetVertexAttribfv+glGetVertexAttribfv = unsafePerformIO $ readIORef glrefGetVertexAttribfv+{-# INLINE glGetVertexAttribfv #-}+type FuntypeGetVertexAttribiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribiv :: FunPtr FuntypeGetVertexAttribiv -> FuntypeGetVertexAttribiv+glrefGetVertexAttribiv :: IORef FuntypeGetVertexAttribiv+glrefGetVertexAttribiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribiv #-}+glGetVertexAttribiv :: FuntypeGetVertexAttribiv+glGetVertexAttribiv = unsafePerformIO $ readIORef glrefGetVertexAttribiv+{-# INLINE glGetVertexAttribiv #-}+type FuntypeGetVertexAttribPointerv =+    GLuint ->+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribPointerv :: FunPtr FuntypeGetVertexAttribPointerv -> FuntypeGetVertexAttribPointerv+glrefGetVertexAttribPointerv :: IORef FuntypeGetVertexAttribPointerv+glrefGetVertexAttribPointerv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribPointerv #-}+glGetVertexAttribPointerv :: FuntypeGetVertexAttribPointerv+glGetVertexAttribPointerv = unsafePerformIO $ readIORef glrefGetVertexAttribPointerv+{-# INLINE glGetVertexAttribPointerv #-}+type FuntypeIsProgram =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsProgram :: FunPtr FuntypeIsProgram -> FuntypeIsProgram+glrefIsProgram :: IORef FuntypeIsProgram+glrefIsProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsProgram #-}+glIsProgram :: FuntypeIsProgram+glIsProgram = unsafePerformIO $ readIORef glrefIsProgram+{-# INLINE glIsProgram #-}+type FuntypeIsShader =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsShader :: FunPtr FuntypeIsShader -> FuntypeIsShader+glrefIsShader :: IORef FuntypeIsShader+glrefIsShader = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsShader #-}+glIsShader :: FuntypeIsShader+glIsShader = unsafePerformIO $ readIORef glrefIsShader+{-# INLINE glIsShader #-}+type FuntypeLinkProgram =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynLinkProgram :: FunPtr FuntypeLinkProgram -> FuntypeLinkProgram+glrefLinkProgram :: IORef FuntypeLinkProgram+glrefLinkProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefLinkProgram #-}+glLinkProgram :: FuntypeLinkProgram+glLinkProgram = unsafePerformIO $ readIORef glrefLinkProgram+{-# INLINE glLinkProgram #-}+type FuntypeShaderSource =+    GLuint ->+    GLsizei ->+    Ptr (Ptr (GLchar)) ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynShaderSource :: FunPtr FuntypeShaderSource -> FuntypeShaderSource+glrefShaderSource :: IORef FuntypeShaderSource+glrefShaderSource = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefShaderSource #-}+glShaderSource :: FuntypeShaderSource+glShaderSource = unsafePerformIO $ readIORef glrefShaderSource+{-# INLINE glShaderSource #-}+type FuntypeUseProgram =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUseProgram :: FunPtr FuntypeUseProgram -> FuntypeUseProgram+glrefUseProgram :: IORef FuntypeUseProgram+glrefUseProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUseProgram #-}+glUseProgram :: FuntypeUseProgram+glUseProgram = unsafePerformIO $ readIORef glrefUseProgram+{-# INLINE glUseProgram #-}+type FuntypeUniform1f =+    GLint ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1f :: FunPtr FuntypeUniform1f -> FuntypeUniform1f+glrefUniform1f :: IORef FuntypeUniform1f+glrefUniform1f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1f #-}+glUniform1f :: FuntypeUniform1f+glUniform1f = unsafePerformIO $ readIORef glrefUniform1f+{-# INLINE glUniform1f #-}+type FuntypeUniform2f =+    GLint ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2f :: FunPtr FuntypeUniform2f -> FuntypeUniform2f+glrefUniform2f :: IORef FuntypeUniform2f+glrefUniform2f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2f #-}+glUniform2f :: FuntypeUniform2f+glUniform2f = unsafePerformIO $ readIORef glrefUniform2f+{-# INLINE glUniform2f #-}+type FuntypeUniform3f =+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3f :: FunPtr FuntypeUniform3f -> FuntypeUniform3f+glrefUniform3f :: IORef FuntypeUniform3f+glrefUniform3f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3f #-}+glUniform3f :: FuntypeUniform3f+glUniform3f = unsafePerformIO $ readIORef glrefUniform3f+{-# INLINE glUniform3f #-}+type FuntypeUniform4f =+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4f :: FunPtr FuntypeUniform4f -> FuntypeUniform4f+glrefUniform4f :: IORef FuntypeUniform4f+glrefUniform4f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4f #-}+glUniform4f :: FuntypeUniform4f+glUniform4f = unsafePerformIO $ readIORef glrefUniform4f+{-# INLINE glUniform4f #-}+type FuntypeUniform1i =+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1i :: FunPtr FuntypeUniform1i -> FuntypeUniform1i+glrefUniform1i :: IORef FuntypeUniform1i+glrefUniform1i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1i #-}+glUniform1i :: FuntypeUniform1i+glUniform1i = unsafePerformIO $ readIORef glrefUniform1i+{-# INLINE glUniform1i #-}+type FuntypeUniform2i =+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2i :: FunPtr FuntypeUniform2i -> FuntypeUniform2i+glrefUniform2i :: IORef FuntypeUniform2i+glrefUniform2i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2i #-}+glUniform2i :: FuntypeUniform2i+glUniform2i = unsafePerformIO $ readIORef glrefUniform2i+{-# INLINE glUniform2i #-}+type FuntypeUniform3i =+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3i :: FunPtr FuntypeUniform3i -> FuntypeUniform3i+glrefUniform3i :: IORef FuntypeUniform3i+glrefUniform3i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3i #-}+glUniform3i :: FuntypeUniform3i+glUniform3i = unsafePerformIO $ readIORef glrefUniform3i+{-# INLINE glUniform3i #-}+type FuntypeUniform4i =+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4i :: FunPtr FuntypeUniform4i -> FuntypeUniform4i+glrefUniform4i :: IORef FuntypeUniform4i+glrefUniform4i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4i #-}+glUniform4i :: FuntypeUniform4i+glUniform4i = unsafePerformIO $ readIORef glrefUniform4i+{-# INLINE glUniform4i #-}+type FuntypeUniform1fv =+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1fv :: FunPtr FuntypeUniform1fv -> FuntypeUniform1fv+glrefUniform1fv :: IORef FuntypeUniform1fv+glrefUniform1fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1fv #-}+glUniform1fv :: FuntypeUniform1fv+glUniform1fv = unsafePerformIO $ readIORef glrefUniform1fv+{-# INLINE glUniform1fv #-}+type FuntypeUniform2fv =+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2fv :: FunPtr FuntypeUniform2fv -> FuntypeUniform2fv+glrefUniform2fv :: IORef FuntypeUniform2fv+glrefUniform2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2fv #-}+glUniform2fv :: FuntypeUniform2fv+glUniform2fv = unsafePerformIO $ readIORef glrefUniform2fv+{-# INLINE glUniform2fv #-}+type FuntypeUniform3fv =+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3fv :: FunPtr FuntypeUniform3fv -> FuntypeUniform3fv+glrefUniform3fv :: IORef FuntypeUniform3fv+glrefUniform3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3fv #-}+glUniform3fv :: FuntypeUniform3fv+glUniform3fv = unsafePerformIO $ readIORef glrefUniform3fv+{-# INLINE glUniform3fv #-}+type FuntypeUniform4fv =+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4fv :: FunPtr FuntypeUniform4fv -> FuntypeUniform4fv+glrefUniform4fv :: IORef FuntypeUniform4fv+glrefUniform4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4fv #-}+glUniform4fv :: FuntypeUniform4fv+glUniform4fv = unsafePerformIO $ readIORef glrefUniform4fv+{-# INLINE glUniform4fv #-}+type FuntypeUniform1iv =+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1iv :: FunPtr FuntypeUniform1iv -> FuntypeUniform1iv+glrefUniform1iv :: IORef FuntypeUniform1iv+glrefUniform1iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1iv #-}+glUniform1iv :: FuntypeUniform1iv+glUniform1iv = unsafePerformIO $ readIORef glrefUniform1iv+{-# INLINE glUniform1iv #-}+type FuntypeUniform2iv =+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2iv :: FunPtr FuntypeUniform2iv -> FuntypeUniform2iv+glrefUniform2iv :: IORef FuntypeUniform2iv+glrefUniform2iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2iv #-}+glUniform2iv :: FuntypeUniform2iv+glUniform2iv = unsafePerformIO $ readIORef glrefUniform2iv+{-# INLINE glUniform2iv #-}+type FuntypeUniform3iv =+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3iv :: FunPtr FuntypeUniform3iv -> FuntypeUniform3iv+glrefUniform3iv :: IORef FuntypeUniform3iv+glrefUniform3iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3iv #-}+glUniform3iv :: FuntypeUniform3iv+glUniform3iv = unsafePerformIO $ readIORef glrefUniform3iv+{-# INLINE glUniform3iv #-}+type FuntypeUniform4iv =+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4iv :: FunPtr FuntypeUniform4iv -> FuntypeUniform4iv+glrefUniform4iv :: IORef FuntypeUniform4iv+glrefUniform4iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4iv #-}+glUniform4iv :: FuntypeUniform4iv+glUniform4iv = unsafePerformIO $ readIORef glrefUniform4iv+{-# INLINE glUniform4iv #-}+type FuntypeUniformMatrix2fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix2fv :: FunPtr FuntypeUniformMatrix2fv -> FuntypeUniformMatrix2fv+glrefUniformMatrix2fv :: IORef FuntypeUniformMatrix2fv+glrefUniformMatrix2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix2fv #-}+glUniformMatrix2fv :: FuntypeUniformMatrix2fv+glUniformMatrix2fv = unsafePerformIO $ readIORef glrefUniformMatrix2fv+{-# INLINE glUniformMatrix2fv #-}+type FuntypeUniformMatrix3fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix3fv :: FunPtr FuntypeUniformMatrix3fv -> FuntypeUniformMatrix3fv+glrefUniformMatrix3fv :: IORef FuntypeUniformMatrix3fv+glrefUniformMatrix3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix3fv #-}+glUniformMatrix3fv :: FuntypeUniformMatrix3fv+glUniformMatrix3fv = unsafePerformIO $ readIORef glrefUniformMatrix3fv+{-# INLINE glUniformMatrix3fv #-}+type FuntypeUniformMatrix4fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix4fv :: FunPtr FuntypeUniformMatrix4fv -> FuntypeUniformMatrix4fv+glrefUniformMatrix4fv :: IORef FuntypeUniformMatrix4fv+glrefUniformMatrix4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix4fv #-}+glUniformMatrix4fv :: FuntypeUniformMatrix4fv+glUniformMatrix4fv = unsafePerformIO $ readIORef glrefUniformMatrix4fv+{-# INLINE glUniformMatrix4fv #-}+type FuntypeValidateProgram =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynValidateProgram :: FunPtr FuntypeValidateProgram -> FuntypeValidateProgram+glrefValidateProgram :: IORef FuntypeValidateProgram+glrefValidateProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefValidateProgram #-}+glValidateProgram :: FuntypeValidateProgram+glValidateProgram = unsafePerformIO $ readIORef glrefValidateProgram+{-# INLINE glValidateProgram #-}+type FuntypeVertexAttrib1d =+    GLuint ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1d :: FunPtr FuntypeVertexAttrib1d -> FuntypeVertexAttrib1d+glrefVertexAttrib1d :: IORef FuntypeVertexAttrib1d+glrefVertexAttrib1d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1d #-}+glVertexAttrib1d :: FuntypeVertexAttrib1d+glVertexAttrib1d = unsafePerformIO $ readIORef glrefVertexAttrib1d+{-# INLINE glVertexAttrib1d #-}+type FuntypeVertexAttrib1dv =+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1dv :: FunPtr FuntypeVertexAttrib1dv -> FuntypeVertexAttrib1dv+glrefVertexAttrib1dv :: IORef FuntypeVertexAttrib1dv+glrefVertexAttrib1dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1dv #-}+glVertexAttrib1dv :: FuntypeVertexAttrib1dv+glVertexAttrib1dv = unsafePerformIO $ readIORef glrefVertexAttrib1dv+{-# INLINE glVertexAttrib1dv #-}+type FuntypeVertexAttrib1f =+    GLuint ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1f :: FunPtr FuntypeVertexAttrib1f -> FuntypeVertexAttrib1f+glrefVertexAttrib1f :: IORef FuntypeVertexAttrib1f+glrefVertexAttrib1f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1f #-}+glVertexAttrib1f :: FuntypeVertexAttrib1f+glVertexAttrib1f = unsafePerformIO $ readIORef glrefVertexAttrib1f+{-# INLINE glVertexAttrib1f #-}+type FuntypeVertexAttrib1fv =+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1fv :: FunPtr FuntypeVertexAttrib1fv -> FuntypeVertexAttrib1fv+glrefVertexAttrib1fv :: IORef FuntypeVertexAttrib1fv+glrefVertexAttrib1fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1fv #-}+glVertexAttrib1fv :: FuntypeVertexAttrib1fv+glVertexAttrib1fv = unsafePerformIO $ readIORef glrefVertexAttrib1fv+{-# INLINE glVertexAttrib1fv #-}+type FuntypeVertexAttrib1s =+    GLuint ->+    GLshort ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1s :: FunPtr FuntypeVertexAttrib1s -> FuntypeVertexAttrib1s+glrefVertexAttrib1s :: IORef FuntypeVertexAttrib1s+glrefVertexAttrib1s = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1s #-}+glVertexAttrib1s :: FuntypeVertexAttrib1s+glVertexAttrib1s = unsafePerformIO $ readIORef glrefVertexAttrib1s+{-# INLINE glVertexAttrib1s #-}+type FuntypeVertexAttrib1sv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib1sv :: FunPtr FuntypeVertexAttrib1sv -> FuntypeVertexAttrib1sv+glrefVertexAttrib1sv :: IORef FuntypeVertexAttrib1sv+glrefVertexAttrib1sv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib1sv #-}+glVertexAttrib1sv :: FuntypeVertexAttrib1sv+glVertexAttrib1sv = unsafePerformIO $ readIORef glrefVertexAttrib1sv+{-# INLINE glVertexAttrib1sv #-}+type FuntypeVertexAttrib2d =+    GLuint ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2d :: FunPtr FuntypeVertexAttrib2d -> FuntypeVertexAttrib2d+glrefVertexAttrib2d :: IORef FuntypeVertexAttrib2d+glrefVertexAttrib2d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2d #-}+glVertexAttrib2d :: FuntypeVertexAttrib2d+glVertexAttrib2d = unsafePerformIO $ readIORef glrefVertexAttrib2d+{-# INLINE glVertexAttrib2d #-}+type FuntypeVertexAttrib2dv =+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2dv :: FunPtr FuntypeVertexAttrib2dv -> FuntypeVertexAttrib2dv+glrefVertexAttrib2dv :: IORef FuntypeVertexAttrib2dv+glrefVertexAttrib2dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2dv #-}+glVertexAttrib2dv :: FuntypeVertexAttrib2dv+glVertexAttrib2dv = unsafePerformIO $ readIORef glrefVertexAttrib2dv+{-# INLINE glVertexAttrib2dv #-}+type FuntypeVertexAttrib2f =+    GLuint ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2f :: FunPtr FuntypeVertexAttrib2f -> FuntypeVertexAttrib2f+glrefVertexAttrib2f :: IORef FuntypeVertexAttrib2f+glrefVertexAttrib2f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2f #-}+glVertexAttrib2f :: FuntypeVertexAttrib2f+glVertexAttrib2f = unsafePerformIO $ readIORef glrefVertexAttrib2f+{-# INLINE glVertexAttrib2f #-}+type FuntypeVertexAttrib2fv =+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2fv :: FunPtr FuntypeVertexAttrib2fv -> FuntypeVertexAttrib2fv+glrefVertexAttrib2fv :: IORef FuntypeVertexAttrib2fv+glrefVertexAttrib2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2fv #-}+glVertexAttrib2fv :: FuntypeVertexAttrib2fv+glVertexAttrib2fv = unsafePerformIO $ readIORef glrefVertexAttrib2fv+{-# INLINE glVertexAttrib2fv #-}+type FuntypeVertexAttrib2s =+    GLuint ->+    GLshort ->+    GLshort ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2s :: FunPtr FuntypeVertexAttrib2s -> FuntypeVertexAttrib2s+glrefVertexAttrib2s :: IORef FuntypeVertexAttrib2s+glrefVertexAttrib2s = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2s #-}+glVertexAttrib2s :: FuntypeVertexAttrib2s+glVertexAttrib2s = unsafePerformIO $ readIORef glrefVertexAttrib2s+{-# INLINE glVertexAttrib2s #-}+type FuntypeVertexAttrib2sv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib2sv :: FunPtr FuntypeVertexAttrib2sv -> FuntypeVertexAttrib2sv+glrefVertexAttrib2sv :: IORef FuntypeVertexAttrib2sv+glrefVertexAttrib2sv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib2sv #-}+glVertexAttrib2sv :: FuntypeVertexAttrib2sv+glVertexAttrib2sv = unsafePerformIO $ readIORef glrefVertexAttrib2sv+{-# INLINE glVertexAttrib2sv #-}+type FuntypeVertexAttrib3d =+    GLuint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3d :: FunPtr FuntypeVertexAttrib3d -> FuntypeVertexAttrib3d+glrefVertexAttrib3d :: IORef FuntypeVertexAttrib3d+glrefVertexAttrib3d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3d #-}+glVertexAttrib3d :: FuntypeVertexAttrib3d+glVertexAttrib3d = unsafePerformIO $ readIORef glrefVertexAttrib3d+{-# INLINE glVertexAttrib3d #-}+type FuntypeVertexAttrib3dv =+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3dv :: FunPtr FuntypeVertexAttrib3dv -> FuntypeVertexAttrib3dv+glrefVertexAttrib3dv :: IORef FuntypeVertexAttrib3dv+glrefVertexAttrib3dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3dv #-}+glVertexAttrib3dv :: FuntypeVertexAttrib3dv+glVertexAttrib3dv = unsafePerformIO $ readIORef glrefVertexAttrib3dv+{-# INLINE glVertexAttrib3dv #-}+type FuntypeVertexAttrib3f =+    GLuint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3f :: FunPtr FuntypeVertexAttrib3f -> FuntypeVertexAttrib3f+glrefVertexAttrib3f :: IORef FuntypeVertexAttrib3f+glrefVertexAttrib3f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3f #-}+glVertexAttrib3f :: FuntypeVertexAttrib3f+glVertexAttrib3f = unsafePerformIO $ readIORef glrefVertexAttrib3f+{-# INLINE glVertexAttrib3f #-}+type FuntypeVertexAttrib3fv =+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3fv :: FunPtr FuntypeVertexAttrib3fv -> FuntypeVertexAttrib3fv+glrefVertexAttrib3fv :: IORef FuntypeVertexAttrib3fv+glrefVertexAttrib3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3fv #-}+glVertexAttrib3fv :: FuntypeVertexAttrib3fv+glVertexAttrib3fv = unsafePerformIO $ readIORef glrefVertexAttrib3fv+{-# INLINE glVertexAttrib3fv #-}+type FuntypeVertexAttrib3s =+    GLuint ->+    GLshort ->+    GLshort ->+    GLshort ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3s :: FunPtr FuntypeVertexAttrib3s -> FuntypeVertexAttrib3s+glrefVertexAttrib3s :: IORef FuntypeVertexAttrib3s+glrefVertexAttrib3s = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3s #-}+glVertexAttrib3s :: FuntypeVertexAttrib3s+glVertexAttrib3s = unsafePerformIO $ readIORef glrefVertexAttrib3s+{-# INLINE glVertexAttrib3s #-}+type FuntypeVertexAttrib3sv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib3sv :: FunPtr FuntypeVertexAttrib3sv -> FuntypeVertexAttrib3sv+glrefVertexAttrib3sv :: IORef FuntypeVertexAttrib3sv+glrefVertexAttrib3sv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib3sv #-}+glVertexAttrib3sv :: FuntypeVertexAttrib3sv+glVertexAttrib3sv = unsafePerformIO $ readIORef glrefVertexAttrib3sv+{-# INLINE glVertexAttrib3sv #-}+type FuntypeVertexAttrib4Nbv =+    GLuint ->+    Ptr (GLbyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nbv :: FunPtr FuntypeVertexAttrib4Nbv -> FuntypeVertexAttrib4Nbv+glrefVertexAttrib4Nbv :: IORef FuntypeVertexAttrib4Nbv+glrefVertexAttrib4Nbv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nbv #-}+glVertexAttrib4Nbv :: FuntypeVertexAttrib4Nbv+glVertexAttrib4Nbv = unsafePerformIO $ readIORef glrefVertexAttrib4Nbv+{-# INLINE glVertexAttrib4Nbv #-}+type FuntypeVertexAttrib4Niv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Niv :: FunPtr FuntypeVertexAttrib4Niv -> FuntypeVertexAttrib4Niv+glrefVertexAttrib4Niv :: IORef FuntypeVertexAttrib4Niv+glrefVertexAttrib4Niv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Niv #-}+glVertexAttrib4Niv :: FuntypeVertexAttrib4Niv+glVertexAttrib4Niv = unsafePerformIO $ readIORef glrefVertexAttrib4Niv+{-# INLINE glVertexAttrib4Niv #-}+type FuntypeVertexAttrib4Nsv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nsv :: FunPtr FuntypeVertexAttrib4Nsv -> FuntypeVertexAttrib4Nsv+glrefVertexAttrib4Nsv :: IORef FuntypeVertexAttrib4Nsv+glrefVertexAttrib4Nsv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nsv #-}+glVertexAttrib4Nsv :: FuntypeVertexAttrib4Nsv+glVertexAttrib4Nsv = unsafePerformIO $ readIORef glrefVertexAttrib4Nsv+{-# INLINE glVertexAttrib4Nsv #-}+type FuntypeVertexAttrib4Nub =+    GLuint ->+    GLubyte ->+    GLubyte ->+    GLubyte ->+    GLubyte ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nub :: FunPtr FuntypeVertexAttrib4Nub -> FuntypeVertexAttrib4Nub+glrefVertexAttrib4Nub :: IORef FuntypeVertexAttrib4Nub+glrefVertexAttrib4Nub = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nub #-}+glVertexAttrib4Nub :: FuntypeVertexAttrib4Nub+glVertexAttrib4Nub = unsafePerformIO $ readIORef glrefVertexAttrib4Nub+{-# INLINE glVertexAttrib4Nub #-}+type FuntypeVertexAttrib4Nubv =+    GLuint ->+    Ptr (GLubyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nubv :: FunPtr FuntypeVertexAttrib4Nubv -> FuntypeVertexAttrib4Nubv+glrefVertexAttrib4Nubv :: IORef FuntypeVertexAttrib4Nubv+glrefVertexAttrib4Nubv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nubv #-}+glVertexAttrib4Nubv :: FuntypeVertexAttrib4Nubv+glVertexAttrib4Nubv = unsafePerformIO $ readIORef glrefVertexAttrib4Nubv+{-# INLINE glVertexAttrib4Nubv #-}+type FuntypeVertexAttrib4Nuiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nuiv :: FunPtr FuntypeVertexAttrib4Nuiv -> FuntypeVertexAttrib4Nuiv+glrefVertexAttrib4Nuiv :: IORef FuntypeVertexAttrib4Nuiv+glrefVertexAttrib4Nuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nuiv #-}+glVertexAttrib4Nuiv :: FuntypeVertexAttrib4Nuiv+glVertexAttrib4Nuiv = unsafePerformIO $ readIORef glrefVertexAttrib4Nuiv+{-# INLINE glVertexAttrib4Nuiv #-}+type FuntypeVertexAttrib4Nusv =+    GLuint ->+    Ptr (GLushort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4Nusv :: FunPtr FuntypeVertexAttrib4Nusv -> FuntypeVertexAttrib4Nusv+glrefVertexAttrib4Nusv :: IORef FuntypeVertexAttrib4Nusv+glrefVertexAttrib4Nusv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4Nusv #-}+glVertexAttrib4Nusv :: FuntypeVertexAttrib4Nusv+glVertexAttrib4Nusv = unsafePerformIO $ readIORef glrefVertexAttrib4Nusv+{-# INLINE glVertexAttrib4Nusv #-}+type FuntypeVertexAttrib4bv =+    GLuint ->+    Ptr (GLbyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4bv :: FunPtr FuntypeVertexAttrib4bv -> FuntypeVertexAttrib4bv+glrefVertexAttrib4bv :: IORef FuntypeVertexAttrib4bv+glrefVertexAttrib4bv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4bv #-}+glVertexAttrib4bv :: FuntypeVertexAttrib4bv+glVertexAttrib4bv = unsafePerformIO $ readIORef glrefVertexAttrib4bv+{-# INLINE glVertexAttrib4bv #-}+type FuntypeVertexAttrib4d =+    GLuint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4d :: FunPtr FuntypeVertexAttrib4d -> FuntypeVertexAttrib4d+glrefVertexAttrib4d :: IORef FuntypeVertexAttrib4d+glrefVertexAttrib4d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4d #-}+glVertexAttrib4d :: FuntypeVertexAttrib4d+glVertexAttrib4d = unsafePerformIO $ readIORef glrefVertexAttrib4d+{-# INLINE glVertexAttrib4d #-}+type FuntypeVertexAttrib4dv =+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4dv :: FunPtr FuntypeVertexAttrib4dv -> FuntypeVertexAttrib4dv+glrefVertexAttrib4dv :: IORef FuntypeVertexAttrib4dv+glrefVertexAttrib4dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4dv #-}+glVertexAttrib4dv :: FuntypeVertexAttrib4dv+glVertexAttrib4dv = unsafePerformIO $ readIORef glrefVertexAttrib4dv+{-# INLINE glVertexAttrib4dv #-}+type FuntypeVertexAttrib4f =+    GLuint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4f :: FunPtr FuntypeVertexAttrib4f -> FuntypeVertexAttrib4f+glrefVertexAttrib4f :: IORef FuntypeVertexAttrib4f+glrefVertexAttrib4f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4f #-}+glVertexAttrib4f :: FuntypeVertexAttrib4f+glVertexAttrib4f = unsafePerformIO $ readIORef glrefVertexAttrib4f+{-# INLINE glVertexAttrib4f #-}+type FuntypeVertexAttrib4fv =+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4fv :: FunPtr FuntypeVertexAttrib4fv -> FuntypeVertexAttrib4fv+glrefVertexAttrib4fv :: IORef FuntypeVertexAttrib4fv+glrefVertexAttrib4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4fv #-}+glVertexAttrib4fv :: FuntypeVertexAttrib4fv+glVertexAttrib4fv = unsafePerformIO $ readIORef glrefVertexAttrib4fv+{-# INLINE glVertexAttrib4fv #-}+type FuntypeVertexAttrib4iv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4iv :: FunPtr FuntypeVertexAttrib4iv -> FuntypeVertexAttrib4iv+glrefVertexAttrib4iv :: IORef FuntypeVertexAttrib4iv+glrefVertexAttrib4iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4iv #-}+glVertexAttrib4iv :: FuntypeVertexAttrib4iv+glVertexAttrib4iv = unsafePerformIO $ readIORef glrefVertexAttrib4iv+{-# INLINE glVertexAttrib4iv #-}+type FuntypeVertexAttrib4s =+    GLuint ->+    GLshort ->+    GLshort ->+    GLshort ->+    GLshort ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4s :: FunPtr FuntypeVertexAttrib4s -> FuntypeVertexAttrib4s+glrefVertexAttrib4s :: IORef FuntypeVertexAttrib4s+glrefVertexAttrib4s = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4s #-}+glVertexAttrib4s :: FuntypeVertexAttrib4s+glVertexAttrib4s = unsafePerformIO $ readIORef glrefVertexAttrib4s+{-# INLINE glVertexAttrib4s #-}+type FuntypeVertexAttrib4sv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4sv :: FunPtr FuntypeVertexAttrib4sv -> FuntypeVertexAttrib4sv+glrefVertexAttrib4sv :: IORef FuntypeVertexAttrib4sv+glrefVertexAttrib4sv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4sv #-}+glVertexAttrib4sv :: FuntypeVertexAttrib4sv+glVertexAttrib4sv = unsafePerformIO $ readIORef glrefVertexAttrib4sv+{-# INLINE glVertexAttrib4sv #-}+type FuntypeVertexAttrib4ubv =+    GLuint ->+    Ptr (GLubyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4ubv :: FunPtr FuntypeVertexAttrib4ubv -> FuntypeVertexAttrib4ubv+glrefVertexAttrib4ubv :: IORef FuntypeVertexAttrib4ubv+glrefVertexAttrib4ubv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4ubv #-}+glVertexAttrib4ubv :: FuntypeVertexAttrib4ubv+glVertexAttrib4ubv = unsafePerformIO $ readIORef glrefVertexAttrib4ubv+{-# INLINE glVertexAttrib4ubv #-}+type FuntypeVertexAttrib4uiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4uiv :: FunPtr FuntypeVertexAttrib4uiv -> FuntypeVertexAttrib4uiv+glrefVertexAttrib4uiv :: IORef FuntypeVertexAttrib4uiv+glrefVertexAttrib4uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4uiv #-}+glVertexAttrib4uiv :: FuntypeVertexAttrib4uiv+glVertexAttrib4uiv = unsafePerformIO $ readIORef glrefVertexAttrib4uiv+{-# INLINE glVertexAttrib4uiv #-}+type FuntypeVertexAttrib4usv =+    GLuint ->+    Ptr (GLushort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttrib4usv :: FunPtr FuntypeVertexAttrib4usv -> FuntypeVertexAttrib4usv+glrefVertexAttrib4usv :: IORef FuntypeVertexAttrib4usv+glrefVertexAttrib4usv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttrib4usv #-}+glVertexAttrib4usv :: FuntypeVertexAttrib4usv+glVertexAttrib4usv = unsafePerformIO $ readIORef glrefVertexAttrib4usv+{-# INLINE glVertexAttrib4usv #-}+type FuntypeVertexAttribPointer =+    GLuint ->+    GLint ->+    GLenum ->+    GLboolean ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribPointer :: FunPtr FuntypeVertexAttribPointer -> FuntypeVertexAttribPointer+glrefVertexAttribPointer :: IORef FuntypeVertexAttribPointer+glrefVertexAttribPointer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribPointer #-}+glVertexAttribPointer :: FuntypeVertexAttribPointer+glVertexAttribPointer = unsafePerformIO $ readIORef glrefVertexAttribPointer+{-# INLINE glVertexAttribPointer #-}++-- GL_VERSION_2_1++type FuntypeUniformMatrix2x3fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix2x3fv :: FunPtr FuntypeUniformMatrix2x3fv -> FuntypeUniformMatrix2x3fv+glrefUniformMatrix2x3fv :: IORef FuntypeUniformMatrix2x3fv+glrefUniformMatrix2x3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix2x3fv #-}+glUniformMatrix2x3fv :: FuntypeUniformMatrix2x3fv+glUniformMatrix2x3fv = unsafePerformIO $ readIORef glrefUniformMatrix2x3fv+{-# INLINE glUniformMatrix2x3fv #-}+type FuntypeUniformMatrix3x2fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix3x2fv :: FunPtr FuntypeUniformMatrix3x2fv -> FuntypeUniformMatrix3x2fv+glrefUniformMatrix3x2fv :: IORef FuntypeUniformMatrix3x2fv+glrefUniformMatrix3x2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix3x2fv #-}+glUniformMatrix3x2fv :: FuntypeUniformMatrix3x2fv+glUniformMatrix3x2fv = unsafePerformIO $ readIORef glrefUniformMatrix3x2fv+{-# INLINE glUniformMatrix3x2fv #-}+type FuntypeUniformMatrix2x4fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix2x4fv :: FunPtr FuntypeUniformMatrix2x4fv -> FuntypeUniformMatrix2x4fv+glrefUniformMatrix2x4fv :: IORef FuntypeUniformMatrix2x4fv+glrefUniformMatrix2x4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix2x4fv #-}+glUniformMatrix2x4fv :: FuntypeUniformMatrix2x4fv+glUniformMatrix2x4fv = unsafePerformIO $ readIORef glrefUniformMatrix2x4fv+{-# INLINE glUniformMatrix2x4fv #-}+type FuntypeUniformMatrix4x2fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix4x2fv :: FunPtr FuntypeUniformMatrix4x2fv -> FuntypeUniformMatrix4x2fv+glrefUniformMatrix4x2fv :: IORef FuntypeUniformMatrix4x2fv+glrefUniformMatrix4x2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix4x2fv #-}+glUniformMatrix4x2fv :: FuntypeUniformMatrix4x2fv+glUniformMatrix4x2fv = unsafePerformIO $ readIORef glrefUniformMatrix4x2fv+{-# INLINE glUniformMatrix4x2fv #-}+type FuntypeUniformMatrix3x4fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix3x4fv :: FunPtr FuntypeUniformMatrix3x4fv -> FuntypeUniformMatrix3x4fv+glrefUniformMatrix3x4fv :: IORef FuntypeUniformMatrix3x4fv+glrefUniformMatrix3x4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix3x4fv #-}+glUniformMatrix3x4fv :: FuntypeUniformMatrix3x4fv+glUniformMatrix3x4fv = unsafePerformIO $ readIORef glrefUniformMatrix3x4fv+{-# INLINE glUniformMatrix3x4fv #-}+type FuntypeUniformMatrix4x3fv =+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformMatrix4x3fv :: FunPtr FuntypeUniformMatrix4x3fv -> FuntypeUniformMatrix4x3fv+glrefUniformMatrix4x3fv :: IORef FuntypeUniformMatrix4x3fv+glrefUniformMatrix4x3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformMatrix4x3fv #-}+glUniformMatrix4x3fv :: FuntypeUniformMatrix4x3fv+glUniformMatrix4x3fv = unsafePerformIO $ readIORef glrefUniformMatrix4x3fv+{-# INLINE glUniformMatrix4x3fv #-}++-- GL_VERSION_3_0++type FuntypeColorMaski =+    GLuint ->+    GLboolean ->+    GLboolean ->+    GLboolean ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynColorMaski :: FunPtr FuntypeColorMaski -> FuntypeColorMaski+glrefColorMaski :: IORef FuntypeColorMaski+glrefColorMaski = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefColorMaski #-}+glColorMaski :: FuntypeColorMaski+glColorMaski = unsafePerformIO $ readIORef glrefColorMaski+{-# INLINE glColorMaski #-}+type FuntypeGetBooleani_v =+    GLenum ->+    GLuint ->+    Ptr (GLboolean) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBooleani_v :: FunPtr FuntypeGetBooleani_v -> FuntypeGetBooleani_v+glrefGetBooleani_v :: IORef FuntypeGetBooleani_v+glrefGetBooleani_v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBooleani_v #-}+glGetBooleani_v :: FuntypeGetBooleani_v+glGetBooleani_v = unsafePerformIO $ readIORef glrefGetBooleani_v+{-# INLINE glGetBooleani_v #-}+type FuntypeGetIntegeri_v =+    GLenum ->+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetIntegeri_v :: FunPtr FuntypeGetIntegeri_v -> FuntypeGetIntegeri_v+glrefGetIntegeri_v :: IORef FuntypeGetIntegeri_v+glrefGetIntegeri_v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetIntegeri_v #-}+glGetIntegeri_v :: FuntypeGetIntegeri_v+glGetIntegeri_v = unsafePerformIO $ readIORef glrefGetIntegeri_v+{-# INLINE glGetIntegeri_v #-}+type FuntypeEnablei =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnablei :: FunPtr FuntypeEnablei -> FuntypeEnablei+glrefEnablei :: IORef FuntypeEnablei+glrefEnablei = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnablei #-}+glEnablei :: FuntypeEnablei+glEnablei = unsafePerformIO $ readIORef glrefEnablei+{-# INLINE glEnablei #-}+type FuntypeDisablei =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisablei :: FunPtr FuntypeDisablei -> FuntypeDisablei+glrefDisablei :: IORef FuntypeDisablei+glrefDisablei = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisablei #-}+glDisablei :: FuntypeDisablei+glDisablei = unsafePerformIO $ readIORef glrefDisablei+{-# INLINE glDisablei #-}+type FuntypeIsEnabledi =+    GLenum ->+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsEnabledi :: FunPtr FuntypeIsEnabledi -> FuntypeIsEnabledi+glrefIsEnabledi :: IORef FuntypeIsEnabledi+glrefIsEnabledi = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsEnabledi #-}+glIsEnabledi :: FuntypeIsEnabledi+glIsEnabledi = unsafePerformIO $ readIORef glrefIsEnabledi+{-# INLINE glIsEnabledi #-}+type FuntypeBeginTransformFeedback =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBeginTransformFeedback :: FunPtr FuntypeBeginTransformFeedback -> FuntypeBeginTransformFeedback+glrefBeginTransformFeedback :: IORef FuntypeBeginTransformFeedback+glrefBeginTransformFeedback = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBeginTransformFeedback #-}+glBeginTransformFeedback :: FuntypeBeginTransformFeedback+glBeginTransformFeedback = unsafePerformIO $ readIORef glrefBeginTransformFeedback+{-# INLINE glBeginTransformFeedback #-}+type FuntypeEndTransformFeedback =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEndTransformFeedback :: FunPtr FuntypeEndTransformFeedback -> FuntypeEndTransformFeedback+glrefEndTransformFeedback :: IORef FuntypeEndTransformFeedback+glrefEndTransformFeedback = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEndTransformFeedback #-}+glEndTransformFeedback :: FuntypeEndTransformFeedback+glEndTransformFeedback = unsafePerformIO $ readIORef glrefEndTransformFeedback+{-# INLINE glEndTransformFeedback #-}+type FuntypeBindBufferRange =+    GLenum ->+    GLuint ->+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindBufferRange :: FunPtr FuntypeBindBufferRange -> FuntypeBindBufferRange+glrefBindBufferRange :: IORef FuntypeBindBufferRange+glrefBindBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindBufferRange #-}+glBindBufferRange :: FuntypeBindBufferRange+glBindBufferRange = unsafePerformIO $ readIORef glrefBindBufferRange+{-# INLINE glBindBufferRange #-}+type FuntypeBindBufferBase =+    GLenum ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindBufferBase :: FunPtr FuntypeBindBufferBase -> FuntypeBindBufferBase+glrefBindBufferBase :: IORef FuntypeBindBufferBase+glrefBindBufferBase = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindBufferBase #-}+glBindBufferBase :: FuntypeBindBufferBase+glBindBufferBase = unsafePerformIO $ readIORef glrefBindBufferBase+{-# INLINE glBindBufferBase #-}+type FuntypeTransformFeedbackVaryings =+    GLuint ->+    GLsizei ->+    Ptr (Ptr (GLchar)) ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTransformFeedbackVaryings :: FunPtr FuntypeTransformFeedbackVaryings -> FuntypeTransformFeedbackVaryings+glrefTransformFeedbackVaryings :: IORef FuntypeTransformFeedbackVaryings+glrefTransformFeedbackVaryings = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTransformFeedbackVaryings #-}+glTransformFeedbackVaryings :: FuntypeTransformFeedbackVaryings+glTransformFeedbackVaryings = unsafePerformIO $ readIORef glrefTransformFeedbackVaryings+{-# INLINE glTransformFeedbackVaryings #-}+type FuntypeGetTransformFeedbackVarying =+    GLuint ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLsizei) ->+    Ptr (GLenum) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTransformFeedbackVarying :: FunPtr FuntypeGetTransformFeedbackVarying -> FuntypeGetTransformFeedbackVarying+glrefGetTransformFeedbackVarying :: IORef FuntypeGetTransformFeedbackVarying+glrefGetTransformFeedbackVarying = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTransformFeedbackVarying #-}+glGetTransformFeedbackVarying :: FuntypeGetTransformFeedbackVarying+glGetTransformFeedbackVarying = unsafePerformIO $ readIORef glrefGetTransformFeedbackVarying+{-# INLINE glGetTransformFeedbackVarying #-}+type FuntypeClampColor =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClampColor :: FunPtr FuntypeClampColor -> FuntypeClampColor+glrefClampColor :: IORef FuntypeClampColor+glrefClampColor = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClampColor #-}+glClampColor :: FuntypeClampColor+glClampColor = unsafePerformIO $ readIORef glrefClampColor+{-# INLINE glClampColor #-}+type FuntypeBeginConditionalRender =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBeginConditionalRender :: FunPtr FuntypeBeginConditionalRender -> FuntypeBeginConditionalRender+glrefBeginConditionalRender :: IORef FuntypeBeginConditionalRender+glrefBeginConditionalRender = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBeginConditionalRender #-}+glBeginConditionalRender :: FuntypeBeginConditionalRender+glBeginConditionalRender = unsafePerformIO $ readIORef glrefBeginConditionalRender+{-# INLINE glBeginConditionalRender #-}+type FuntypeEndConditionalRender =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEndConditionalRender :: FunPtr FuntypeEndConditionalRender -> FuntypeEndConditionalRender+glrefEndConditionalRender :: IORef FuntypeEndConditionalRender+glrefEndConditionalRender = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEndConditionalRender #-}+glEndConditionalRender :: FuntypeEndConditionalRender+glEndConditionalRender = unsafePerformIO $ readIORef glrefEndConditionalRender+{-# INLINE glEndConditionalRender #-}+type FuntypeVertexAttribIPointer =+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribIPointer :: FunPtr FuntypeVertexAttribIPointer -> FuntypeVertexAttribIPointer+glrefVertexAttribIPointer :: IORef FuntypeVertexAttribIPointer+glrefVertexAttribIPointer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribIPointer #-}+glVertexAttribIPointer :: FuntypeVertexAttribIPointer+glVertexAttribIPointer = unsafePerformIO $ readIORef glrefVertexAttribIPointer+{-# INLINE glVertexAttribIPointer #-}+type FuntypeGetVertexAttribIiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribIiv :: FunPtr FuntypeGetVertexAttribIiv -> FuntypeGetVertexAttribIiv+glrefGetVertexAttribIiv :: IORef FuntypeGetVertexAttribIiv+glrefGetVertexAttribIiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribIiv #-}+glGetVertexAttribIiv :: FuntypeGetVertexAttribIiv+glGetVertexAttribIiv = unsafePerformIO $ readIORef glrefGetVertexAttribIiv+{-# INLINE glGetVertexAttribIiv #-}+type FuntypeGetVertexAttribIuiv =+    GLuint ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexAttribIuiv :: FunPtr FuntypeGetVertexAttribIuiv -> FuntypeGetVertexAttribIuiv+glrefGetVertexAttribIuiv :: IORef FuntypeGetVertexAttribIuiv+glrefGetVertexAttribIuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexAttribIuiv #-}+glGetVertexAttribIuiv :: FuntypeGetVertexAttribIuiv+glGetVertexAttribIuiv = unsafePerformIO $ readIORef glrefGetVertexAttribIuiv+{-# INLINE glGetVertexAttribIuiv #-}+type FuntypeVertexAttribI1i =+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI1i :: FunPtr FuntypeVertexAttribI1i -> FuntypeVertexAttribI1i+glrefVertexAttribI1i :: IORef FuntypeVertexAttribI1i+glrefVertexAttribI1i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI1i #-}+glVertexAttribI1i :: FuntypeVertexAttribI1i+glVertexAttribI1i = unsafePerformIO $ readIORef glrefVertexAttribI1i+{-# INLINE glVertexAttribI1i #-}+type FuntypeVertexAttribI2i =+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI2i :: FunPtr FuntypeVertexAttribI2i -> FuntypeVertexAttribI2i+glrefVertexAttribI2i :: IORef FuntypeVertexAttribI2i+glrefVertexAttribI2i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI2i #-}+glVertexAttribI2i :: FuntypeVertexAttribI2i+glVertexAttribI2i = unsafePerformIO $ readIORef glrefVertexAttribI2i+{-# INLINE glVertexAttribI2i #-}+type FuntypeVertexAttribI3i =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI3i :: FunPtr FuntypeVertexAttribI3i -> FuntypeVertexAttribI3i+glrefVertexAttribI3i :: IORef FuntypeVertexAttribI3i+glrefVertexAttribI3i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI3i #-}+glVertexAttribI3i :: FuntypeVertexAttribI3i+glVertexAttribI3i = unsafePerformIO $ readIORef glrefVertexAttribI3i+{-# INLINE glVertexAttribI3i #-}+type FuntypeVertexAttribI4i =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4i :: FunPtr FuntypeVertexAttribI4i -> FuntypeVertexAttribI4i+glrefVertexAttribI4i :: IORef FuntypeVertexAttribI4i+glrefVertexAttribI4i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4i #-}+glVertexAttribI4i :: FuntypeVertexAttribI4i+glVertexAttribI4i = unsafePerformIO $ readIORef glrefVertexAttribI4i+{-# INLINE glVertexAttribI4i #-}+type FuntypeVertexAttribI1ui =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI1ui :: FunPtr FuntypeVertexAttribI1ui -> FuntypeVertexAttribI1ui+glrefVertexAttribI1ui :: IORef FuntypeVertexAttribI1ui+glrefVertexAttribI1ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI1ui #-}+glVertexAttribI1ui :: FuntypeVertexAttribI1ui+glVertexAttribI1ui = unsafePerformIO $ readIORef glrefVertexAttribI1ui+{-# INLINE glVertexAttribI1ui #-}+type FuntypeVertexAttribI2ui =+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI2ui :: FunPtr FuntypeVertexAttribI2ui -> FuntypeVertexAttribI2ui+glrefVertexAttribI2ui :: IORef FuntypeVertexAttribI2ui+glrefVertexAttribI2ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI2ui #-}+glVertexAttribI2ui :: FuntypeVertexAttribI2ui+glVertexAttribI2ui = unsafePerformIO $ readIORef glrefVertexAttribI2ui+{-# INLINE glVertexAttribI2ui #-}+type FuntypeVertexAttribI3ui =+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI3ui :: FunPtr FuntypeVertexAttribI3ui -> FuntypeVertexAttribI3ui+glrefVertexAttribI3ui :: IORef FuntypeVertexAttribI3ui+glrefVertexAttribI3ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI3ui #-}+glVertexAttribI3ui :: FuntypeVertexAttribI3ui+glVertexAttribI3ui = unsafePerformIO $ readIORef glrefVertexAttribI3ui+{-# INLINE glVertexAttribI3ui #-}+type FuntypeVertexAttribI4ui =+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4ui :: FunPtr FuntypeVertexAttribI4ui -> FuntypeVertexAttribI4ui+glrefVertexAttribI4ui :: IORef FuntypeVertexAttribI4ui+glrefVertexAttribI4ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4ui #-}+glVertexAttribI4ui :: FuntypeVertexAttribI4ui+glVertexAttribI4ui = unsafePerformIO $ readIORef glrefVertexAttribI4ui+{-# INLINE glVertexAttribI4ui #-}+type FuntypeVertexAttribI1iv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI1iv :: FunPtr FuntypeVertexAttribI1iv -> FuntypeVertexAttribI1iv+glrefVertexAttribI1iv :: IORef FuntypeVertexAttribI1iv+glrefVertexAttribI1iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI1iv #-}+glVertexAttribI1iv :: FuntypeVertexAttribI1iv+glVertexAttribI1iv = unsafePerformIO $ readIORef glrefVertexAttribI1iv+{-# INLINE glVertexAttribI1iv #-}+type FuntypeVertexAttribI2iv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI2iv :: FunPtr FuntypeVertexAttribI2iv -> FuntypeVertexAttribI2iv+glrefVertexAttribI2iv :: IORef FuntypeVertexAttribI2iv+glrefVertexAttribI2iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI2iv #-}+glVertexAttribI2iv :: FuntypeVertexAttribI2iv+glVertexAttribI2iv = unsafePerformIO $ readIORef glrefVertexAttribI2iv+{-# INLINE glVertexAttribI2iv #-}+type FuntypeVertexAttribI3iv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI3iv :: FunPtr FuntypeVertexAttribI3iv -> FuntypeVertexAttribI3iv+glrefVertexAttribI3iv :: IORef FuntypeVertexAttribI3iv+glrefVertexAttribI3iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI3iv #-}+glVertexAttribI3iv :: FuntypeVertexAttribI3iv+glVertexAttribI3iv = unsafePerformIO $ readIORef glrefVertexAttribI3iv+{-# INLINE glVertexAttribI3iv #-}+type FuntypeVertexAttribI4iv =+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4iv :: FunPtr FuntypeVertexAttribI4iv -> FuntypeVertexAttribI4iv+glrefVertexAttribI4iv :: IORef FuntypeVertexAttribI4iv+glrefVertexAttribI4iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4iv #-}+glVertexAttribI4iv :: FuntypeVertexAttribI4iv+glVertexAttribI4iv = unsafePerformIO $ readIORef glrefVertexAttribI4iv+{-# INLINE glVertexAttribI4iv #-}+type FuntypeVertexAttribI1uiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI1uiv :: FunPtr FuntypeVertexAttribI1uiv -> FuntypeVertexAttribI1uiv+glrefVertexAttribI1uiv :: IORef FuntypeVertexAttribI1uiv+glrefVertexAttribI1uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI1uiv #-}+glVertexAttribI1uiv :: FuntypeVertexAttribI1uiv+glVertexAttribI1uiv = unsafePerformIO $ readIORef glrefVertexAttribI1uiv+{-# INLINE glVertexAttribI1uiv #-}+type FuntypeVertexAttribI2uiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI2uiv :: FunPtr FuntypeVertexAttribI2uiv -> FuntypeVertexAttribI2uiv+glrefVertexAttribI2uiv :: IORef FuntypeVertexAttribI2uiv+glrefVertexAttribI2uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI2uiv #-}+glVertexAttribI2uiv :: FuntypeVertexAttribI2uiv+glVertexAttribI2uiv = unsafePerformIO $ readIORef glrefVertexAttribI2uiv+{-# INLINE glVertexAttribI2uiv #-}+type FuntypeVertexAttribI3uiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI3uiv :: FunPtr FuntypeVertexAttribI3uiv -> FuntypeVertexAttribI3uiv+glrefVertexAttribI3uiv :: IORef FuntypeVertexAttribI3uiv+glrefVertexAttribI3uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI3uiv #-}+glVertexAttribI3uiv :: FuntypeVertexAttribI3uiv+glVertexAttribI3uiv = unsafePerformIO $ readIORef glrefVertexAttribI3uiv+{-# INLINE glVertexAttribI3uiv #-}+type FuntypeVertexAttribI4uiv =+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4uiv :: FunPtr FuntypeVertexAttribI4uiv -> FuntypeVertexAttribI4uiv+glrefVertexAttribI4uiv :: IORef FuntypeVertexAttribI4uiv+glrefVertexAttribI4uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4uiv #-}+glVertexAttribI4uiv :: FuntypeVertexAttribI4uiv+glVertexAttribI4uiv = unsafePerformIO $ readIORef glrefVertexAttribI4uiv+{-# INLINE glVertexAttribI4uiv #-}+type FuntypeVertexAttribI4bv =+    GLuint ->+    Ptr (GLbyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4bv :: FunPtr FuntypeVertexAttribI4bv -> FuntypeVertexAttribI4bv+glrefVertexAttribI4bv :: IORef FuntypeVertexAttribI4bv+glrefVertexAttribI4bv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4bv #-}+glVertexAttribI4bv :: FuntypeVertexAttribI4bv+glVertexAttribI4bv = unsafePerformIO $ readIORef glrefVertexAttribI4bv+{-# INLINE glVertexAttribI4bv #-}+type FuntypeVertexAttribI4sv =+    GLuint ->+    Ptr (GLshort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4sv :: FunPtr FuntypeVertexAttribI4sv -> FuntypeVertexAttribI4sv+glrefVertexAttribI4sv :: IORef FuntypeVertexAttribI4sv+glrefVertexAttribI4sv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4sv #-}+glVertexAttribI4sv :: FuntypeVertexAttribI4sv+glVertexAttribI4sv = unsafePerformIO $ readIORef glrefVertexAttribI4sv+{-# INLINE glVertexAttribI4sv #-}+type FuntypeVertexAttribI4ubv =+    GLuint ->+    Ptr (GLubyte) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4ubv :: FunPtr FuntypeVertexAttribI4ubv -> FuntypeVertexAttribI4ubv+glrefVertexAttribI4ubv :: IORef FuntypeVertexAttribI4ubv+glrefVertexAttribI4ubv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4ubv #-}+glVertexAttribI4ubv :: FuntypeVertexAttribI4ubv+glVertexAttribI4ubv = unsafePerformIO $ readIORef glrefVertexAttribI4ubv+{-# INLINE glVertexAttribI4ubv #-}+type FuntypeVertexAttribI4usv =+    GLuint ->+    Ptr (GLushort) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribI4usv :: FunPtr FuntypeVertexAttribI4usv -> FuntypeVertexAttribI4usv+glrefVertexAttribI4usv :: IORef FuntypeVertexAttribI4usv+glrefVertexAttribI4usv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribI4usv #-}+glVertexAttribI4usv :: FuntypeVertexAttribI4usv+glVertexAttribI4usv = unsafePerformIO $ readIORef glrefVertexAttribI4usv+{-# INLINE glVertexAttribI4usv #-}+type FuntypeGetUniformuiv =+    GLuint ->+    GLint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformuiv :: FunPtr FuntypeGetUniformuiv -> FuntypeGetUniformuiv+glrefGetUniformuiv :: IORef FuntypeGetUniformuiv+glrefGetUniformuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformuiv #-}+glGetUniformuiv :: FuntypeGetUniformuiv+glGetUniformuiv = unsafePerformIO $ readIORef glrefGetUniformuiv+{-# INLINE glGetUniformuiv #-}+type FuntypeBindFragDataLocation =+    GLuint ->+    GLuint ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindFragDataLocation :: FunPtr FuntypeBindFragDataLocation -> FuntypeBindFragDataLocation+glrefBindFragDataLocation :: IORef FuntypeBindFragDataLocation+glrefBindFragDataLocation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindFragDataLocation #-}+glBindFragDataLocation :: FuntypeBindFragDataLocation+glBindFragDataLocation = unsafePerformIO $ readIORef glrefBindFragDataLocation+{-# INLINE glBindFragDataLocation #-}+type FuntypeGetFragDataLocation =+    GLuint ->+    Ptr (GLchar) ->+    IO ( GLint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFragDataLocation :: FunPtr FuntypeGetFragDataLocation -> FuntypeGetFragDataLocation+glrefGetFragDataLocation :: IORef FuntypeGetFragDataLocation+glrefGetFragDataLocation = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFragDataLocation #-}+glGetFragDataLocation :: FuntypeGetFragDataLocation+glGetFragDataLocation = unsafePerformIO $ readIORef glrefGetFragDataLocation+{-# INLINE glGetFragDataLocation #-}+type FuntypeUniform1ui =+    GLint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1ui :: FunPtr FuntypeUniform1ui -> FuntypeUniform1ui+glrefUniform1ui :: IORef FuntypeUniform1ui+glrefUniform1ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1ui #-}+glUniform1ui :: FuntypeUniform1ui+glUniform1ui = unsafePerformIO $ readIORef glrefUniform1ui+{-# INLINE glUniform1ui #-}+type FuntypeUniform2ui =+    GLint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2ui :: FunPtr FuntypeUniform2ui -> FuntypeUniform2ui+glrefUniform2ui :: IORef FuntypeUniform2ui+glrefUniform2ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2ui #-}+glUniform2ui :: FuntypeUniform2ui+glUniform2ui = unsafePerformIO $ readIORef glrefUniform2ui+{-# INLINE glUniform2ui #-}+type FuntypeUniform3ui =+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3ui :: FunPtr FuntypeUniform3ui -> FuntypeUniform3ui+glrefUniform3ui :: IORef FuntypeUniform3ui+glrefUniform3ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3ui #-}+glUniform3ui :: FuntypeUniform3ui+glUniform3ui = unsafePerformIO $ readIORef glrefUniform3ui+{-# INLINE glUniform3ui #-}+type FuntypeUniform4ui =+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4ui :: FunPtr FuntypeUniform4ui -> FuntypeUniform4ui+glrefUniform4ui :: IORef FuntypeUniform4ui+glrefUniform4ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4ui #-}+glUniform4ui :: FuntypeUniform4ui+glUniform4ui = unsafePerformIO $ readIORef glrefUniform4ui+{-# INLINE glUniform4ui #-}+type FuntypeUniform1uiv =+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform1uiv :: FunPtr FuntypeUniform1uiv -> FuntypeUniform1uiv+glrefUniform1uiv :: IORef FuntypeUniform1uiv+glrefUniform1uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform1uiv #-}+glUniform1uiv :: FuntypeUniform1uiv+glUniform1uiv = unsafePerformIO $ readIORef glrefUniform1uiv+{-# INLINE glUniform1uiv #-}+type FuntypeUniform2uiv =+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform2uiv :: FunPtr FuntypeUniform2uiv -> FuntypeUniform2uiv+glrefUniform2uiv :: IORef FuntypeUniform2uiv+glrefUniform2uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform2uiv #-}+glUniform2uiv :: FuntypeUniform2uiv+glUniform2uiv = unsafePerformIO $ readIORef glrefUniform2uiv+{-# INLINE glUniform2uiv #-}+type FuntypeUniform3uiv =+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform3uiv :: FunPtr FuntypeUniform3uiv -> FuntypeUniform3uiv+glrefUniform3uiv :: IORef FuntypeUniform3uiv+glrefUniform3uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform3uiv #-}+glUniform3uiv :: FuntypeUniform3uiv+glUniform3uiv = unsafePerformIO $ readIORef glrefUniform3uiv+{-# INLINE glUniform3uiv #-}+type FuntypeUniform4uiv =+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniform4uiv :: FunPtr FuntypeUniform4uiv -> FuntypeUniform4uiv+glrefUniform4uiv :: IORef FuntypeUniform4uiv+glrefUniform4uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniform4uiv #-}+glUniform4uiv :: FuntypeUniform4uiv+glUniform4uiv = unsafePerformIO $ readIORef glrefUniform4uiv+{-# INLINE glUniform4uiv #-}+type FuntypeTexParameterIiv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameterIiv :: FunPtr FuntypeTexParameterIiv -> FuntypeTexParameterIiv+glrefTexParameterIiv :: IORef FuntypeTexParameterIiv+glrefTexParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameterIiv #-}+glTexParameterIiv :: FuntypeTexParameterIiv+glTexParameterIiv = unsafePerformIO $ readIORef glrefTexParameterIiv+{-# INLINE glTexParameterIiv #-}+type FuntypeTexParameterIuiv =+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexParameterIuiv :: FunPtr FuntypeTexParameterIuiv -> FuntypeTexParameterIuiv+glrefTexParameterIuiv :: IORef FuntypeTexParameterIuiv+glrefTexParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexParameterIuiv #-}+glTexParameterIuiv :: FuntypeTexParameterIuiv+glTexParameterIuiv = unsafePerformIO $ readIORef glrefTexParameterIuiv+{-# INLINE glTexParameterIuiv #-}+type FuntypeGetTexParameterIiv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexParameterIiv :: FunPtr FuntypeGetTexParameterIiv -> FuntypeGetTexParameterIiv+glrefGetTexParameterIiv :: IORef FuntypeGetTexParameterIiv+glrefGetTexParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexParameterIiv #-}+glGetTexParameterIiv :: FuntypeGetTexParameterIiv+glGetTexParameterIiv = unsafePerformIO $ readIORef glrefGetTexParameterIiv+{-# INLINE glGetTexParameterIiv #-}+type FuntypeGetTexParameterIuiv =+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTexParameterIuiv :: FunPtr FuntypeGetTexParameterIuiv -> FuntypeGetTexParameterIuiv+glrefGetTexParameterIuiv :: IORef FuntypeGetTexParameterIuiv+glrefGetTexParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTexParameterIuiv #-}+glGetTexParameterIuiv :: FuntypeGetTexParameterIuiv+glGetTexParameterIuiv = unsafePerformIO $ readIORef glrefGetTexParameterIuiv+{-# INLINE glGetTexParameterIuiv #-}+type FuntypeClearBufferiv =+    GLenum ->+    GLint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearBufferiv :: FunPtr FuntypeClearBufferiv -> FuntypeClearBufferiv+glrefClearBufferiv :: IORef FuntypeClearBufferiv+glrefClearBufferiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearBufferiv #-}+glClearBufferiv :: FuntypeClearBufferiv+glClearBufferiv = unsafePerformIO $ readIORef glrefClearBufferiv+{-# INLINE glClearBufferiv #-}+type FuntypeClearBufferuiv =+    GLenum ->+    GLint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearBufferuiv :: FunPtr FuntypeClearBufferuiv -> FuntypeClearBufferuiv+glrefClearBufferuiv :: IORef FuntypeClearBufferuiv+glrefClearBufferuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearBufferuiv #-}+glClearBufferuiv :: FuntypeClearBufferuiv+glClearBufferuiv = unsafePerformIO $ readIORef glrefClearBufferuiv+{-# INLINE glClearBufferuiv #-}+type FuntypeClearBufferfv =+    GLenum ->+    GLint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearBufferfv :: FunPtr FuntypeClearBufferfv -> FuntypeClearBufferfv+glrefClearBufferfv :: IORef FuntypeClearBufferfv+glrefClearBufferfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearBufferfv #-}+glClearBufferfv :: FuntypeClearBufferfv+glClearBufferfv = unsafePerformIO $ readIORef glrefClearBufferfv+{-# INLINE glClearBufferfv #-}+type FuntypeClearBufferfi =+    GLenum ->+    GLint ->+    GLfloat ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearBufferfi :: FunPtr FuntypeClearBufferfi -> FuntypeClearBufferfi+glrefClearBufferfi :: IORef FuntypeClearBufferfi+glrefClearBufferfi = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearBufferfi #-}+glClearBufferfi :: FuntypeClearBufferfi+glClearBufferfi = unsafePerformIO $ readIORef glrefClearBufferfi+{-# INLINE glClearBufferfi #-}+type FuntypeGetStringi =+    GLenum ->+    GLuint ->+    IO ( Ptr (GLubyte) )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetStringi :: FunPtr FuntypeGetStringi -> FuntypeGetStringi+glrefGetStringi :: IORef FuntypeGetStringi+glrefGetStringi = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetStringi #-}+glGetStringi :: FuntypeGetStringi+glGetStringi = unsafePerformIO $ readIORef glrefGetStringi+{-# INLINE glGetStringi #-}+type FuntypeIsRenderbuffer =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsRenderbuffer :: FunPtr FuntypeIsRenderbuffer -> FuntypeIsRenderbuffer+glrefIsRenderbuffer :: IORef FuntypeIsRenderbuffer+glrefIsRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsRenderbuffer #-}+glIsRenderbuffer :: FuntypeIsRenderbuffer+glIsRenderbuffer = unsafePerformIO $ readIORef glrefIsRenderbuffer+{-# INLINE glIsRenderbuffer #-}+type FuntypeBindRenderbuffer =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindRenderbuffer :: FunPtr FuntypeBindRenderbuffer -> FuntypeBindRenderbuffer+glrefBindRenderbuffer :: IORef FuntypeBindRenderbuffer+glrefBindRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindRenderbuffer #-}+glBindRenderbuffer :: FuntypeBindRenderbuffer+glBindRenderbuffer = unsafePerformIO $ readIORef glrefBindRenderbuffer+{-# INLINE glBindRenderbuffer #-}+type FuntypeDeleteRenderbuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteRenderbuffers :: FunPtr FuntypeDeleteRenderbuffers -> FuntypeDeleteRenderbuffers+glrefDeleteRenderbuffers :: IORef FuntypeDeleteRenderbuffers+glrefDeleteRenderbuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteRenderbuffers #-}+glDeleteRenderbuffers :: FuntypeDeleteRenderbuffers+glDeleteRenderbuffers = unsafePerformIO $ readIORef glrefDeleteRenderbuffers+{-# INLINE glDeleteRenderbuffers #-}+type FuntypeGenRenderbuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenRenderbuffers :: FunPtr FuntypeGenRenderbuffers -> FuntypeGenRenderbuffers+glrefGenRenderbuffers :: IORef FuntypeGenRenderbuffers+glrefGenRenderbuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenRenderbuffers #-}+glGenRenderbuffers :: FuntypeGenRenderbuffers+glGenRenderbuffers = unsafePerformIO $ readIORef glrefGenRenderbuffers+{-# INLINE glGenRenderbuffers #-}+type FuntypeRenderbufferStorage =+    GLenum ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynRenderbufferStorage :: FunPtr FuntypeRenderbufferStorage -> FuntypeRenderbufferStorage+glrefRenderbufferStorage :: IORef FuntypeRenderbufferStorage+glrefRenderbufferStorage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefRenderbufferStorage #-}+glRenderbufferStorage :: FuntypeRenderbufferStorage+glRenderbufferStorage = unsafePerformIO $ readIORef glrefRenderbufferStorage+{-# INLINE glRenderbufferStorage #-}+type FuntypeGetRenderbufferParameteriv =+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetRenderbufferParameteriv :: FunPtr FuntypeGetRenderbufferParameteriv -> FuntypeGetRenderbufferParameteriv+glrefGetRenderbufferParameteriv :: IORef FuntypeGetRenderbufferParameteriv+glrefGetRenderbufferParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetRenderbufferParameteriv #-}+glGetRenderbufferParameteriv :: FuntypeGetRenderbufferParameteriv+glGetRenderbufferParameteriv = unsafePerformIO $ readIORef glrefGetRenderbufferParameteriv+{-# INLINE glGetRenderbufferParameteriv #-}+type FuntypeIsFramebuffer =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsFramebuffer :: FunPtr FuntypeIsFramebuffer -> FuntypeIsFramebuffer+glrefIsFramebuffer :: IORef FuntypeIsFramebuffer+glrefIsFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsFramebuffer #-}+glIsFramebuffer :: FuntypeIsFramebuffer+glIsFramebuffer = unsafePerformIO $ readIORef glrefIsFramebuffer+{-# INLINE glIsFramebuffer #-}+type FuntypeBindFramebuffer =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindFramebuffer :: FunPtr FuntypeBindFramebuffer -> FuntypeBindFramebuffer+glrefBindFramebuffer :: IORef FuntypeBindFramebuffer+glrefBindFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindFramebuffer #-}+glBindFramebuffer :: FuntypeBindFramebuffer+glBindFramebuffer = unsafePerformIO $ readIORef glrefBindFramebuffer+{-# INLINE glBindFramebuffer #-}+type FuntypeDeleteFramebuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteFramebuffers :: FunPtr FuntypeDeleteFramebuffers -> FuntypeDeleteFramebuffers+glrefDeleteFramebuffers :: IORef FuntypeDeleteFramebuffers+glrefDeleteFramebuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteFramebuffers #-}+glDeleteFramebuffers :: FuntypeDeleteFramebuffers+glDeleteFramebuffers = unsafePerformIO $ readIORef glrefDeleteFramebuffers+{-# INLINE glDeleteFramebuffers #-}+type FuntypeGenFramebuffers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenFramebuffers :: FunPtr FuntypeGenFramebuffers -> FuntypeGenFramebuffers+glrefGenFramebuffers :: IORef FuntypeGenFramebuffers+glrefGenFramebuffers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenFramebuffers #-}+glGenFramebuffers :: FuntypeGenFramebuffers+glGenFramebuffers = unsafePerformIO $ readIORef glrefGenFramebuffers+{-# INLINE glGenFramebuffers #-}+type FuntypeCheckFramebufferStatus =+    GLenum ->+    IO ( GLenum )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCheckFramebufferStatus :: FunPtr FuntypeCheckFramebufferStatus -> FuntypeCheckFramebufferStatus+glrefCheckFramebufferStatus :: IORef FuntypeCheckFramebufferStatus+glrefCheckFramebufferStatus = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCheckFramebufferStatus #-}+glCheckFramebufferStatus :: FuntypeCheckFramebufferStatus+glCheckFramebufferStatus = unsafePerformIO $ readIORef glrefCheckFramebufferStatus+{-# INLINE glCheckFramebufferStatus #-}+type FuntypeFramebufferTexture1D =+    GLenum ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferTexture1D :: FunPtr FuntypeFramebufferTexture1D -> FuntypeFramebufferTexture1D+glrefFramebufferTexture1D :: IORef FuntypeFramebufferTexture1D+glrefFramebufferTexture1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferTexture1D #-}+glFramebufferTexture1D :: FuntypeFramebufferTexture1D+glFramebufferTexture1D = unsafePerformIO $ readIORef glrefFramebufferTexture1D+{-# INLINE glFramebufferTexture1D #-}+type FuntypeFramebufferTexture2D =+    GLenum ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferTexture2D :: FunPtr FuntypeFramebufferTexture2D -> FuntypeFramebufferTexture2D+glrefFramebufferTexture2D :: IORef FuntypeFramebufferTexture2D+glrefFramebufferTexture2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferTexture2D #-}+glFramebufferTexture2D :: FuntypeFramebufferTexture2D+glFramebufferTexture2D = unsafePerformIO $ readIORef glrefFramebufferTexture2D+{-# INLINE glFramebufferTexture2D #-}+type FuntypeFramebufferTexture3D =+    GLenum ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferTexture3D :: FunPtr FuntypeFramebufferTexture3D -> FuntypeFramebufferTexture3D+glrefFramebufferTexture3D :: IORef FuntypeFramebufferTexture3D+glrefFramebufferTexture3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferTexture3D #-}+glFramebufferTexture3D :: FuntypeFramebufferTexture3D+glFramebufferTexture3D = unsafePerformIO $ readIORef glrefFramebufferTexture3D+{-# INLINE glFramebufferTexture3D #-}+type FuntypeFramebufferRenderbuffer =+    GLenum ->+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferRenderbuffer :: FunPtr FuntypeFramebufferRenderbuffer -> FuntypeFramebufferRenderbuffer+glrefFramebufferRenderbuffer :: IORef FuntypeFramebufferRenderbuffer+glrefFramebufferRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferRenderbuffer #-}+glFramebufferRenderbuffer :: FuntypeFramebufferRenderbuffer+glFramebufferRenderbuffer = unsafePerformIO $ readIORef glrefFramebufferRenderbuffer+{-# INLINE glFramebufferRenderbuffer #-}+type FuntypeGetFramebufferAttachmentParameteriv =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFramebufferAttachmentParameteriv :: FunPtr FuntypeGetFramebufferAttachmentParameteriv -> FuntypeGetFramebufferAttachmentParameteriv+glrefGetFramebufferAttachmentParameteriv :: IORef FuntypeGetFramebufferAttachmentParameteriv+glrefGetFramebufferAttachmentParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFramebufferAttachmentParameteriv #-}+glGetFramebufferAttachmentParameteriv :: FuntypeGetFramebufferAttachmentParameteriv+glGetFramebufferAttachmentParameteriv = unsafePerformIO $ readIORef glrefGetFramebufferAttachmentParameteriv+{-# INLINE glGetFramebufferAttachmentParameteriv #-}+type FuntypeGenerateMipmap =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenerateMipmap :: FunPtr FuntypeGenerateMipmap -> FuntypeGenerateMipmap+glrefGenerateMipmap :: IORef FuntypeGenerateMipmap+glrefGenerateMipmap = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenerateMipmap #-}+glGenerateMipmap :: FuntypeGenerateMipmap+glGenerateMipmap = unsafePerformIO $ readIORef glrefGenerateMipmap+{-# INLINE glGenerateMipmap #-}+type FuntypeBlitFramebuffer =+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLbitfield ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBlitFramebuffer :: FunPtr FuntypeBlitFramebuffer -> FuntypeBlitFramebuffer+glrefBlitFramebuffer :: IORef FuntypeBlitFramebuffer+glrefBlitFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBlitFramebuffer #-}+glBlitFramebuffer :: FuntypeBlitFramebuffer+glBlitFramebuffer = unsafePerformIO $ readIORef glrefBlitFramebuffer+{-# INLINE glBlitFramebuffer #-}+type FuntypeRenderbufferStorageMultisample =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynRenderbufferStorageMultisample :: FunPtr FuntypeRenderbufferStorageMultisample -> FuntypeRenderbufferStorageMultisample+glrefRenderbufferStorageMultisample :: IORef FuntypeRenderbufferStorageMultisample+glrefRenderbufferStorageMultisample = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefRenderbufferStorageMultisample #-}+glRenderbufferStorageMultisample :: FuntypeRenderbufferStorageMultisample+glRenderbufferStorageMultisample = unsafePerformIO $ readIORef glrefRenderbufferStorageMultisample+{-# INLINE glRenderbufferStorageMultisample #-}+type FuntypeFramebufferTextureLayer =+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferTextureLayer :: FunPtr FuntypeFramebufferTextureLayer -> FuntypeFramebufferTextureLayer+glrefFramebufferTextureLayer :: IORef FuntypeFramebufferTextureLayer+glrefFramebufferTextureLayer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferTextureLayer #-}+glFramebufferTextureLayer :: FuntypeFramebufferTextureLayer+glFramebufferTextureLayer = unsafePerformIO $ readIORef glrefFramebufferTextureLayer+{-# INLINE glFramebufferTextureLayer #-}+type FuntypeMapBufferRange =+    GLenum ->+    GLintptr ->+    GLsizeiptr ->+    GLbitfield ->+    IO ( Ptr () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMapBufferRange :: FunPtr FuntypeMapBufferRange -> FuntypeMapBufferRange+glrefMapBufferRange :: IORef FuntypeMapBufferRange+glrefMapBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMapBufferRange #-}+glMapBufferRange :: FuntypeMapBufferRange+glMapBufferRange = unsafePerformIO $ readIORef glrefMapBufferRange+{-# INLINE glMapBufferRange #-}+type FuntypeFlushMappedBufferRange =+    GLenum ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFlushMappedBufferRange :: FunPtr FuntypeFlushMappedBufferRange -> FuntypeFlushMappedBufferRange+glrefFlushMappedBufferRange :: IORef FuntypeFlushMappedBufferRange+glrefFlushMappedBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFlushMappedBufferRange #-}+glFlushMappedBufferRange :: FuntypeFlushMappedBufferRange+glFlushMappedBufferRange = unsafePerformIO $ readIORef glrefFlushMappedBufferRange+{-# INLINE glFlushMappedBufferRange #-}+type FuntypeBindVertexArray =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindVertexArray :: FunPtr FuntypeBindVertexArray -> FuntypeBindVertexArray+glrefBindVertexArray :: IORef FuntypeBindVertexArray+glrefBindVertexArray = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindVertexArray #-}+glBindVertexArray :: FuntypeBindVertexArray+glBindVertexArray = unsafePerformIO $ readIORef glrefBindVertexArray+{-# INLINE glBindVertexArray #-}+type FuntypeDeleteVertexArrays =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteVertexArrays :: FunPtr FuntypeDeleteVertexArrays -> FuntypeDeleteVertexArrays+glrefDeleteVertexArrays :: IORef FuntypeDeleteVertexArrays+glrefDeleteVertexArrays = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteVertexArrays #-}+glDeleteVertexArrays :: FuntypeDeleteVertexArrays+glDeleteVertexArrays = unsafePerformIO $ readIORef glrefDeleteVertexArrays+{-# INLINE glDeleteVertexArrays #-}+type FuntypeGenVertexArrays =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenVertexArrays :: FunPtr FuntypeGenVertexArrays -> FuntypeGenVertexArrays+glrefGenVertexArrays :: IORef FuntypeGenVertexArrays+glrefGenVertexArrays = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenVertexArrays #-}+glGenVertexArrays :: FuntypeGenVertexArrays+glGenVertexArrays = unsafePerformIO $ readIORef glrefGenVertexArrays+{-# INLINE glGenVertexArrays #-}+type FuntypeIsVertexArray =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsVertexArray :: FunPtr FuntypeIsVertexArray -> FuntypeIsVertexArray+glrefIsVertexArray :: IORef FuntypeIsVertexArray+glrefIsVertexArray = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsVertexArray #-}+glIsVertexArray :: FuntypeIsVertexArray+glIsVertexArray = unsafePerformIO $ readIORef glrefIsVertexArray+{-# INLINE glIsVertexArray #-}++-- GL_VERSION_3_1++type FuntypeDrawArraysInstanced =+    GLenum ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawArraysInstanced :: FunPtr FuntypeDrawArraysInstanced -> FuntypeDrawArraysInstanced+glrefDrawArraysInstanced :: IORef FuntypeDrawArraysInstanced+glrefDrawArraysInstanced = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawArraysInstanced #-}+glDrawArraysInstanced :: FuntypeDrawArraysInstanced+glDrawArraysInstanced = unsafePerformIO $ readIORef glrefDrawArraysInstanced+{-# INLINE glDrawArraysInstanced #-}+type FuntypeDrawElementsInstanced =+    GLenum ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawElementsInstanced :: FunPtr FuntypeDrawElementsInstanced -> FuntypeDrawElementsInstanced+glrefDrawElementsInstanced :: IORef FuntypeDrawElementsInstanced+glrefDrawElementsInstanced = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawElementsInstanced #-}+glDrawElementsInstanced :: FuntypeDrawElementsInstanced+glDrawElementsInstanced = unsafePerformIO $ readIORef glrefDrawElementsInstanced+{-# INLINE glDrawElementsInstanced #-}+type FuntypeTexBuffer =+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexBuffer :: FunPtr FuntypeTexBuffer -> FuntypeTexBuffer+glrefTexBuffer :: IORef FuntypeTexBuffer+glrefTexBuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexBuffer #-}+glTexBuffer :: FuntypeTexBuffer+glTexBuffer = unsafePerformIO $ readIORef glrefTexBuffer+{-# INLINE glTexBuffer #-}+type FuntypePrimitiveRestartIndex =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPrimitiveRestartIndex :: FunPtr FuntypePrimitiveRestartIndex -> FuntypePrimitiveRestartIndex+glrefPrimitiveRestartIndex :: IORef FuntypePrimitiveRestartIndex+glrefPrimitiveRestartIndex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPrimitiveRestartIndex #-}+glPrimitiveRestartIndex :: FuntypePrimitiveRestartIndex+glPrimitiveRestartIndex = unsafePerformIO $ readIORef glrefPrimitiveRestartIndex+{-# INLINE glPrimitiveRestartIndex #-}+type FuntypeCopyBufferSubData =+    GLenum ->+    GLenum ->+    GLintptr ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyBufferSubData :: FunPtr FuntypeCopyBufferSubData -> FuntypeCopyBufferSubData+glrefCopyBufferSubData :: IORef FuntypeCopyBufferSubData+glrefCopyBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyBufferSubData #-}+glCopyBufferSubData :: FuntypeCopyBufferSubData+glCopyBufferSubData = unsafePerformIO $ readIORef glrefCopyBufferSubData+{-# INLINE glCopyBufferSubData #-}+type FuntypeGetUniformIndices =+    GLuint ->+    GLsizei ->+    Ptr (Ptr (GLchar)) ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformIndices :: FunPtr FuntypeGetUniformIndices -> FuntypeGetUniformIndices+glrefGetUniformIndices :: IORef FuntypeGetUniformIndices+glrefGetUniformIndices = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformIndices #-}+glGetUniformIndices :: FuntypeGetUniformIndices+glGetUniformIndices = unsafePerformIO $ readIORef glrefGetUniformIndices+{-# INLINE glGetUniformIndices #-}+type FuntypeGetActiveUniformsiv =+    GLuint ->+    GLsizei ->+    Ptr (GLuint) ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveUniformsiv :: FunPtr FuntypeGetActiveUniformsiv -> FuntypeGetActiveUniformsiv+glrefGetActiveUniformsiv :: IORef FuntypeGetActiveUniformsiv+glrefGetActiveUniformsiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveUniformsiv #-}+glGetActiveUniformsiv :: FuntypeGetActiveUniformsiv+glGetActiveUniformsiv = unsafePerformIO $ readIORef glrefGetActiveUniformsiv+{-# INLINE glGetActiveUniformsiv #-}+type FuntypeGetActiveUniformName =+    GLuint ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveUniformName :: FunPtr FuntypeGetActiveUniformName -> FuntypeGetActiveUniformName+glrefGetActiveUniformName :: IORef FuntypeGetActiveUniformName+glrefGetActiveUniformName = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveUniformName #-}+glGetActiveUniformName :: FuntypeGetActiveUniformName+glGetActiveUniformName = unsafePerformIO $ readIORef glrefGetActiveUniformName+{-# INLINE glGetActiveUniformName #-}+type FuntypeGetUniformBlockIndex =+    GLuint ->+    Ptr (GLchar) ->+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetUniformBlockIndex :: FunPtr FuntypeGetUniformBlockIndex -> FuntypeGetUniformBlockIndex+glrefGetUniformBlockIndex :: IORef FuntypeGetUniformBlockIndex+glrefGetUniformBlockIndex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetUniformBlockIndex #-}+glGetUniformBlockIndex :: FuntypeGetUniformBlockIndex+glGetUniformBlockIndex = unsafePerformIO $ readIORef glrefGetUniformBlockIndex+{-# INLINE glGetUniformBlockIndex #-}+type FuntypeGetActiveUniformBlockiv =+    GLuint ->+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveUniformBlockiv :: FunPtr FuntypeGetActiveUniformBlockiv -> FuntypeGetActiveUniformBlockiv+glrefGetActiveUniformBlockiv :: IORef FuntypeGetActiveUniformBlockiv+glrefGetActiveUniformBlockiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveUniformBlockiv #-}+glGetActiveUniformBlockiv :: FuntypeGetActiveUniformBlockiv+glGetActiveUniformBlockiv = unsafePerformIO $ readIORef glrefGetActiveUniformBlockiv+{-# INLINE glGetActiveUniformBlockiv #-}+type FuntypeGetActiveUniformBlockName =+    GLuint ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetActiveUniformBlockName :: FunPtr FuntypeGetActiveUniformBlockName -> FuntypeGetActiveUniformBlockName+glrefGetActiveUniformBlockName :: IORef FuntypeGetActiveUniformBlockName+glrefGetActiveUniformBlockName = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetActiveUniformBlockName #-}+glGetActiveUniformBlockName :: FuntypeGetActiveUniformBlockName+glGetActiveUniformBlockName = unsafePerformIO $ readIORef glrefGetActiveUniformBlockName+{-# INLINE glGetActiveUniformBlockName #-}+type FuntypeUniformBlockBinding =+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUniformBlockBinding :: FunPtr FuntypeUniformBlockBinding -> FuntypeUniformBlockBinding+glrefUniformBlockBinding :: IORef FuntypeUniformBlockBinding+glrefUniformBlockBinding = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUniformBlockBinding #-}+glUniformBlockBinding :: FuntypeUniformBlockBinding+glUniformBlockBinding = unsafePerformIO $ readIORef glrefUniformBlockBinding+{-# INLINE glUniformBlockBinding #-}++-- GL_VERSION_3_2++type FuntypeDrawElementsBaseVertex =+    GLenum ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawElementsBaseVertex :: FunPtr FuntypeDrawElementsBaseVertex -> FuntypeDrawElementsBaseVertex+glrefDrawElementsBaseVertex :: IORef FuntypeDrawElementsBaseVertex+glrefDrawElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawElementsBaseVertex #-}+glDrawElementsBaseVertex :: FuntypeDrawElementsBaseVertex+glDrawElementsBaseVertex = unsafePerformIO $ readIORef glrefDrawElementsBaseVertex+{-# INLINE glDrawElementsBaseVertex #-}+type FuntypeDrawRangeElementsBaseVertex =+    GLenum ->+    GLuint ->+    GLuint ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawRangeElementsBaseVertex :: FunPtr FuntypeDrawRangeElementsBaseVertex -> FuntypeDrawRangeElementsBaseVertex+glrefDrawRangeElementsBaseVertex :: IORef FuntypeDrawRangeElementsBaseVertex+glrefDrawRangeElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawRangeElementsBaseVertex #-}+glDrawRangeElementsBaseVertex :: FuntypeDrawRangeElementsBaseVertex+glDrawRangeElementsBaseVertex = unsafePerformIO $ readIORef glrefDrawRangeElementsBaseVertex+{-# INLINE glDrawRangeElementsBaseVertex #-}+type FuntypeDrawElementsInstancedBaseVertex =+    GLenum ->+    GLsizei ->+    GLenum ->+    Ptr () ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDrawElementsInstancedBaseVertex :: FunPtr FuntypeDrawElementsInstancedBaseVertex -> FuntypeDrawElementsInstancedBaseVertex+glrefDrawElementsInstancedBaseVertex :: IORef FuntypeDrawElementsInstancedBaseVertex+glrefDrawElementsInstancedBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDrawElementsInstancedBaseVertex #-}+glDrawElementsInstancedBaseVertex :: FuntypeDrawElementsInstancedBaseVertex+glDrawElementsInstancedBaseVertex = unsafePerformIO $ readIORef glrefDrawElementsInstancedBaseVertex+{-# INLINE glDrawElementsInstancedBaseVertex #-}+type FuntypeMultiDrawElementsBaseVertex =+    GLenum ->+    Ptr (GLsizei) ->+    GLenum ->+    Ptr (Ptr ()) ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiDrawElementsBaseVertex :: FunPtr FuntypeMultiDrawElementsBaseVertex -> FuntypeMultiDrawElementsBaseVertex+glrefMultiDrawElementsBaseVertex :: IORef FuntypeMultiDrawElementsBaseVertex+glrefMultiDrawElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiDrawElementsBaseVertex #-}+glMultiDrawElementsBaseVertex :: FuntypeMultiDrawElementsBaseVertex+glMultiDrawElementsBaseVertex = unsafePerformIO $ readIORef glrefMultiDrawElementsBaseVertex+{-# INLINE glMultiDrawElementsBaseVertex #-}+type FuntypeProvokingVertex =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProvokingVertex :: FunPtr FuntypeProvokingVertex -> FuntypeProvokingVertex+glrefProvokingVertex :: IORef FuntypeProvokingVertex+glrefProvokingVertex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProvokingVertex #-}+glProvokingVertex :: FuntypeProvokingVertex+glProvokingVertex = unsafePerformIO $ readIORef glrefProvokingVertex+{-# INLINE glProvokingVertex #-}+type FuntypeFenceSync =+    GLenum ->+    GLbitfield ->+    IO ( GLsync )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFenceSync :: FunPtr FuntypeFenceSync -> FuntypeFenceSync+glrefFenceSync :: IORef FuntypeFenceSync+glrefFenceSync = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFenceSync #-}+glFenceSync :: FuntypeFenceSync+glFenceSync = unsafePerformIO $ readIORef glrefFenceSync+{-# INLINE glFenceSync #-}+type FuntypeIsSync =+    GLsync ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsSync :: FunPtr FuntypeIsSync -> FuntypeIsSync+glrefIsSync :: IORef FuntypeIsSync+glrefIsSync = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsSync #-}+glIsSync :: FuntypeIsSync+glIsSync = unsafePerformIO $ readIORef glrefIsSync+{-# INLINE glIsSync #-}+type FuntypeDeleteSync =+    GLsync ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteSync :: FunPtr FuntypeDeleteSync -> FuntypeDeleteSync+glrefDeleteSync :: IORef FuntypeDeleteSync+glrefDeleteSync = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteSync #-}+glDeleteSync :: FuntypeDeleteSync+glDeleteSync = unsafePerformIO $ readIORef glrefDeleteSync+{-# INLINE glDeleteSync #-}+type FuntypeClientWaitSync =+    GLsync ->+    GLbitfield ->+    GLuint64 ->+    IO ( GLenum )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClientWaitSync :: FunPtr FuntypeClientWaitSync -> FuntypeClientWaitSync+glrefClientWaitSync :: IORef FuntypeClientWaitSync+glrefClientWaitSync = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClientWaitSync #-}+glClientWaitSync :: FuntypeClientWaitSync+glClientWaitSync = unsafePerformIO $ readIORef glrefClientWaitSync+{-# INLINE glClientWaitSync #-}+type FuntypeWaitSync =+    GLsync ->+    GLbitfield ->+    GLuint64 ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynWaitSync :: FunPtr FuntypeWaitSync -> FuntypeWaitSync+glrefWaitSync :: IORef FuntypeWaitSync+glrefWaitSync = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefWaitSync #-}+glWaitSync :: FuntypeWaitSync+glWaitSync = unsafePerformIO $ readIORef glrefWaitSync+{-# INLINE glWaitSync #-}+type FuntypeGetInteger64v =+    GLenum ->+    Ptr (GLint64) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetInteger64v :: FunPtr FuntypeGetInteger64v -> FuntypeGetInteger64v+glrefGetInteger64v :: IORef FuntypeGetInteger64v+glrefGetInteger64v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetInteger64v #-}+glGetInteger64v :: FuntypeGetInteger64v+glGetInteger64v = unsafePerformIO $ readIORef glrefGetInteger64v+{-# INLINE glGetInteger64v #-}+type FuntypeGetSynciv =+    GLsync ->+    GLenum ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetSynciv :: FunPtr FuntypeGetSynciv -> FuntypeGetSynciv+glrefGetSynciv :: IORef FuntypeGetSynciv+glrefGetSynciv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetSynciv #-}+glGetSynciv :: FuntypeGetSynciv+glGetSynciv = unsafePerformIO $ readIORef glrefGetSynciv+{-# INLINE glGetSynciv #-}+type FuntypeGetInteger64i_v =+    GLenum ->+    GLuint ->+    Ptr (GLint64) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetInteger64i_v :: FunPtr FuntypeGetInteger64i_v -> FuntypeGetInteger64i_v+glrefGetInteger64i_v :: IORef FuntypeGetInteger64i_v+glrefGetInteger64i_v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetInteger64i_v #-}+glGetInteger64i_v :: FuntypeGetInteger64i_v+glGetInteger64i_v = unsafePerformIO $ readIORef glrefGetInteger64i_v+{-# INLINE glGetInteger64i_v #-}+type FuntypeGetBufferParameteri64v =+    GLenum ->+    GLenum ->+    Ptr (GLint64) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBufferParameteri64v :: FunPtr FuntypeGetBufferParameteri64v -> FuntypeGetBufferParameteri64v+glrefGetBufferParameteri64v :: IORef FuntypeGetBufferParameteri64v+glrefGetBufferParameteri64v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBufferParameteri64v #-}+glGetBufferParameteri64v :: FuntypeGetBufferParameteri64v+glGetBufferParameteri64v = unsafePerformIO $ readIORef glrefGetBufferParameteri64v+{-# INLINE glGetBufferParameteri64v #-}+type FuntypeFramebufferTexture =+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferTexture :: FunPtr FuntypeFramebufferTexture -> FuntypeFramebufferTexture+glrefFramebufferTexture :: IORef FuntypeFramebufferTexture+glrefFramebufferTexture = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferTexture #-}+glFramebufferTexture :: FuntypeFramebufferTexture+glFramebufferTexture = unsafePerformIO $ readIORef glrefFramebufferTexture+{-# INLINE glFramebufferTexture #-}+type FuntypeTexImage2DMultisample =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexImage2DMultisample :: FunPtr FuntypeTexImage2DMultisample -> FuntypeTexImage2DMultisample+glrefTexImage2DMultisample :: IORef FuntypeTexImage2DMultisample+glrefTexImage2DMultisample = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexImage2DMultisample #-}+glTexImage2DMultisample :: FuntypeTexImage2DMultisample+glTexImage2DMultisample = unsafePerformIO $ readIORef glrefTexImage2DMultisample+{-# INLINE glTexImage2DMultisample #-}+type FuntypeTexImage3DMultisample =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexImage3DMultisample :: FunPtr FuntypeTexImage3DMultisample -> FuntypeTexImage3DMultisample+glrefTexImage3DMultisample :: IORef FuntypeTexImage3DMultisample+glrefTexImage3DMultisample = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexImage3DMultisample #-}+glTexImage3DMultisample :: FuntypeTexImage3DMultisample+glTexImage3DMultisample = unsafePerformIO $ readIORef glrefTexImage3DMultisample+{-# INLINE glTexImage3DMultisample #-}+type FuntypeGetMultisamplefv =+    GLenum ->+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultisamplefv :: FunPtr FuntypeGetMultisamplefv -> FuntypeGetMultisamplefv+glrefGetMultisamplefv :: IORef FuntypeGetMultisamplefv+glrefGetMultisamplefv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultisamplefv #-}+glGetMultisamplefv :: FuntypeGetMultisamplefv+glGetMultisamplefv = unsafePerformIO $ readIORef glrefGetMultisamplefv+{-# INLINE glGetMultisamplefv #-}+type FuntypeSampleMaski =+    GLuint ->+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSampleMaski :: FunPtr FuntypeSampleMaski -> FuntypeSampleMaski+glrefSampleMaski :: IORef FuntypeSampleMaski+glrefSampleMaski = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSampleMaski #-}+glSampleMaski :: FuntypeSampleMaski+glSampleMaski = unsafePerformIO $ readIORef glrefSampleMaski+{-# INLINE glSampleMaski #-}++-- GL_VERSION_3_3++type FuntypeBindFragDataLocationIndexed =+    GLuint ->+    GLuint ->+    GLuint ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindFragDataLocationIndexed :: FunPtr FuntypeBindFragDataLocationIndexed -> FuntypeBindFragDataLocationIndexed+glrefBindFragDataLocationIndexed :: IORef FuntypeBindFragDataLocationIndexed+glrefBindFragDataLocationIndexed = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindFragDataLocationIndexed #-}+glBindFragDataLocationIndexed :: FuntypeBindFragDataLocationIndexed+glBindFragDataLocationIndexed = unsafePerformIO $ readIORef glrefBindFragDataLocationIndexed+{-# INLINE glBindFragDataLocationIndexed #-}+type FuntypeGetFragDataIndex =+    GLuint ->+    Ptr (GLchar) ->+    IO ( GLint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFragDataIndex :: FunPtr FuntypeGetFragDataIndex -> FuntypeGetFragDataIndex+glrefGetFragDataIndex :: IORef FuntypeGetFragDataIndex+glrefGetFragDataIndex = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFragDataIndex #-}+glGetFragDataIndex :: FuntypeGetFragDataIndex+glGetFragDataIndex = unsafePerformIO $ readIORef glrefGetFragDataIndex+{-# INLINE glGetFragDataIndex #-}+type FuntypeGenSamplers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenSamplers :: FunPtr FuntypeGenSamplers -> FuntypeGenSamplers+glrefGenSamplers :: IORef FuntypeGenSamplers+glrefGenSamplers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenSamplers #-}+glGenSamplers :: FuntypeGenSamplers+glGenSamplers = unsafePerformIO $ readIORef glrefGenSamplers+{-# INLINE glGenSamplers #-}+type FuntypeDeleteSamplers =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteSamplers :: FunPtr FuntypeDeleteSamplers -> FuntypeDeleteSamplers+glrefDeleteSamplers :: IORef FuntypeDeleteSamplers+glrefDeleteSamplers = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteSamplers #-}+glDeleteSamplers :: FuntypeDeleteSamplers+glDeleteSamplers = unsafePerformIO $ readIORef glrefDeleteSamplers+{-# INLINE glDeleteSamplers #-}+type FuntypeIsSampler =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsSampler :: FunPtr FuntypeIsSampler -> FuntypeIsSampler+glrefIsSampler :: IORef FuntypeIsSampler+glrefIsSampler = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsSampler #-}+glIsSampler :: FuntypeIsSampler+glIsSampler = unsafePerformIO $ readIORef glrefIsSampler+{-# INLINE glIsSampler #-}+type FuntypeBindSampler =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindSampler :: FunPtr FuntypeBindSampler -> FuntypeBindSampler+glrefBindSampler :: IORef FuntypeBindSampler+glrefBindSampler = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindSampler #-}+glBindSampler :: FuntypeBindSampler+glBindSampler = unsafePerformIO $ readIORef glrefBindSampler+{-# INLINE glBindSampler #-}+type FuntypeSamplerParameteri =+    GLuint ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameteri :: FunPtr FuntypeSamplerParameteri -> FuntypeSamplerParameteri+glrefSamplerParameteri :: IORef FuntypeSamplerParameteri+glrefSamplerParameteri = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameteri #-}+glSamplerParameteri :: FuntypeSamplerParameteri+glSamplerParameteri = unsafePerformIO $ readIORef glrefSamplerParameteri+{-# INLINE glSamplerParameteri #-}+type FuntypeSamplerParameteriv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameteriv :: FunPtr FuntypeSamplerParameteriv -> FuntypeSamplerParameteriv+glrefSamplerParameteriv :: IORef FuntypeSamplerParameteriv+glrefSamplerParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameteriv #-}+glSamplerParameteriv :: FuntypeSamplerParameteriv+glSamplerParameteriv = unsafePerformIO $ readIORef glrefSamplerParameteriv+{-# INLINE glSamplerParameteriv #-}+type FuntypeSamplerParameterf =+    GLuint ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameterf :: FunPtr FuntypeSamplerParameterf -> FuntypeSamplerParameterf+glrefSamplerParameterf :: IORef FuntypeSamplerParameterf+glrefSamplerParameterf = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameterf #-}+glSamplerParameterf :: FuntypeSamplerParameterf+glSamplerParameterf = unsafePerformIO $ readIORef glrefSamplerParameterf+{-# INLINE glSamplerParameterf #-}+type FuntypeSamplerParameterfv =+    GLuint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameterfv :: FunPtr FuntypeSamplerParameterfv -> FuntypeSamplerParameterfv+glrefSamplerParameterfv :: IORef FuntypeSamplerParameterfv+glrefSamplerParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameterfv #-}+glSamplerParameterfv :: FuntypeSamplerParameterfv+glSamplerParameterfv = unsafePerformIO $ readIORef glrefSamplerParameterfv+{-# INLINE glSamplerParameterfv #-}+type FuntypeSamplerParameterIiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameterIiv :: FunPtr FuntypeSamplerParameterIiv -> FuntypeSamplerParameterIiv+glrefSamplerParameterIiv :: IORef FuntypeSamplerParameterIiv+glrefSamplerParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameterIiv #-}+glSamplerParameterIiv :: FuntypeSamplerParameterIiv+glSamplerParameterIiv = unsafePerformIO $ readIORef glrefSamplerParameterIiv+{-# INLINE glSamplerParameterIiv #-}+type FuntypeSamplerParameterIuiv =+    GLuint ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynSamplerParameterIuiv :: FunPtr FuntypeSamplerParameterIuiv -> FuntypeSamplerParameterIuiv+glrefSamplerParameterIuiv :: IORef FuntypeSamplerParameterIuiv+glrefSamplerParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefSamplerParameterIuiv #-}+glSamplerParameterIuiv :: FuntypeSamplerParameterIuiv+glSamplerParameterIuiv = unsafePerformIO $ readIORef glrefSamplerParameterIuiv+{-# INLINE glSamplerParameterIuiv #-}+type FuntypeGetSamplerParameteriv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetSamplerParameteriv :: FunPtr FuntypeGetSamplerParameteriv -> FuntypeGetSamplerParameteriv+glrefGetSamplerParameteriv :: IORef FuntypeGetSamplerParameteriv+glrefGetSamplerParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetSamplerParameteriv #-}+glGetSamplerParameteriv :: FuntypeGetSamplerParameteriv+glGetSamplerParameteriv = unsafePerformIO $ readIORef glrefGetSamplerParameteriv+{-# INLINE glGetSamplerParameteriv #-}+type FuntypeGetSamplerParameterIiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetSamplerParameterIiv :: FunPtr FuntypeGetSamplerParameterIiv -> FuntypeGetSamplerParameterIiv+glrefGetSamplerParameterIiv :: IORef FuntypeGetSamplerParameterIiv+glrefGetSamplerParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetSamplerParameterIiv #-}+glGetSamplerParameterIiv :: FuntypeGetSamplerParameterIiv+glGetSamplerParameterIiv = unsafePerformIO $ readIORef glrefGetSamplerParameterIiv+{-# INLINE glGetSamplerParameterIiv #-}+type FuntypeGetSamplerParameterfv =+    GLuint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetSamplerParameterfv :: FunPtr FuntypeGetSamplerParameterfv -> FuntypeGetSamplerParameterfv+glrefGetSamplerParameterfv :: IORef FuntypeGetSamplerParameterfv+glrefGetSamplerParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetSamplerParameterfv #-}+glGetSamplerParameterfv :: FuntypeGetSamplerParameterfv+glGetSamplerParameterfv = unsafePerformIO $ readIORef glrefGetSamplerParameterfv+{-# INLINE glGetSamplerParameterfv #-}+type FuntypeGetSamplerParameterIuiv =+    GLuint ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetSamplerParameterIuiv :: FunPtr FuntypeGetSamplerParameterIuiv -> FuntypeGetSamplerParameterIuiv+glrefGetSamplerParameterIuiv :: IORef FuntypeGetSamplerParameterIuiv+glrefGetSamplerParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetSamplerParameterIuiv #-}+glGetSamplerParameterIuiv :: FuntypeGetSamplerParameterIuiv+glGetSamplerParameterIuiv = unsafePerformIO $ readIORef glrefGetSamplerParameterIuiv+{-# INLINE glGetSamplerParameterIuiv #-}+type FuntypeQueryCounter =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynQueryCounter :: FunPtr FuntypeQueryCounter -> FuntypeQueryCounter+glrefQueryCounter :: IORef FuntypeQueryCounter+glrefQueryCounter = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefQueryCounter #-}+glQueryCounter :: FuntypeQueryCounter+glQueryCounter = unsafePerformIO $ readIORef glrefQueryCounter+{-# INLINE glQueryCounter #-}+type FuntypeGetQueryObjecti64v =+    GLuint ->+    GLenum ->+    Ptr (GLint64) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetQueryObjecti64v :: FunPtr FuntypeGetQueryObjecti64v -> FuntypeGetQueryObjecti64v+glrefGetQueryObjecti64v :: IORef FuntypeGetQueryObjecti64v+glrefGetQueryObjecti64v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetQueryObjecti64v #-}+glGetQueryObjecti64v :: FuntypeGetQueryObjecti64v+glGetQueryObjecti64v = unsafePerformIO $ readIORef glrefGetQueryObjecti64v+{-# INLINE glGetQueryObjecti64v #-}+type FuntypeGetQueryObjectui64v =+    GLuint ->+    GLenum ->+    Ptr (GLuint64) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetQueryObjectui64v :: FunPtr FuntypeGetQueryObjectui64v -> FuntypeGetQueryObjectui64v+glrefGetQueryObjectui64v :: IORef FuntypeGetQueryObjectui64v+glrefGetQueryObjectui64v = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetQueryObjectui64v #-}+glGetQueryObjectui64v :: FuntypeGetQueryObjectui64v+glGetQueryObjectui64v = unsafePerformIO $ readIORef glrefGetQueryObjectui64v+{-# INLINE glGetQueryObjectui64v #-}+type FuntypeVertexAttribDivisor =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribDivisor :: FunPtr FuntypeVertexAttribDivisor -> FuntypeVertexAttribDivisor+glrefVertexAttribDivisor :: IORef FuntypeVertexAttribDivisor+glrefVertexAttribDivisor = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribDivisor #-}+glVertexAttribDivisor :: FuntypeVertexAttribDivisor+glVertexAttribDivisor = unsafePerformIO $ readIORef glrefVertexAttribDivisor+{-# INLINE glVertexAttribDivisor #-}+type FuntypeVertexAttribP1ui =+    GLuint ->+    GLenum ->+    GLboolean ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP1ui :: FunPtr FuntypeVertexAttribP1ui -> FuntypeVertexAttribP1ui+glrefVertexAttribP1ui :: IORef FuntypeVertexAttribP1ui+glrefVertexAttribP1ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP1ui #-}+glVertexAttribP1ui :: FuntypeVertexAttribP1ui+glVertexAttribP1ui = unsafePerformIO $ readIORef glrefVertexAttribP1ui+{-# INLINE glVertexAttribP1ui #-}+type FuntypeVertexAttribP1uiv =+    GLuint ->+    GLenum ->+    GLboolean ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP1uiv :: FunPtr FuntypeVertexAttribP1uiv -> FuntypeVertexAttribP1uiv+glrefVertexAttribP1uiv :: IORef FuntypeVertexAttribP1uiv+glrefVertexAttribP1uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP1uiv #-}+glVertexAttribP1uiv :: FuntypeVertexAttribP1uiv+glVertexAttribP1uiv = unsafePerformIO $ readIORef glrefVertexAttribP1uiv+{-# INLINE glVertexAttribP1uiv #-}+type FuntypeVertexAttribP2ui =+    GLuint ->+    GLenum ->+    GLboolean ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP2ui :: FunPtr FuntypeVertexAttribP2ui -> FuntypeVertexAttribP2ui+glrefVertexAttribP2ui :: IORef FuntypeVertexAttribP2ui+glrefVertexAttribP2ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP2ui #-}+glVertexAttribP2ui :: FuntypeVertexAttribP2ui+glVertexAttribP2ui = unsafePerformIO $ readIORef glrefVertexAttribP2ui+{-# INLINE glVertexAttribP2ui #-}+type FuntypeVertexAttribP2uiv =+    GLuint ->+    GLenum ->+    GLboolean ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP2uiv :: FunPtr FuntypeVertexAttribP2uiv -> FuntypeVertexAttribP2uiv+glrefVertexAttribP2uiv :: IORef FuntypeVertexAttribP2uiv+glrefVertexAttribP2uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP2uiv #-}+glVertexAttribP2uiv :: FuntypeVertexAttribP2uiv+glVertexAttribP2uiv = unsafePerformIO $ readIORef glrefVertexAttribP2uiv+{-# INLINE glVertexAttribP2uiv #-}+type FuntypeVertexAttribP3ui =+    GLuint ->+    GLenum ->+    GLboolean ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP3ui :: FunPtr FuntypeVertexAttribP3ui -> FuntypeVertexAttribP3ui+glrefVertexAttribP3ui :: IORef FuntypeVertexAttribP3ui+glrefVertexAttribP3ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP3ui #-}+glVertexAttribP3ui :: FuntypeVertexAttribP3ui+glVertexAttribP3ui = unsafePerformIO $ readIORef glrefVertexAttribP3ui+{-# INLINE glVertexAttribP3ui #-}+type FuntypeVertexAttribP3uiv =+    GLuint ->+    GLenum ->+    GLboolean ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP3uiv :: FunPtr FuntypeVertexAttribP3uiv -> FuntypeVertexAttribP3uiv+glrefVertexAttribP3uiv :: IORef FuntypeVertexAttribP3uiv+glrefVertexAttribP3uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP3uiv #-}+glVertexAttribP3uiv :: FuntypeVertexAttribP3uiv+glVertexAttribP3uiv = unsafePerformIO $ readIORef glrefVertexAttribP3uiv+{-# INLINE glVertexAttribP3uiv #-}+type FuntypeVertexAttribP4ui =+    GLuint ->+    GLenum ->+    GLboolean ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP4ui :: FunPtr FuntypeVertexAttribP4ui -> FuntypeVertexAttribP4ui+glrefVertexAttribP4ui :: IORef FuntypeVertexAttribP4ui+glrefVertexAttribP4ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP4ui #-}+glVertexAttribP4ui :: FuntypeVertexAttribP4ui+glVertexAttribP4ui = unsafePerformIO $ readIORef glrefVertexAttribP4ui+{-# INLINE glVertexAttribP4ui #-}+type FuntypeVertexAttribP4uiv =+    GLuint ->+    GLenum ->+    GLboolean ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexAttribP4uiv :: FunPtr FuntypeVertexAttribP4uiv -> FuntypeVertexAttribP4uiv+glrefVertexAttribP4uiv :: IORef FuntypeVertexAttribP4uiv+glrefVertexAttribP4uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexAttribP4uiv #-}+glVertexAttribP4uiv :: FuntypeVertexAttribP4uiv+glVertexAttribP4uiv = unsafePerformIO $ readIORef glrefVertexAttribP4uiv+{-# INLINE glVertexAttribP4uiv #-}++-- GL_ARB_texture_storage++type FuntypeTexStorage1D =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexStorage1D :: FunPtr FuntypeTexStorage1D -> FuntypeTexStorage1D+glrefTexStorage1D :: IORef FuntypeTexStorage1D+glrefTexStorage1D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexStorage1D #-}+glTexStorage1D :: FuntypeTexStorage1D+glTexStorage1D = unsafePerformIO $ readIORef glrefTexStorage1D+{-# INLINE glTexStorage1D #-}+type FuntypeTexStorage2D =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexStorage2D :: FunPtr FuntypeTexStorage2D -> FuntypeTexStorage2D+glrefTexStorage2D :: IORef FuntypeTexStorage2D+glrefTexStorage2D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexStorage2D #-}+glTexStorage2D :: FuntypeTexStorage2D+glTexStorage2D = unsafePerformIO $ readIORef glrefTexStorage2D+{-# INLINE glTexStorage2D #-}+type FuntypeTexStorage3D =+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexStorage3D :: FunPtr FuntypeTexStorage3D -> FuntypeTexStorage3D+glrefTexStorage3D :: IORef FuntypeTexStorage3D+glrefTexStorage3D = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexStorage3D #-}+glTexStorage3D :: FuntypeTexStorage3D+glTexStorage3D = unsafePerformIO $ readIORef glrefTexStorage3D+{-# INLINE glTexStorage3D #-}++-- GL_KHR_debug++type FuntypeDebugMessageControl =+    GLenum ->+    GLenum ->+    GLenum ->+    GLsizei ->+    Ptr (GLuint) ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageControl :: FunPtr FuntypeDebugMessageControl -> FuntypeDebugMessageControl+glrefDebugMessageControl :: IORef FuntypeDebugMessageControl+glrefDebugMessageControl = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageControl #-}+glDebugMessageControl :: FuntypeDebugMessageControl+glDebugMessageControl = unsafePerformIO $ readIORef glrefDebugMessageControl+{-# INLINE glDebugMessageControl #-}+type FuntypeDebugMessageInsert =+    GLenum ->+    GLenum ->+    GLuint ->+    GLenum ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageInsert :: FunPtr FuntypeDebugMessageInsert -> FuntypeDebugMessageInsert+glrefDebugMessageInsert :: IORef FuntypeDebugMessageInsert+glrefDebugMessageInsert = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageInsert #-}+glDebugMessageInsert :: FuntypeDebugMessageInsert+glDebugMessageInsert = unsafePerformIO $ readIORef glrefDebugMessageInsert+{-# INLINE glDebugMessageInsert #-}+type FuntypeDebugMessageCallback =+    GLDEBUGPROC ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageCallback :: FunPtr FuntypeDebugMessageCallback -> FuntypeDebugMessageCallback+glrefDebugMessageCallback :: IORef FuntypeDebugMessageCallback+glrefDebugMessageCallback = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageCallback #-}+glDebugMessageCallback :: FuntypeDebugMessageCallback+glDebugMessageCallback = unsafePerformIO $ readIORef glrefDebugMessageCallback+{-# INLINE glDebugMessageCallback #-}+type FuntypeGetDebugMessageLog =+    GLuint ->+    GLsizei ->+    Ptr (GLenum) ->+    Ptr (GLenum) ->+    Ptr (GLuint) ->+    Ptr (GLenum) ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetDebugMessageLog :: FunPtr FuntypeGetDebugMessageLog -> FuntypeGetDebugMessageLog+glrefGetDebugMessageLog :: IORef FuntypeGetDebugMessageLog+glrefGetDebugMessageLog = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetDebugMessageLog #-}+glGetDebugMessageLog :: FuntypeGetDebugMessageLog+glGetDebugMessageLog = unsafePerformIO $ readIORef glrefGetDebugMessageLog+{-# INLINE glGetDebugMessageLog #-}+type FuntypePushDebugGroup =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPushDebugGroup :: FunPtr FuntypePushDebugGroup -> FuntypePushDebugGroup+glrefPushDebugGroup :: IORef FuntypePushDebugGroup+glrefPushDebugGroup = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPushDebugGroup #-}+glPushDebugGroup :: FuntypePushDebugGroup+glPushDebugGroup = unsafePerformIO $ readIORef glrefPushDebugGroup+{-# INLINE glPushDebugGroup #-}+type FuntypePopDebugGroup =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPopDebugGroup :: FunPtr FuntypePopDebugGroup -> FuntypePopDebugGroup+glrefPopDebugGroup :: IORef FuntypePopDebugGroup+glrefPopDebugGroup = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPopDebugGroup #-}+glPopDebugGroup :: FuntypePopDebugGroup+glPopDebugGroup = unsafePerformIO $ readIORef glrefPopDebugGroup+{-# INLINE glPopDebugGroup #-}+type FuntypeObjectLabel =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynObjectLabel :: FunPtr FuntypeObjectLabel -> FuntypeObjectLabel+glrefObjectLabel :: IORef FuntypeObjectLabel+glrefObjectLabel = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefObjectLabel #-}+glObjectLabel :: FuntypeObjectLabel+glObjectLabel = unsafePerformIO $ readIORef glrefObjectLabel+{-# INLINE glObjectLabel #-}+type FuntypeGetObjectLabel =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetObjectLabel :: FunPtr FuntypeGetObjectLabel -> FuntypeGetObjectLabel+glrefGetObjectLabel :: IORef FuntypeGetObjectLabel+glrefGetObjectLabel = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetObjectLabel #-}+glGetObjectLabel :: FuntypeGetObjectLabel+glGetObjectLabel = unsafePerformIO $ readIORef glrefGetObjectLabel+{-# INLINE glGetObjectLabel #-}+type FuntypeObjectPtrLabel =+    Ptr () ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynObjectPtrLabel :: FunPtr FuntypeObjectPtrLabel -> FuntypeObjectPtrLabel+glrefObjectPtrLabel :: IORef FuntypeObjectPtrLabel+glrefObjectPtrLabel = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefObjectPtrLabel #-}+glObjectPtrLabel :: FuntypeObjectPtrLabel+glObjectPtrLabel = unsafePerformIO $ readIORef glrefObjectPtrLabel+{-# INLINE glObjectPtrLabel #-}+type FuntypeGetObjectPtrLabel =+    Ptr () ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetObjectPtrLabel :: FunPtr FuntypeGetObjectPtrLabel -> FuntypeGetObjectPtrLabel+glrefGetObjectPtrLabel :: IORef FuntypeGetObjectPtrLabel+glrefGetObjectPtrLabel = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetObjectPtrLabel #-}+glGetObjectPtrLabel :: FuntypeGetObjectPtrLabel+glGetObjectPtrLabel = unsafePerformIO $ readIORef glrefGetObjectPtrLabel+{-# INLINE glGetObjectPtrLabel #-}+type FuntypeGetPointerv =+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetPointerv :: FunPtr FuntypeGetPointerv -> FuntypeGetPointerv+glrefGetPointerv :: IORef FuntypeGetPointerv+glrefGetPointerv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetPointerv #-}+glGetPointerv :: FuntypeGetPointerv+glGetPointerv = unsafePerformIO $ readIORef glrefGetPointerv+{-# INLINE glGetPointerv #-}+type FuntypeDebugMessageControlKHR =+    GLenum ->+    GLenum ->+    GLenum ->+    GLsizei ->+    Ptr (GLuint) ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageControlKHR :: FunPtr FuntypeDebugMessageControlKHR -> FuntypeDebugMessageControlKHR+glrefDebugMessageControlKHR :: IORef FuntypeDebugMessageControlKHR+glrefDebugMessageControlKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageControlKHR #-}+glDebugMessageControlKHR :: FuntypeDebugMessageControlKHR+glDebugMessageControlKHR = unsafePerformIO $ readIORef glrefDebugMessageControlKHR+{-# INLINE glDebugMessageControlKHR #-}+type FuntypeDebugMessageInsertKHR =+    GLenum ->+    GLenum ->+    GLuint ->+    GLenum ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageInsertKHR :: FunPtr FuntypeDebugMessageInsertKHR -> FuntypeDebugMessageInsertKHR+glrefDebugMessageInsertKHR :: IORef FuntypeDebugMessageInsertKHR+glrefDebugMessageInsertKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageInsertKHR #-}+glDebugMessageInsertKHR :: FuntypeDebugMessageInsertKHR+glDebugMessageInsertKHR = unsafePerformIO $ readIORef glrefDebugMessageInsertKHR+{-# INLINE glDebugMessageInsertKHR #-}+type FuntypeDebugMessageCallbackKHR =+    GLDEBUGPROCKHR ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDebugMessageCallbackKHR :: FunPtr FuntypeDebugMessageCallbackKHR -> FuntypeDebugMessageCallbackKHR+glrefDebugMessageCallbackKHR :: IORef FuntypeDebugMessageCallbackKHR+glrefDebugMessageCallbackKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDebugMessageCallbackKHR #-}+glDebugMessageCallbackKHR :: FuntypeDebugMessageCallbackKHR+glDebugMessageCallbackKHR = unsafePerformIO $ readIORef glrefDebugMessageCallbackKHR+{-# INLINE glDebugMessageCallbackKHR #-}+type FuntypeGetDebugMessageLogKHR =+    GLuint ->+    GLsizei ->+    Ptr (GLenum) ->+    Ptr (GLenum) ->+    Ptr (GLuint) ->+    Ptr (GLenum) ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetDebugMessageLogKHR :: FunPtr FuntypeGetDebugMessageLogKHR -> FuntypeGetDebugMessageLogKHR+glrefGetDebugMessageLogKHR :: IORef FuntypeGetDebugMessageLogKHR+glrefGetDebugMessageLogKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetDebugMessageLogKHR #-}+glGetDebugMessageLogKHR :: FuntypeGetDebugMessageLogKHR+glGetDebugMessageLogKHR = unsafePerformIO $ readIORef glrefGetDebugMessageLogKHR+{-# INLINE glGetDebugMessageLogKHR #-}+type FuntypePushDebugGroupKHR =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPushDebugGroupKHR :: FunPtr FuntypePushDebugGroupKHR -> FuntypePushDebugGroupKHR+glrefPushDebugGroupKHR :: IORef FuntypePushDebugGroupKHR+glrefPushDebugGroupKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPushDebugGroupKHR #-}+glPushDebugGroupKHR :: FuntypePushDebugGroupKHR+glPushDebugGroupKHR = unsafePerformIO $ readIORef glrefPushDebugGroupKHR+{-# INLINE glPushDebugGroupKHR #-}+type FuntypePopDebugGroupKHR =+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPopDebugGroupKHR :: FunPtr FuntypePopDebugGroupKHR -> FuntypePopDebugGroupKHR+glrefPopDebugGroupKHR :: IORef FuntypePopDebugGroupKHR+glrefPopDebugGroupKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPopDebugGroupKHR #-}+glPopDebugGroupKHR :: FuntypePopDebugGroupKHR+glPopDebugGroupKHR = unsafePerformIO $ readIORef glrefPopDebugGroupKHR+{-# INLINE glPopDebugGroupKHR #-}+type FuntypeObjectLabelKHR =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynObjectLabelKHR :: FunPtr FuntypeObjectLabelKHR -> FuntypeObjectLabelKHR+glrefObjectLabelKHR :: IORef FuntypeObjectLabelKHR+glrefObjectLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefObjectLabelKHR #-}+glObjectLabelKHR :: FuntypeObjectLabelKHR+glObjectLabelKHR = unsafePerformIO $ readIORef glrefObjectLabelKHR+{-# INLINE glObjectLabelKHR #-}+type FuntypeGetObjectLabelKHR =+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetObjectLabelKHR :: FunPtr FuntypeGetObjectLabelKHR -> FuntypeGetObjectLabelKHR+glrefGetObjectLabelKHR :: IORef FuntypeGetObjectLabelKHR+glrefGetObjectLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetObjectLabelKHR #-}+glGetObjectLabelKHR :: FuntypeGetObjectLabelKHR+glGetObjectLabelKHR = unsafePerformIO $ readIORef glrefGetObjectLabelKHR+{-# INLINE glGetObjectLabelKHR #-}+type FuntypeObjectPtrLabelKHR =+    Ptr () ->+    GLsizei ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynObjectPtrLabelKHR :: FunPtr FuntypeObjectPtrLabelKHR -> FuntypeObjectPtrLabelKHR+glrefObjectPtrLabelKHR :: IORef FuntypeObjectPtrLabelKHR+glrefObjectPtrLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefObjectPtrLabelKHR #-}+glObjectPtrLabelKHR :: FuntypeObjectPtrLabelKHR+glObjectPtrLabelKHR = unsafePerformIO $ readIORef glrefObjectPtrLabelKHR+{-# INLINE glObjectPtrLabelKHR #-}+type FuntypeGetObjectPtrLabelKHR =+    Ptr () ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetObjectPtrLabelKHR :: FunPtr FuntypeGetObjectPtrLabelKHR -> FuntypeGetObjectPtrLabelKHR+glrefGetObjectPtrLabelKHR :: IORef FuntypeGetObjectPtrLabelKHR+glrefGetObjectPtrLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetObjectPtrLabelKHR #-}+glGetObjectPtrLabelKHR :: FuntypeGetObjectPtrLabelKHR+glGetObjectPtrLabelKHR = unsafePerformIO $ readIORef glrefGetObjectPtrLabelKHR+{-# INLINE glGetObjectPtrLabelKHR #-}+type FuntypeGetPointervKHR =+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetPointervKHR :: FunPtr FuntypeGetPointervKHR -> FuntypeGetPointervKHR+glrefGetPointervKHR :: IORef FuntypeGetPointervKHR+glrefGetPointervKHR = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetPointervKHR #-}+glGetPointervKHR :: FuntypeGetPointervKHR+glGetPointervKHR = unsafePerformIO $ readIORef glrefGetPointervKHR+{-# INLINE glGetPointervKHR #-}++-- GL_EXT_direct_state_access++type FuntypeMatrixLoadfEXT =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixLoadfEXT :: FunPtr FuntypeMatrixLoadfEXT -> FuntypeMatrixLoadfEXT+glrefMatrixLoadfEXT :: IORef FuntypeMatrixLoadfEXT+glrefMatrixLoadfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixLoadfEXT #-}+glMatrixLoadfEXT :: FuntypeMatrixLoadfEXT+glMatrixLoadfEXT = unsafePerformIO $ readIORef glrefMatrixLoadfEXT+{-# INLINE glMatrixLoadfEXT #-}+type FuntypeMatrixLoaddEXT =+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixLoaddEXT :: FunPtr FuntypeMatrixLoaddEXT -> FuntypeMatrixLoaddEXT+glrefMatrixLoaddEXT :: IORef FuntypeMatrixLoaddEXT+glrefMatrixLoaddEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixLoaddEXT #-}+glMatrixLoaddEXT :: FuntypeMatrixLoaddEXT+glMatrixLoaddEXT = unsafePerformIO $ readIORef glrefMatrixLoaddEXT+{-# INLINE glMatrixLoaddEXT #-}+type FuntypeMatrixMultfEXT =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixMultfEXT :: FunPtr FuntypeMatrixMultfEXT -> FuntypeMatrixMultfEXT+glrefMatrixMultfEXT :: IORef FuntypeMatrixMultfEXT+glrefMatrixMultfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixMultfEXT #-}+glMatrixMultfEXT :: FuntypeMatrixMultfEXT+glMatrixMultfEXT = unsafePerformIO $ readIORef glrefMatrixMultfEXT+{-# INLINE glMatrixMultfEXT #-}+type FuntypeMatrixMultdEXT =+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixMultdEXT :: FunPtr FuntypeMatrixMultdEXT -> FuntypeMatrixMultdEXT+glrefMatrixMultdEXT :: IORef FuntypeMatrixMultdEXT+glrefMatrixMultdEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixMultdEXT #-}+glMatrixMultdEXT :: FuntypeMatrixMultdEXT+glMatrixMultdEXT = unsafePerformIO $ readIORef glrefMatrixMultdEXT+{-# INLINE glMatrixMultdEXT #-}+type FuntypeMatrixLoadIdentityEXT =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixLoadIdentityEXT :: FunPtr FuntypeMatrixLoadIdentityEXT -> FuntypeMatrixLoadIdentityEXT+glrefMatrixLoadIdentityEXT :: IORef FuntypeMatrixLoadIdentityEXT+glrefMatrixLoadIdentityEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixLoadIdentityEXT #-}+glMatrixLoadIdentityEXT :: FuntypeMatrixLoadIdentityEXT+glMatrixLoadIdentityEXT = unsafePerformIO $ readIORef glrefMatrixLoadIdentityEXT+{-# INLINE glMatrixLoadIdentityEXT #-}+type FuntypeMatrixRotatefEXT =+    GLenum ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixRotatefEXT :: FunPtr FuntypeMatrixRotatefEXT -> FuntypeMatrixRotatefEXT+glrefMatrixRotatefEXT :: IORef FuntypeMatrixRotatefEXT+glrefMatrixRotatefEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixRotatefEXT #-}+glMatrixRotatefEXT :: FuntypeMatrixRotatefEXT+glMatrixRotatefEXT = unsafePerformIO $ readIORef glrefMatrixRotatefEXT+{-# INLINE glMatrixRotatefEXT #-}+type FuntypeMatrixRotatedEXT =+    GLenum ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixRotatedEXT :: FunPtr FuntypeMatrixRotatedEXT -> FuntypeMatrixRotatedEXT+glrefMatrixRotatedEXT :: IORef FuntypeMatrixRotatedEXT+glrefMatrixRotatedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixRotatedEXT #-}+glMatrixRotatedEXT :: FuntypeMatrixRotatedEXT+glMatrixRotatedEXT = unsafePerformIO $ readIORef glrefMatrixRotatedEXT+{-# INLINE glMatrixRotatedEXT #-}+type FuntypeMatrixScalefEXT =+    GLenum ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixScalefEXT :: FunPtr FuntypeMatrixScalefEXT -> FuntypeMatrixScalefEXT+glrefMatrixScalefEXT :: IORef FuntypeMatrixScalefEXT+glrefMatrixScalefEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixScalefEXT #-}+glMatrixScalefEXT :: FuntypeMatrixScalefEXT+glMatrixScalefEXT = unsafePerformIO $ readIORef glrefMatrixScalefEXT+{-# INLINE glMatrixScalefEXT #-}+type FuntypeMatrixScaledEXT =+    GLenum ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixScaledEXT :: FunPtr FuntypeMatrixScaledEXT -> FuntypeMatrixScaledEXT+glrefMatrixScaledEXT :: IORef FuntypeMatrixScaledEXT+glrefMatrixScaledEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixScaledEXT #-}+glMatrixScaledEXT :: FuntypeMatrixScaledEXT+glMatrixScaledEXT = unsafePerformIO $ readIORef glrefMatrixScaledEXT+{-# INLINE glMatrixScaledEXT #-}+type FuntypeMatrixTranslatefEXT =+    GLenum ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixTranslatefEXT :: FunPtr FuntypeMatrixTranslatefEXT -> FuntypeMatrixTranslatefEXT+glrefMatrixTranslatefEXT :: IORef FuntypeMatrixTranslatefEXT+glrefMatrixTranslatefEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixTranslatefEXT #-}+glMatrixTranslatefEXT :: FuntypeMatrixTranslatefEXT+glMatrixTranslatefEXT = unsafePerformIO $ readIORef glrefMatrixTranslatefEXT+{-# INLINE glMatrixTranslatefEXT #-}+type FuntypeMatrixTranslatedEXT =+    GLenum ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixTranslatedEXT :: FunPtr FuntypeMatrixTranslatedEXT -> FuntypeMatrixTranslatedEXT+glrefMatrixTranslatedEXT :: IORef FuntypeMatrixTranslatedEXT+glrefMatrixTranslatedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixTranslatedEXT #-}+glMatrixTranslatedEXT :: FuntypeMatrixTranslatedEXT+glMatrixTranslatedEXT = unsafePerformIO $ readIORef glrefMatrixTranslatedEXT+{-# INLINE glMatrixTranslatedEXT #-}+type FuntypeMatrixFrustumEXT =+    GLenum ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixFrustumEXT :: FunPtr FuntypeMatrixFrustumEXT -> FuntypeMatrixFrustumEXT+glrefMatrixFrustumEXT :: IORef FuntypeMatrixFrustumEXT+glrefMatrixFrustumEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixFrustumEXT #-}+glMatrixFrustumEXT :: FuntypeMatrixFrustumEXT+glMatrixFrustumEXT = unsafePerformIO $ readIORef glrefMatrixFrustumEXT+{-# INLINE glMatrixFrustumEXT #-}+type FuntypeMatrixOrthoEXT =+    GLenum ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixOrthoEXT :: FunPtr FuntypeMatrixOrthoEXT -> FuntypeMatrixOrthoEXT+glrefMatrixOrthoEXT :: IORef FuntypeMatrixOrthoEXT+glrefMatrixOrthoEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixOrthoEXT #-}+glMatrixOrthoEXT :: FuntypeMatrixOrthoEXT+glMatrixOrthoEXT = unsafePerformIO $ readIORef glrefMatrixOrthoEXT+{-# INLINE glMatrixOrthoEXT #-}+type FuntypeMatrixPopEXT =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixPopEXT :: FunPtr FuntypeMatrixPopEXT -> FuntypeMatrixPopEXT+glrefMatrixPopEXT :: IORef FuntypeMatrixPopEXT+glrefMatrixPopEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixPopEXT #-}+glMatrixPopEXT :: FuntypeMatrixPopEXT+glMatrixPopEXT = unsafePerformIO $ readIORef glrefMatrixPopEXT+{-# INLINE glMatrixPopEXT #-}+type FuntypeMatrixPushEXT =+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixPushEXT :: FunPtr FuntypeMatrixPushEXT -> FuntypeMatrixPushEXT+glrefMatrixPushEXT :: IORef FuntypeMatrixPushEXT+glrefMatrixPushEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixPushEXT #-}+glMatrixPushEXT :: FuntypeMatrixPushEXT+glMatrixPushEXT = unsafePerformIO $ readIORef glrefMatrixPushEXT+{-# INLINE glMatrixPushEXT #-}+type FuntypeClientAttribDefaultEXT =+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClientAttribDefaultEXT :: FunPtr FuntypeClientAttribDefaultEXT -> FuntypeClientAttribDefaultEXT+glrefClientAttribDefaultEXT :: IORef FuntypeClientAttribDefaultEXT+glrefClientAttribDefaultEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClientAttribDefaultEXT #-}+glClientAttribDefaultEXT :: FuntypeClientAttribDefaultEXT+glClientAttribDefaultEXT = unsafePerformIO $ readIORef glrefClientAttribDefaultEXT+{-# INLINE glClientAttribDefaultEXT #-}+type FuntypePushClientAttribDefaultEXT =+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynPushClientAttribDefaultEXT :: FunPtr FuntypePushClientAttribDefaultEXT -> FuntypePushClientAttribDefaultEXT+glrefPushClientAttribDefaultEXT :: IORef FuntypePushClientAttribDefaultEXT+glrefPushClientAttribDefaultEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefPushClientAttribDefaultEXT #-}+glPushClientAttribDefaultEXT :: FuntypePushClientAttribDefaultEXT+glPushClientAttribDefaultEXT = unsafePerformIO $ readIORef glrefPushClientAttribDefaultEXT+{-# INLINE glPushClientAttribDefaultEXT #-}+type FuntypeTextureParameterfEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameterfEXT :: FunPtr FuntypeTextureParameterfEXT -> FuntypeTextureParameterfEXT+glrefTextureParameterfEXT :: IORef FuntypeTextureParameterfEXT+glrefTextureParameterfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameterfEXT #-}+glTextureParameterfEXT :: FuntypeTextureParameterfEXT+glTextureParameterfEXT = unsafePerformIO $ readIORef glrefTextureParameterfEXT+{-# INLINE glTextureParameterfEXT #-}+type FuntypeTextureParameterfvEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameterfvEXT :: FunPtr FuntypeTextureParameterfvEXT -> FuntypeTextureParameterfvEXT+glrefTextureParameterfvEXT :: IORef FuntypeTextureParameterfvEXT+glrefTextureParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameterfvEXT #-}+glTextureParameterfvEXT :: FuntypeTextureParameterfvEXT+glTextureParameterfvEXT = unsafePerformIO $ readIORef glrefTextureParameterfvEXT+{-# INLINE glTextureParameterfvEXT #-}+type FuntypeTextureParameteriEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameteriEXT :: FunPtr FuntypeTextureParameteriEXT -> FuntypeTextureParameteriEXT+glrefTextureParameteriEXT :: IORef FuntypeTextureParameteriEXT+glrefTextureParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameteriEXT #-}+glTextureParameteriEXT :: FuntypeTextureParameteriEXT+glTextureParameteriEXT = unsafePerformIO $ readIORef glrefTextureParameteriEXT+{-# INLINE glTextureParameteriEXT #-}+type FuntypeTextureParameterivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameterivEXT :: FunPtr FuntypeTextureParameterivEXT -> FuntypeTextureParameterivEXT+glrefTextureParameterivEXT :: IORef FuntypeTextureParameterivEXT+glrefTextureParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameterivEXT #-}+glTextureParameterivEXT :: FuntypeTextureParameterivEXT+glTextureParameterivEXT = unsafePerformIO $ readIORef glrefTextureParameterivEXT+{-# INLINE glTextureParameterivEXT #-}+type FuntypeTextureImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureImage1DEXT :: FunPtr FuntypeTextureImage1DEXT -> FuntypeTextureImage1DEXT+glrefTextureImage1DEXT :: IORef FuntypeTextureImage1DEXT+glrefTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureImage1DEXT #-}+glTextureImage1DEXT :: FuntypeTextureImage1DEXT+glTextureImage1DEXT = unsafePerformIO $ readIORef glrefTextureImage1DEXT+{-# INLINE glTextureImage1DEXT #-}+type FuntypeTextureImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureImage2DEXT :: FunPtr FuntypeTextureImage2DEXT -> FuntypeTextureImage2DEXT+glrefTextureImage2DEXT :: IORef FuntypeTextureImage2DEXT+glrefTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureImage2DEXT #-}+glTextureImage2DEXT :: FuntypeTextureImage2DEXT+glTextureImage2DEXT = unsafePerformIO $ readIORef glrefTextureImage2DEXT+{-# INLINE glTextureImage2DEXT #-}+type FuntypeTextureSubImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureSubImage1DEXT :: FunPtr FuntypeTextureSubImage1DEXT -> FuntypeTextureSubImage1DEXT+glrefTextureSubImage1DEXT :: IORef FuntypeTextureSubImage1DEXT+glrefTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureSubImage1DEXT #-}+glTextureSubImage1DEXT :: FuntypeTextureSubImage1DEXT+glTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefTextureSubImage1DEXT+{-# INLINE glTextureSubImage1DEXT #-}+type FuntypeTextureSubImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureSubImage2DEXT :: FunPtr FuntypeTextureSubImage2DEXT -> FuntypeTextureSubImage2DEXT+glrefTextureSubImage2DEXT :: IORef FuntypeTextureSubImage2DEXT+glrefTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureSubImage2DEXT #-}+glTextureSubImage2DEXT :: FuntypeTextureSubImage2DEXT+glTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefTextureSubImage2DEXT+{-# INLINE glTextureSubImage2DEXT #-}+type FuntypeCopyTextureImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTextureImage1DEXT :: FunPtr FuntypeCopyTextureImage1DEXT -> FuntypeCopyTextureImage1DEXT+glrefCopyTextureImage1DEXT :: IORef FuntypeCopyTextureImage1DEXT+glrefCopyTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTextureImage1DEXT #-}+glCopyTextureImage1DEXT :: FuntypeCopyTextureImage1DEXT+glCopyTextureImage1DEXT = unsafePerformIO $ readIORef glrefCopyTextureImage1DEXT+{-# INLINE glCopyTextureImage1DEXT #-}+type FuntypeCopyTextureImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTextureImage2DEXT :: FunPtr FuntypeCopyTextureImage2DEXT -> FuntypeCopyTextureImage2DEXT+glrefCopyTextureImage2DEXT :: IORef FuntypeCopyTextureImage2DEXT+glrefCopyTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTextureImage2DEXT #-}+glCopyTextureImage2DEXT :: FuntypeCopyTextureImage2DEXT+glCopyTextureImage2DEXT = unsafePerformIO $ readIORef glrefCopyTextureImage2DEXT+{-# INLINE glCopyTextureImage2DEXT #-}+type FuntypeCopyTextureSubImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTextureSubImage1DEXT :: FunPtr FuntypeCopyTextureSubImage1DEXT -> FuntypeCopyTextureSubImage1DEXT+glrefCopyTextureSubImage1DEXT :: IORef FuntypeCopyTextureSubImage1DEXT+glrefCopyTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTextureSubImage1DEXT #-}+glCopyTextureSubImage1DEXT :: FuntypeCopyTextureSubImage1DEXT+glCopyTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage1DEXT+{-# INLINE glCopyTextureSubImage1DEXT #-}+type FuntypeCopyTextureSubImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTextureSubImage2DEXT :: FunPtr FuntypeCopyTextureSubImage2DEXT -> FuntypeCopyTextureSubImage2DEXT+glrefCopyTextureSubImage2DEXT :: IORef FuntypeCopyTextureSubImage2DEXT+glrefCopyTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTextureSubImage2DEXT #-}+glCopyTextureSubImage2DEXT :: FuntypeCopyTextureSubImage2DEXT+glCopyTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage2DEXT+{-# INLINE glCopyTextureSubImage2DEXT #-}+type FuntypeGetTextureImageEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureImageEXT :: FunPtr FuntypeGetTextureImageEXT -> FuntypeGetTextureImageEXT+glrefGetTextureImageEXT :: IORef FuntypeGetTextureImageEXT+glrefGetTextureImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureImageEXT #-}+glGetTextureImageEXT :: FuntypeGetTextureImageEXT+glGetTextureImageEXT = unsafePerformIO $ readIORef glrefGetTextureImageEXT+{-# INLINE glGetTextureImageEXT #-}+type FuntypeGetTextureParameterfvEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureParameterfvEXT :: FunPtr FuntypeGetTextureParameterfvEXT -> FuntypeGetTextureParameterfvEXT+glrefGetTextureParameterfvEXT :: IORef FuntypeGetTextureParameterfvEXT+glrefGetTextureParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureParameterfvEXT #-}+glGetTextureParameterfvEXT :: FuntypeGetTextureParameterfvEXT+glGetTextureParameterfvEXT = unsafePerformIO $ readIORef glrefGetTextureParameterfvEXT+{-# INLINE glGetTextureParameterfvEXT #-}+type FuntypeGetTextureParameterivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureParameterivEXT :: FunPtr FuntypeGetTextureParameterivEXT -> FuntypeGetTextureParameterivEXT+glrefGetTextureParameterivEXT :: IORef FuntypeGetTextureParameterivEXT+glrefGetTextureParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureParameterivEXT #-}+glGetTextureParameterivEXT :: FuntypeGetTextureParameterivEXT+glGetTextureParameterivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterivEXT+{-# INLINE glGetTextureParameterivEXT #-}+type FuntypeGetTextureLevelParameterfvEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureLevelParameterfvEXT :: FunPtr FuntypeGetTextureLevelParameterfvEXT -> FuntypeGetTextureLevelParameterfvEXT+glrefGetTextureLevelParameterfvEXT :: IORef FuntypeGetTextureLevelParameterfvEXT+glrefGetTextureLevelParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureLevelParameterfvEXT #-}+glGetTextureLevelParameterfvEXT :: FuntypeGetTextureLevelParameterfvEXT+glGetTextureLevelParameterfvEXT = unsafePerformIO $ readIORef glrefGetTextureLevelParameterfvEXT+{-# INLINE glGetTextureLevelParameterfvEXT #-}+type FuntypeGetTextureLevelParameterivEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureLevelParameterivEXT :: FunPtr FuntypeGetTextureLevelParameterivEXT -> FuntypeGetTextureLevelParameterivEXT+glrefGetTextureLevelParameterivEXT :: IORef FuntypeGetTextureLevelParameterivEXT+glrefGetTextureLevelParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureLevelParameterivEXT #-}+glGetTextureLevelParameterivEXT :: FuntypeGetTextureLevelParameterivEXT+glGetTextureLevelParameterivEXT = unsafePerformIO $ readIORef glrefGetTextureLevelParameterivEXT+{-# INLINE glGetTextureLevelParameterivEXT #-}+type FuntypeTextureImage3DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureImage3DEXT :: FunPtr FuntypeTextureImage3DEXT -> FuntypeTextureImage3DEXT+glrefTextureImage3DEXT :: IORef FuntypeTextureImage3DEXT+glrefTextureImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureImage3DEXT #-}+glTextureImage3DEXT :: FuntypeTextureImage3DEXT+glTextureImage3DEXT = unsafePerformIO $ readIORef glrefTextureImage3DEXT+{-# INLINE glTextureImage3DEXT #-}+type FuntypeTextureSubImage3DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureSubImage3DEXT :: FunPtr FuntypeTextureSubImage3DEXT -> FuntypeTextureSubImage3DEXT+glrefTextureSubImage3DEXT :: IORef FuntypeTextureSubImage3DEXT+glrefTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureSubImage3DEXT #-}+glTextureSubImage3DEXT :: FuntypeTextureSubImage3DEXT+glTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefTextureSubImage3DEXT+{-# INLINE glTextureSubImage3DEXT #-}+type FuntypeCopyTextureSubImage3DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyTextureSubImage3DEXT :: FunPtr FuntypeCopyTextureSubImage3DEXT -> FuntypeCopyTextureSubImage3DEXT+glrefCopyTextureSubImage3DEXT :: IORef FuntypeCopyTextureSubImage3DEXT+glrefCopyTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyTextureSubImage3DEXT #-}+glCopyTextureSubImage3DEXT :: FuntypeCopyTextureSubImage3DEXT+glCopyTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage3DEXT+{-# INLINE glCopyTextureSubImage3DEXT #-}+type FuntypeBindMultiTextureEXT =+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindMultiTextureEXT :: FunPtr FuntypeBindMultiTextureEXT -> FuntypeBindMultiTextureEXT+glrefBindMultiTextureEXT :: IORef FuntypeBindMultiTextureEXT+glrefBindMultiTextureEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindMultiTextureEXT #-}+glBindMultiTextureEXT :: FuntypeBindMultiTextureEXT+glBindMultiTextureEXT = unsafePerformIO $ readIORef glrefBindMultiTextureEXT+{-# INLINE glBindMultiTextureEXT #-}+type FuntypeMultiTexCoordPointerEXT =+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexCoordPointerEXT :: FunPtr FuntypeMultiTexCoordPointerEXT -> FuntypeMultiTexCoordPointerEXT+glrefMultiTexCoordPointerEXT :: IORef FuntypeMultiTexCoordPointerEXT+glrefMultiTexCoordPointerEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexCoordPointerEXT #-}+glMultiTexCoordPointerEXT :: FuntypeMultiTexCoordPointerEXT+glMultiTexCoordPointerEXT = unsafePerformIO $ readIORef glrefMultiTexCoordPointerEXT+{-# INLINE glMultiTexCoordPointerEXT #-}+type FuntypeMultiTexEnvfEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexEnvfEXT :: FunPtr FuntypeMultiTexEnvfEXT -> FuntypeMultiTexEnvfEXT+glrefMultiTexEnvfEXT :: IORef FuntypeMultiTexEnvfEXT+glrefMultiTexEnvfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexEnvfEXT #-}+glMultiTexEnvfEXT :: FuntypeMultiTexEnvfEXT+glMultiTexEnvfEXT = unsafePerformIO $ readIORef glrefMultiTexEnvfEXT+{-# INLINE glMultiTexEnvfEXT #-}+type FuntypeMultiTexEnvfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexEnvfvEXT :: FunPtr FuntypeMultiTexEnvfvEXT -> FuntypeMultiTexEnvfvEXT+glrefMultiTexEnvfvEXT :: IORef FuntypeMultiTexEnvfvEXT+glrefMultiTexEnvfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexEnvfvEXT #-}+glMultiTexEnvfvEXT :: FuntypeMultiTexEnvfvEXT+glMultiTexEnvfvEXT = unsafePerformIO $ readIORef glrefMultiTexEnvfvEXT+{-# INLINE glMultiTexEnvfvEXT #-}+type FuntypeMultiTexEnviEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexEnviEXT :: FunPtr FuntypeMultiTexEnviEXT -> FuntypeMultiTexEnviEXT+glrefMultiTexEnviEXT :: IORef FuntypeMultiTexEnviEXT+glrefMultiTexEnviEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexEnviEXT #-}+glMultiTexEnviEXT :: FuntypeMultiTexEnviEXT+glMultiTexEnviEXT = unsafePerformIO $ readIORef glrefMultiTexEnviEXT+{-# INLINE glMultiTexEnviEXT #-}+type FuntypeMultiTexEnvivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexEnvivEXT :: FunPtr FuntypeMultiTexEnvivEXT -> FuntypeMultiTexEnvivEXT+glrefMultiTexEnvivEXT :: IORef FuntypeMultiTexEnvivEXT+glrefMultiTexEnvivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexEnvivEXT #-}+glMultiTexEnvivEXT :: FuntypeMultiTexEnvivEXT+glMultiTexEnvivEXT = unsafePerformIO $ readIORef glrefMultiTexEnvivEXT+{-# INLINE glMultiTexEnvivEXT #-}+type FuntypeMultiTexGendEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGendEXT :: FunPtr FuntypeMultiTexGendEXT -> FuntypeMultiTexGendEXT+glrefMultiTexGendEXT :: IORef FuntypeMultiTexGendEXT+glrefMultiTexGendEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGendEXT #-}+glMultiTexGendEXT :: FuntypeMultiTexGendEXT+glMultiTexGendEXT = unsafePerformIO $ readIORef glrefMultiTexGendEXT+{-# INLINE glMultiTexGendEXT #-}+type FuntypeMultiTexGendvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGendvEXT :: FunPtr FuntypeMultiTexGendvEXT -> FuntypeMultiTexGendvEXT+glrefMultiTexGendvEXT :: IORef FuntypeMultiTexGendvEXT+glrefMultiTexGendvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGendvEXT #-}+glMultiTexGendvEXT :: FuntypeMultiTexGendvEXT+glMultiTexGendvEXT = unsafePerformIO $ readIORef glrefMultiTexGendvEXT+{-# INLINE glMultiTexGendvEXT #-}+type FuntypeMultiTexGenfEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGenfEXT :: FunPtr FuntypeMultiTexGenfEXT -> FuntypeMultiTexGenfEXT+glrefMultiTexGenfEXT :: IORef FuntypeMultiTexGenfEXT+glrefMultiTexGenfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGenfEXT #-}+glMultiTexGenfEXT :: FuntypeMultiTexGenfEXT+glMultiTexGenfEXT = unsafePerformIO $ readIORef glrefMultiTexGenfEXT+{-# INLINE glMultiTexGenfEXT #-}+type FuntypeMultiTexGenfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGenfvEXT :: FunPtr FuntypeMultiTexGenfvEXT -> FuntypeMultiTexGenfvEXT+glrefMultiTexGenfvEXT :: IORef FuntypeMultiTexGenfvEXT+glrefMultiTexGenfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGenfvEXT #-}+glMultiTexGenfvEXT :: FuntypeMultiTexGenfvEXT+glMultiTexGenfvEXT = unsafePerformIO $ readIORef glrefMultiTexGenfvEXT+{-# INLINE glMultiTexGenfvEXT #-}+type FuntypeMultiTexGeniEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGeniEXT :: FunPtr FuntypeMultiTexGeniEXT -> FuntypeMultiTexGeniEXT+glrefMultiTexGeniEXT :: IORef FuntypeMultiTexGeniEXT+glrefMultiTexGeniEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGeniEXT #-}+glMultiTexGeniEXT :: FuntypeMultiTexGeniEXT+glMultiTexGeniEXT = unsafePerformIO $ readIORef glrefMultiTexGeniEXT+{-# INLINE glMultiTexGeniEXT #-}+type FuntypeMultiTexGenivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexGenivEXT :: FunPtr FuntypeMultiTexGenivEXT -> FuntypeMultiTexGenivEXT+glrefMultiTexGenivEXT :: IORef FuntypeMultiTexGenivEXT+glrefMultiTexGenivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexGenivEXT #-}+glMultiTexGenivEXT :: FuntypeMultiTexGenivEXT+glMultiTexGenivEXT = unsafePerformIO $ readIORef glrefMultiTexGenivEXT+{-# INLINE glMultiTexGenivEXT #-}+type FuntypeGetMultiTexEnvfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexEnvfvEXT :: FunPtr FuntypeGetMultiTexEnvfvEXT -> FuntypeGetMultiTexEnvfvEXT+glrefGetMultiTexEnvfvEXT :: IORef FuntypeGetMultiTexEnvfvEXT+glrefGetMultiTexEnvfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexEnvfvEXT #-}+glGetMultiTexEnvfvEXT :: FuntypeGetMultiTexEnvfvEXT+glGetMultiTexEnvfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexEnvfvEXT+{-# INLINE glGetMultiTexEnvfvEXT #-}+type FuntypeGetMultiTexEnvivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexEnvivEXT :: FunPtr FuntypeGetMultiTexEnvivEXT -> FuntypeGetMultiTexEnvivEXT+glrefGetMultiTexEnvivEXT :: IORef FuntypeGetMultiTexEnvivEXT+glrefGetMultiTexEnvivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexEnvivEXT #-}+glGetMultiTexEnvivEXT :: FuntypeGetMultiTexEnvivEXT+glGetMultiTexEnvivEXT = unsafePerformIO $ readIORef glrefGetMultiTexEnvivEXT+{-# INLINE glGetMultiTexEnvivEXT #-}+type FuntypeGetMultiTexGendvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexGendvEXT :: FunPtr FuntypeGetMultiTexGendvEXT -> FuntypeGetMultiTexGendvEXT+glrefGetMultiTexGendvEXT :: IORef FuntypeGetMultiTexGendvEXT+glrefGetMultiTexGendvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexGendvEXT #-}+glGetMultiTexGendvEXT :: FuntypeGetMultiTexGendvEXT+glGetMultiTexGendvEXT = unsafePerformIO $ readIORef glrefGetMultiTexGendvEXT+{-# INLINE glGetMultiTexGendvEXT #-}+type FuntypeGetMultiTexGenfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexGenfvEXT :: FunPtr FuntypeGetMultiTexGenfvEXT -> FuntypeGetMultiTexGenfvEXT+glrefGetMultiTexGenfvEXT :: IORef FuntypeGetMultiTexGenfvEXT+glrefGetMultiTexGenfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexGenfvEXT #-}+glGetMultiTexGenfvEXT :: FuntypeGetMultiTexGenfvEXT+glGetMultiTexGenfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexGenfvEXT+{-# INLINE glGetMultiTexGenfvEXT #-}+type FuntypeGetMultiTexGenivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexGenivEXT :: FunPtr FuntypeGetMultiTexGenivEXT -> FuntypeGetMultiTexGenivEXT+glrefGetMultiTexGenivEXT :: IORef FuntypeGetMultiTexGenivEXT+glrefGetMultiTexGenivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexGenivEXT #-}+glGetMultiTexGenivEXT :: FuntypeGetMultiTexGenivEXT+glGetMultiTexGenivEXT = unsafePerformIO $ readIORef glrefGetMultiTexGenivEXT+{-# INLINE glGetMultiTexGenivEXT #-}+type FuntypeMultiTexParameteriEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameteriEXT :: FunPtr FuntypeMultiTexParameteriEXT -> FuntypeMultiTexParameteriEXT+glrefMultiTexParameteriEXT :: IORef FuntypeMultiTexParameteriEXT+glrefMultiTexParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameteriEXT #-}+glMultiTexParameteriEXT :: FuntypeMultiTexParameteriEXT+glMultiTexParameteriEXT = unsafePerformIO $ readIORef glrefMultiTexParameteriEXT+{-# INLINE glMultiTexParameteriEXT #-}+type FuntypeMultiTexParameterivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameterivEXT :: FunPtr FuntypeMultiTexParameterivEXT -> FuntypeMultiTexParameterivEXT+glrefMultiTexParameterivEXT :: IORef FuntypeMultiTexParameterivEXT+glrefMultiTexParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameterivEXT #-}+glMultiTexParameterivEXT :: FuntypeMultiTexParameterivEXT+glMultiTexParameterivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterivEXT+{-# INLINE glMultiTexParameterivEXT #-}+type FuntypeMultiTexParameterfEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameterfEXT :: FunPtr FuntypeMultiTexParameterfEXT -> FuntypeMultiTexParameterfEXT+glrefMultiTexParameterfEXT :: IORef FuntypeMultiTexParameterfEXT+glrefMultiTexParameterfEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameterfEXT #-}+glMultiTexParameterfEXT :: FuntypeMultiTexParameterfEXT+glMultiTexParameterfEXT = unsafePerformIO $ readIORef glrefMultiTexParameterfEXT+{-# INLINE glMultiTexParameterfEXT #-}+type FuntypeMultiTexParameterfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameterfvEXT :: FunPtr FuntypeMultiTexParameterfvEXT -> FuntypeMultiTexParameterfvEXT+glrefMultiTexParameterfvEXT :: IORef FuntypeMultiTexParameterfvEXT+glrefMultiTexParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameterfvEXT #-}+glMultiTexParameterfvEXT :: FuntypeMultiTexParameterfvEXT+glMultiTexParameterfvEXT = unsafePerformIO $ readIORef glrefMultiTexParameterfvEXT+{-# INLINE glMultiTexParameterfvEXT #-}+type FuntypeMultiTexImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexImage1DEXT :: FunPtr FuntypeMultiTexImage1DEXT -> FuntypeMultiTexImage1DEXT+glrefMultiTexImage1DEXT :: IORef FuntypeMultiTexImage1DEXT+glrefMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexImage1DEXT #-}+glMultiTexImage1DEXT :: FuntypeMultiTexImage1DEXT+glMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefMultiTexImage1DEXT+{-# INLINE glMultiTexImage1DEXT #-}+type FuntypeMultiTexImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexImage2DEXT :: FunPtr FuntypeMultiTexImage2DEXT -> FuntypeMultiTexImage2DEXT+glrefMultiTexImage2DEXT :: IORef FuntypeMultiTexImage2DEXT+glrefMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexImage2DEXT #-}+glMultiTexImage2DEXT :: FuntypeMultiTexImage2DEXT+glMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefMultiTexImage2DEXT+{-# INLINE glMultiTexImage2DEXT #-}+type FuntypeMultiTexSubImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexSubImage1DEXT :: FunPtr FuntypeMultiTexSubImage1DEXT -> FuntypeMultiTexSubImage1DEXT+glrefMultiTexSubImage1DEXT :: IORef FuntypeMultiTexSubImage1DEXT+glrefMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexSubImage1DEXT #-}+glMultiTexSubImage1DEXT :: FuntypeMultiTexSubImage1DEXT+glMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage1DEXT+{-# INLINE glMultiTexSubImage1DEXT #-}+type FuntypeMultiTexSubImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexSubImage2DEXT :: FunPtr FuntypeMultiTexSubImage2DEXT -> FuntypeMultiTexSubImage2DEXT+glrefMultiTexSubImage2DEXT :: IORef FuntypeMultiTexSubImage2DEXT+glrefMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexSubImage2DEXT #-}+glMultiTexSubImage2DEXT :: FuntypeMultiTexSubImage2DEXT+glMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage2DEXT+{-# INLINE glMultiTexSubImage2DEXT #-}+type FuntypeCopyMultiTexImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyMultiTexImage1DEXT :: FunPtr FuntypeCopyMultiTexImage1DEXT -> FuntypeCopyMultiTexImage1DEXT+glrefCopyMultiTexImage1DEXT :: IORef FuntypeCopyMultiTexImage1DEXT+glrefCopyMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyMultiTexImage1DEXT #-}+glCopyMultiTexImage1DEXT :: FuntypeCopyMultiTexImage1DEXT+glCopyMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexImage1DEXT+{-# INLINE glCopyMultiTexImage1DEXT #-}+type FuntypeCopyMultiTexImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyMultiTexImage2DEXT :: FunPtr FuntypeCopyMultiTexImage2DEXT -> FuntypeCopyMultiTexImage2DEXT+glrefCopyMultiTexImage2DEXT :: IORef FuntypeCopyMultiTexImage2DEXT+glrefCopyMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyMultiTexImage2DEXT #-}+glCopyMultiTexImage2DEXT :: FuntypeCopyMultiTexImage2DEXT+glCopyMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexImage2DEXT+{-# INLINE glCopyMultiTexImage2DEXT #-}+type FuntypeCopyMultiTexSubImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyMultiTexSubImage1DEXT :: FunPtr FuntypeCopyMultiTexSubImage1DEXT -> FuntypeCopyMultiTexSubImage1DEXT+glrefCopyMultiTexSubImage1DEXT :: IORef FuntypeCopyMultiTexSubImage1DEXT+glrefCopyMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyMultiTexSubImage1DEXT #-}+glCopyMultiTexSubImage1DEXT :: FuntypeCopyMultiTexSubImage1DEXT+glCopyMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage1DEXT+{-# INLINE glCopyMultiTexSubImage1DEXT #-}+type FuntypeCopyMultiTexSubImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyMultiTexSubImage2DEXT :: FunPtr FuntypeCopyMultiTexSubImage2DEXT -> FuntypeCopyMultiTexSubImage2DEXT+glrefCopyMultiTexSubImage2DEXT :: IORef FuntypeCopyMultiTexSubImage2DEXT+glrefCopyMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyMultiTexSubImage2DEXT #-}+glCopyMultiTexSubImage2DEXT :: FuntypeCopyMultiTexSubImage2DEXT+glCopyMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage2DEXT+{-# INLINE glCopyMultiTexSubImage2DEXT #-}+type FuntypeGetMultiTexImageEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexImageEXT :: FunPtr FuntypeGetMultiTexImageEXT -> FuntypeGetMultiTexImageEXT+glrefGetMultiTexImageEXT :: IORef FuntypeGetMultiTexImageEXT+glrefGetMultiTexImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexImageEXT #-}+glGetMultiTexImageEXT :: FuntypeGetMultiTexImageEXT+glGetMultiTexImageEXT = unsafePerformIO $ readIORef glrefGetMultiTexImageEXT+{-# INLINE glGetMultiTexImageEXT #-}+type FuntypeGetMultiTexParameterfvEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexParameterfvEXT :: FunPtr FuntypeGetMultiTexParameterfvEXT -> FuntypeGetMultiTexParameterfvEXT+glrefGetMultiTexParameterfvEXT :: IORef FuntypeGetMultiTexParameterfvEXT+glrefGetMultiTexParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexParameterfvEXT #-}+glGetMultiTexParameterfvEXT :: FuntypeGetMultiTexParameterfvEXT+glGetMultiTexParameterfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterfvEXT+{-# INLINE glGetMultiTexParameterfvEXT #-}+type FuntypeGetMultiTexParameterivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexParameterivEXT :: FunPtr FuntypeGetMultiTexParameterivEXT -> FuntypeGetMultiTexParameterivEXT+glrefGetMultiTexParameterivEXT :: IORef FuntypeGetMultiTexParameterivEXT+glrefGetMultiTexParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexParameterivEXT #-}+glGetMultiTexParameterivEXT :: FuntypeGetMultiTexParameterivEXT+glGetMultiTexParameterivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterivEXT+{-# INLINE glGetMultiTexParameterivEXT #-}+type FuntypeGetMultiTexLevelParameterfvEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexLevelParameterfvEXT :: FunPtr FuntypeGetMultiTexLevelParameterfvEXT -> FuntypeGetMultiTexLevelParameterfvEXT+glrefGetMultiTexLevelParameterfvEXT :: IORef FuntypeGetMultiTexLevelParameterfvEXT+glrefGetMultiTexLevelParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexLevelParameterfvEXT #-}+glGetMultiTexLevelParameterfvEXT :: FuntypeGetMultiTexLevelParameterfvEXT+glGetMultiTexLevelParameterfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexLevelParameterfvEXT+{-# INLINE glGetMultiTexLevelParameterfvEXT #-}+type FuntypeGetMultiTexLevelParameterivEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexLevelParameterivEXT :: FunPtr FuntypeGetMultiTexLevelParameterivEXT -> FuntypeGetMultiTexLevelParameterivEXT+glrefGetMultiTexLevelParameterivEXT :: IORef FuntypeGetMultiTexLevelParameterivEXT+glrefGetMultiTexLevelParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexLevelParameterivEXT #-}+glGetMultiTexLevelParameterivEXT :: FuntypeGetMultiTexLevelParameterivEXT+glGetMultiTexLevelParameterivEXT = unsafePerformIO $ readIORef glrefGetMultiTexLevelParameterivEXT+{-# INLINE glGetMultiTexLevelParameterivEXT #-}+type FuntypeMultiTexImage3DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexImage3DEXT :: FunPtr FuntypeMultiTexImage3DEXT -> FuntypeMultiTexImage3DEXT+glrefMultiTexImage3DEXT :: IORef FuntypeMultiTexImage3DEXT+glrefMultiTexImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexImage3DEXT #-}+glMultiTexImage3DEXT :: FuntypeMultiTexImage3DEXT+glMultiTexImage3DEXT = unsafePerformIO $ readIORef glrefMultiTexImage3DEXT+{-# INLINE glMultiTexImage3DEXT #-}+type FuntypeMultiTexSubImage3DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexSubImage3DEXT :: FunPtr FuntypeMultiTexSubImage3DEXT -> FuntypeMultiTexSubImage3DEXT+glrefMultiTexSubImage3DEXT :: IORef FuntypeMultiTexSubImage3DEXT+glrefMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexSubImage3DEXT #-}+glMultiTexSubImage3DEXT :: FuntypeMultiTexSubImage3DEXT+glMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage3DEXT+{-# INLINE glMultiTexSubImage3DEXT #-}+type FuntypeCopyMultiTexSubImage3DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCopyMultiTexSubImage3DEXT :: FunPtr FuntypeCopyMultiTexSubImage3DEXT -> FuntypeCopyMultiTexSubImage3DEXT+glrefCopyMultiTexSubImage3DEXT :: IORef FuntypeCopyMultiTexSubImage3DEXT+glrefCopyMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCopyMultiTexSubImage3DEXT #-}+glCopyMultiTexSubImage3DEXT :: FuntypeCopyMultiTexSubImage3DEXT+glCopyMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage3DEXT+{-# INLINE glCopyMultiTexSubImage3DEXT #-}+type FuntypeEnableClientStateIndexedEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableClientStateIndexedEXT :: FunPtr FuntypeEnableClientStateIndexedEXT -> FuntypeEnableClientStateIndexedEXT+glrefEnableClientStateIndexedEXT :: IORef FuntypeEnableClientStateIndexedEXT+glrefEnableClientStateIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableClientStateIndexedEXT #-}+glEnableClientStateIndexedEXT :: FuntypeEnableClientStateIndexedEXT+glEnableClientStateIndexedEXT = unsafePerformIO $ readIORef glrefEnableClientStateIndexedEXT+{-# INLINE glEnableClientStateIndexedEXT #-}+type FuntypeDisableClientStateIndexedEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableClientStateIndexedEXT :: FunPtr FuntypeDisableClientStateIndexedEXT -> FuntypeDisableClientStateIndexedEXT+glrefDisableClientStateIndexedEXT :: IORef FuntypeDisableClientStateIndexedEXT+glrefDisableClientStateIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableClientStateIndexedEXT #-}+glDisableClientStateIndexedEXT :: FuntypeDisableClientStateIndexedEXT+glDisableClientStateIndexedEXT = unsafePerformIO $ readIORef glrefDisableClientStateIndexedEXT+{-# INLINE glDisableClientStateIndexedEXT #-}+type FuntypeGetFloatIndexedvEXT =+    GLenum ->+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFloatIndexedvEXT :: FunPtr FuntypeGetFloatIndexedvEXT -> FuntypeGetFloatIndexedvEXT+glrefGetFloatIndexedvEXT :: IORef FuntypeGetFloatIndexedvEXT+glrefGetFloatIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFloatIndexedvEXT #-}+glGetFloatIndexedvEXT :: FuntypeGetFloatIndexedvEXT+glGetFloatIndexedvEXT = unsafePerformIO $ readIORef glrefGetFloatIndexedvEXT+{-# INLINE glGetFloatIndexedvEXT #-}+type FuntypeGetDoubleIndexedvEXT =+    GLenum ->+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetDoubleIndexedvEXT :: FunPtr FuntypeGetDoubleIndexedvEXT -> FuntypeGetDoubleIndexedvEXT+glrefGetDoubleIndexedvEXT :: IORef FuntypeGetDoubleIndexedvEXT+glrefGetDoubleIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetDoubleIndexedvEXT #-}+glGetDoubleIndexedvEXT :: FuntypeGetDoubleIndexedvEXT+glGetDoubleIndexedvEXT = unsafePerformIO $ readIORef glrefGetDoubleIndexedvEXT+{-# INLINE glGetDoubleIndexedvEXT #-}+type FuntypeGetPointerIndexedvEXT =+    GLenum ->+    GLuint ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetPointerIndexedvEXT :: FunPtr FuntypeGetPointerIndexedvEXT -> FuntypeGetPointerIndexedvEXT+glrefGetPointerIndexedvEXT :: IORef FuntypeGetPointerIndexedvEXT+glrefGetPointerIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetPointerIndexedvEXT #-}+glGetPointerIndexedvEXT :: FuntypeGetPointerIndexedvEXT+glGetPointerIndexedvEXT = unsafePerformIO $ readIORef glrefGetPointerIndexedvEXT+{-# INLINE glGetPointerIndexedvEXT #-}+type FuntypeEnableIndexedEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableIndexedEXT :: FunPtr FuntypeEnableIndexedEXT -> FuntypeEnableIndexedEXT+glrefEnableIndexedEXT :: IORef FuntypeEnableIndexedEXT+glrefEnableIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableIndexedEXT #-}+glEnableIndexedEXT :: FuntypeEnableIndexedEXT+glEnableIndexedEXT = unsafePerformIO $ readIORef glrefEnableIndexedEXT+{-# INLINE glEnableIndexedEXT #-}+type FuntypeDisableIndexedEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableIndexedEXT :: FunPtr FuntypeDisableIndexedEXT -> FuntypeDisableIndexedEXT+glrefDisableIndexedEXT :: IORef FuntypeDisableIndexedEXT+glrefDisableIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableIndexedEXT #-}+glDisableIndexedEXT :: FuntypeDisableIndexedEXT+glDisableIndexedEXT = unsafePerformIO $ readIORef glrefDisableIndexedEXT+{-# INLINE glDisableIndexedEXT #-}+type FuntypeIsEnabledIndexedEXT =+    GLenum ->+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsEnabledIndexedEXT :: FunPtr FuntypeIsEnabledIndexedEXT -> FuntypeIsEnabledIndexedEXT+glrefIsEnabledIndexedEXT :: IORef FuntypeIsEnabledIndexedEXT+glrefIsEnabledIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsEnabledIndexedEXT #-}+glIsEnabledIndexedEXT :: FuntypeIsEnabledIndexedEXT+glIsEnabledIndexedEXT = unsafePerformIO $ readIORef glrefIsEnabledIndexedEXT+{-# INLINE glIsEnabledIndexedEXT #-}+type FuntypeGetIntegerIndexedvEXT =+    GLenum ->+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetIntegerIndexedvEXT :: FunPtr FuntypeGetIntegerIndexedvEXT -> FuntypeGetIntegerIndexedvEXT+glrefGetIntegerIndexedvEXT :: IORef FuntypeGetIntegerIndexedvEXT+glrefGetIntegerIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetIntegerIndexedvEXT #-}+glGetIntegerIndexedvEXT :: FuntypeGetIntegerIndexedvEXT+glGetIntegerIndexedvEXT = unsafePerformIO $ readIORef glrefGetIntegerIndexedvEXT+{-# INLINE glGetIntegerIndexedvEXT #-}+type FuntypeGetBooleanIndexedvEXT =+    GLenum ->+    GLuint ->+    Ptr (GLboolean) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetBooleanIndexedvEXT :: FunPtr FuntypeGetBooleanIndexedvEXT -> FuntypeGetBooleanIndexedvEXT+glrefGetBooleanIndexedvEXT :: IORef FuntypeGetBooleanIndexedvEXT+glrefGetBooleanIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetBooleanIndexedvEXT #-}+glGetBooleanIndexedvEXT :: FuntypeGetBooleanIndexedvEXT+glGetBooleanIndexedvEXT = unsafePerformIO $ readIORef glrefGetBooleanIndexedvEXT+{-# INLINE glGetBooleanIndexedvEXT #-}+type FuntypeCompressedTextureImage3DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureImage3DEXT :: FunPtr FuntypeCompressedTextureImage3DEXT -> FuntypeCompressedTextureImage3DEXT+glrefCompressedTextureImage3DEXT :: IORef FuntypeCompressedTextureImage3DEXT+glrefCompressedTextureImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureImage3DEXT #-}+glCompressedTextureImage3DEXT :: FuntypeCompressedTextureImage3DEXT+glCompressedTextureImage3DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage3DEXT+{-# INLINE glCompressedTextureImage3DEXT #-}+type FuntypeCompressedTextureImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureImage2DEXT :: FunPtr FuntypeCompressedTextureImage2DEXT -> FuntypeCompressedTextureImage2DEXT+glrefCompressedTextureImage2DEXT :: IORef FuntypeCompressedTextureImage2DEXT+glrefCompressedTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureImage2DEXT #-}+glCompressedTextureImage2DEXT :: FuntypeCompressedTextureImage2DEXT+glCompressedTextureImage2DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage2DEXT+{-# INLINE glCompressedTextureImage2DEXT #-}+type FuntypeCompressedTextureImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureImage1DEXT :: FunPtr FuntypeCompressedTextureImage1DEXT -> FuntypeCompressedTextureImage1DEXT+glrefCompressedTextureImage1DEXT :: IORef FuntypeCompressedTextureImage1DEXT+glrefCompressedTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureImage1DEXT #-}+glCompressedTextureImage1DEXT :: FuntypeCompressedTextureImage1DEXT+glCompressedTextureImage1DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage1DEXT+{-# INLINE glCompressedTextureImage1DEXT #-}+type FuntypeCompressedTextureSubImage3DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureSubImage3DEXT :: FunPtr FuntypeCompressedTextureSubImage3DEXT -> FuntypeCompressedTextureSubImage3DEXT+glrefCompressedTextureSubImage3DEXT :: IORef FuntypeCompressedTextureSubImage3DEXT+glrefCompressedTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureSubImage3DEXT #-}+glCompressedTextureSubImage3DEXT :: FuntypeCompressedTextureSubImage3DEXT+glCompressedTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage3DEXT+{-# INLINE glCompressedTextureSubImage3DEXT #-}+type FuntypeCompressedTextureSubImage2DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureSubImage2DEXT :: FunPtr FuntypeCompressedTextureSubImage2DEXT -> FuntypeCompressedTextureSubImage2DEXT+glrefCompressedTextureSubImage2DEXT :: IORef FuntypeCompressedTextureSubImage2DEXT+glrefCompressedTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureSubImage2DEXT #-}+glCompressedTextureSubImage2DEXT :: FuntypeCompressedTextureSubImage2DEXT+glCompressedTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage2DEXT+{-# INLINE glCompressedTextureSubImage2DEXT #-}+type FuntypeCompressedTextureSubImage1DEXT =+    GLuint ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedTextureSubImage1DEXT :: FunPtr FuntypeCompressedTextureSubImage1DEXT -> FuntypeCompressedTextureSubImage1DEXT+glrefCompressedTextureSubImage1DEXT :: IORef FuntypeCompressedTextureSubImage1DEXT+glrefCompressedTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedTextureSubImage1DEXT #-}+glCompressedTextureSubImage1DEXT :: FuntypeCompressedTextureSubImage1DEXT+glCompressedTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage1DEXT+{-# INLINE glCompressedTextureSubImage1DEXT #-}+type FuntypeGetCompressedTextureImageEXT =+    GLuint ->+    GLenum ->+    GLint ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetCompressedTextureImageEXT :: FunPtr FuntypeGetCompressedTextureImageEXT -> FuntypeGetCompressedTextureImageEXT+glrefGetCompressedTextureImageEXT :: IORef FuntypeGetCompressedTextureImageEXT+glrefGetCompressedTextureImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetCompressedTextureImageEXT #-}+glGetCompressedTextureImageEXT :: FuntypeGetCompressedTextureImageEXT+glGetCompressedTextureImageEXT = unsafePerformIO $ readIORef glrefGetCompressedTextureImageEXT+{-# INLINE glGetCompressedTextureImageEXT #-}+type FuntypeCompressedMultiTexImage3DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexImage3DEXT :: FunPtr FuntypeCompressedMultiTexImage3DEXT -> FuntypeCompressedMultiTexImage3DEXT+glrefCompressedMultiTexImage3DEXT :: IORef FuntypeCompressedMultiTexImage3DEXT+glrefCompressedMultiTexImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexImage3DEXT #-}+glCompressedMultiTexImage3DEXT :: FuntypeCompressedMultiTexImage3DEXT+glCompressedMultiTexImage3DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage3DEXT+{-# INLINE glCompressedMultiTexImage3DEXT #-}+type FuntypeCompressedMultiTexImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexImage2DEXT :: FunPtr FuntypeCompressedMultiTexImage2DEXT -> FuntypeCompressedMultiTexImage2DEXT+glrefCompressedMultiTexImage2DEXT :: IORef FuntypeCompressedMultiTexImage2DEXT+glrefCompressedMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexImage2DEXT #-}+glCompressedMultiTexImage2DEXT :: FuntypeCompressedMultiTexImage2DEXT+glCompressedMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage2DEXT+{-# INLINE glCompressedMultiTexImage2DEXT #-}+type FuntypeCompressedMultiTexImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLint ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexImage1DEXT :: FunPtr FuntypeCompressedMultiTexImage1DEXT -> FuntypeCompressedMultiTexImage1DEXT+glrefCompressedMultiTexImage1DEXT :: IORef FuntypeCompressedMultiTexImage1DEXT+glrefCompressedMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexImage1DEXT #-}+glCompressedMultiTexImage1DEXT :: FuntypeCompressedMultiTexImage1DEXT+glCompressedMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage1DEXT+{-# INLINE glCompressedMultiTexImage1DEXT #-}+type FuntypeCompressedMultiTexSubImage3DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexSubImage3DEXT :: FunPtr FuntypeCompressedMultiTexSubImage3DEXT -> FuntypeCompressedMultiTexSubImage3DEXT+glrefCompressedMultiTexSubImage3DEXT :: IORef FuntypeCompressedMultiTexSubImage3DEXT+glrefCompressedMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexSubImage3DEXT #-}+glCompressedMultiTexSubImage3DEXT :: FuntypeCompressedMultiTexSubImage3DEXT+glCompressedMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage3DEXT+{-# INLINE glCompressedMultiTexSubImage3DEXT #-}+type FuntypeCompressedMultiTexSubImage2DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexSubImage2DEXT :: FunPtr FuntypeCompressedMultiTexSubImage2DEXT -> FuntypeCompressedMultiTexSubImage2DEXT+glrefCompressedMultiTexSubImage2DEXT :: IORef FuntypeCompressedMultiTexSubImage2DEXT+glrefCompressedMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexSubImage2DEXT #-}+glCompressedMultiTexSubImage2DEXT :: FuntypeCompressedMultiTexSubImage2DEXT+glCompressedMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage2DEXT+{-# INLINE glCompressedMultiTexSubImage2DEXT #-}+type FuntypeCompressedMultiTexSubImage1DEXT =+    GLenum ->+    GLenum ->+    GLint ->+    GLint ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCompressedMultiTexSubImage1DEXT :: FunPtr FuntypeCompressedMultiTexSubImage1DEXT -> FuntypeCompressedMultiTexSubImage1DEXT+glrefCompressedMultiTexSubImage1DEXT :: IORef FuntypeCompressedMultiTexSubImage1DEXT+glrefCompressedMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCompressedMultiTexSubImage1DEXT #-}+glCompressedMultiTexSubImage1DEXT :: FuntypeCompressedMultiTexSubImage1DEXT+glCompressedMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage1DEXT+{-# INLINE glCompressedMultiTexSubImage1DEXT #-}+type FuntypeGetCompressedMultiTexImageEXT =+    GLenum ->+    GLenum ->+    GLint ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetCompressedMultiTexImageEXT :: FunPtr FuntypeGetCompressedMultiTexImageEXT -> FuntypeGetCompressedMultiTexImageEXT+glrefGetCompressedMultiTexImageEXT :: IORef FuntypeGetCompressedMultiTexImageEXT+glrefGetCompressedMultiTexImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetCompressedMultiTexImageEXT #-}+glGetCompressedMultiTexImageEXT :: FuntypeGetCompressedMultiTexImageEXT+glGetCompressedMultiTexImageEXT = unsafePerformIO $ readIORef glrefGetCompressedMultiTexImageEXT+{-# INLINE glGetCompressedMultiTexImageEXT #-}+type FuntypeMatrixLoadTransposefEXT =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixLoadTransposefEXT :: FunPtr FuntypeMatrixLoadTransposefEXT -> FuntypeMatrixLoadTransposefEXT+glrefMatrixLoadTransposefEXT :: IORef FuntypeMatrixLoadTransposefEXT+glrefMatrixLoadTransposefEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixLoadTransposefEXT #-}+glMatrixLoadTransposefEXT :: FuntypeMatrixLoadTransposefEXT+glMatrixLoadTransposefEXT = unsafePerformIO $ readIORef glrefMatrixLoadTransposefEXT+{-# INLINE glMatrixLoadTransposefEXT #-}+type FuntypeMatrixLoadTransposedEXT =+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixLoadTransposedEXT :: FunPtr FuntypeMatrixLoadTransposedEXT -> FuntypeMatrixLoadTransposedEXT+glrefMatrixLoadTransposedEXT :: IORef FuntypeMatrixLoadTransposedEXT+glrefMatrixLoadTransposedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixLoadTransposedEXT #-}+glMatrixLoadTransposedEXT :: FuntypeMatrixLoadTransposedEXT+glMatrixLoadTransposedEXT = unsafePerformIO $ readIORef glrefMatrixLoadTransposedEXT+{-# INLINE glMatrixLoadTransposedEXT #-}+type FuntypeMatrixMultTransposefEXT =+    GLenum ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixMultTransposefEXT :: FunPtr FuntypeMatrixMultTransposefEXT -> FuntypeMatrixMultTransposefEXT+glrefMatrixMultTransposefEXT :: IORef FuntypeMatrixMultTransposefEXT+glrefMatrixMultTransposefEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixMultTransposefEXT #-}+glMatrixMultTransposefEXT :: FuntypeMatrixMultTransposefEXT+glMatrixMultTransposefEXT = unsafePerformIO $ readIORef glrefMatrixMultTransposefEXT+{-# INLINE glMatrixMultTransposefEXT #-}+type FuntypeMatrixMultTransposedEXT =+    GLenum ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMatrixMultTransposedEXT :: FunPtr FuntypeMatrixMultTransposedEXT -> FuntypeMatrixMultTransposedEXT+glrefMatrixMultTransposedEXT :: IORef FuntypeMatrixMultTransposedEXT+glrefMatrixMultTransposedEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMatrixMultTransposedEXT #-}+glMatrixMultTransposedEXT :: FuntypeMatrixMultTransposedEXT+glMatrixMultTransposedEXT = unsafePerformIO $ readIORef glrefMatrixMultTransposedEXT+{-# INLINE glMatrixMultTransposedEXT #-}+type FuntypeNamedBufferDataEXT =+    GLuint ->+    GLsizeiptr ->+    Ptr () ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedBufferDataEXT :: FunPtr FuntypeNamedBufferDataEXT -> FuntypeNamedBufferDataEXT+glrefNamedBufferDataEXT :: IORef FuntypeNamedBufferDataEXT+glrefNamedBufferDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedBufferDataEXT #-}+glNamedBufferDataEXT :: FuntypeNamedBufferDataEXT+glNamedBufferDataEXT = unsafePerformIO $ readIORef glrefNamedBufferDataEXT+{-# INLINE glNamedBufferDataEXT #-}+type FuntypeNamedBufferSubDataEXT =+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedBufferSubDataEXT :: FunPtr FuntypeNamedBufferSubDataEXT -> FuntypeNamedBufferSubDataEXT+glrefNamedBufferSubDataEXT :: IORef FuntypeNamedBufferSubDataEXT+glrefNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedBufferSubDataEXT #-}+glNamedBufferSubDataEXT :: FuntypeNamedBufferSubDataEXT+glNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefNamedBufferSubDataEXT+{-# INLINE glNamedBufferSubDataEXT #-}+type FuntypeMapNamedBufferEXT =+    GLuint ->+    GLenum ->+    IO ( Ptr () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMapNamedBufferEXT :: FunPtr FuntypeMapNamedBufferEXT -> FuntypeMapNamedBufferEXT+glrefMapNamedBufferEXT :: IORef FuntypeMapNamedBufferEXT+glrefMapNamedBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMapNamedBufferEXT #-}+glMapNamedBufferEXT :: FuntypeMapNamedBufferEXT+glMapNamedBufferEXT = unsafePerformIO $ readIORef glrefMapNamedBufferEXT+{-# INLINE glMapNamedBufferEXT #-}+type FuntypeUnmapNamedBufferEXT =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUnmapNamedBufferEXT :: FunPtr FuntypeUnmapNamedBufferEXT -> FuntypeUnmapNamedBufferEXT+glrefUnmapNamedBufferEXT :: IORef FuntypeUnmapNamedBufferEXT+glrefUnmapNamedBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUnmapNamedBufferEXT #-}+glUnmapNamedBufferEXT :: FuntypeUnmapNamedBufferEXT+glUnmapNamedBufferEXT = unsafePerformIO $ readIORef glrefUnmapNamedBufferEXT+{-# INLINE glUnmapNamedBufferEXT #-}+type FuntypeGetNamedBufferParameterivEXT =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedBufferParameterivEXT :: FunPtr FuntypeGetNamedBufferParameterivEXT -> FuntypeGetNamedBufferParameterivEXT+glrefGetNamedBufferParameterivEXT :: IORef FuntypeGetNamedBufferParameterivEXT+glrefGetNamedBufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedBufferParameterivEXT #-}+glGetNamedBufferParameterivEXT :: FuntypeGetNamedBufferParameterivEXT+glGetNamedBufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedBufferParameterivEXT+{-# INLINE glGetNamedBufferParameterivEXT #-}+type FuntypeGetNamedBufferPointervEXT =+    GLuint ->+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedBufferPointervEXT :: FunPtr FuntypeGetNamedBufferPointervEXT -> FuntypeGetNamedBufferPointervEXT+glrefGetNamedBufferPointervEXT :: IORef FuntypeGetNamedBufferPointervEXT+glrefGetNamedBufferPointervEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedBufferPointervEXT #-}+glGetNamedBufferPointervEXT :: FuntypeGetNamedBufferPointervEXT+glGetNamedBufferPointervEXT = unsafePerformIO $ readIORef glrefGetNamedBufferPointervEXT+{-# INLINE glGetNamedBufferPointervEXT #-}+type FuntypeGetNamedBufferSubDataEXT =+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedBufferSubDataEXT :: FunPtr FuntypeGetNamedBufferSubDataEXT -> FuntypeGetNamedBufferSubDataEXT+glrefGetNamedBufferSubDataEXT :: IORef FuntypeGetNamedBufferSubDataEXT+glrefGetNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedBufferSubDataEXT #-}+glGetNamedBufferSubDataEXT :: FuntypeGetNamedBufferSubDataEXT+glGetNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefGetNamedBufferSubDataEXT+{-# INLINE glGetNamedBufferSubDataEXT #-}+type FuntypeProgramUniform1fEXT =+    GLuint ->+    GLint ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1fEXT :: FunPtr FuntypeProgramUniform1fEXT -> FuntypeProgramUniform1fEXT+glrefProgramUniform1fEXT :: IORef FuntypeProgramUniform1fEXT+glrefProgramUniform1fEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1fEXT #-}+glProgramUniform1fEXT :: FuntypeProgramUniform1fEXT+glProgramUniform1fEXT = unsafePerformIO $ readIORef glrefProgramUniform1fEXT+{-# INLINE glProgramUniform1fEXT #-}+type FuntypeProgramUniform2fEXT =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2fEXT :: FunPtr FuntypeProgramUniform2fEXT -> FuntypeProgramUniform2fEXT+glrefProgramUniform2fEXT :: IORef FuntypeProgramUniform2fEXT+glrefProgramUniform2fEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2fEXT #-}+glProgramUniform2fEXT :: FuntypeProgramUniform2fEXT+glProgramUniform2fEXT = unsafePerformIO $ readIORef glrefProgramUniform2fEXT+{-# INLINE glProgramUniform2fEXT #-}+type FuntypeProgramUniform3fEXT =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3fEXT :: FunPtr FuntypeProgramUniform3fEXT -> FuntypeProgramUniform3fEXT+glrefProgramUniform3fEXT :: IORef FuntypeProgramUniform3fEXT+glrefProgramUniform3fEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3fEXT #-}+glProgramUniform3fEXT :: FuntypeProgramUniform3fEXT+glProgramUniform3fEXT = unsafePerformIO $ readIORef glrefProgramUniform3fEXT+{-# INLINE glProgramUniform3fEXT #-}+type FuntypeProgramUniform4fEXT =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4fEXT :: FunPtr FuntypeProgramUniform4fEXT -> FuntypeProgramUniform4fEXT+glrefProgramUniform4fEXT :: IORef FuntypeProgramUniform4fEXT+glrefProgramUniform4fEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4fEXT #-}+glProgramUniform4fEXT :: FuntypeProgramUniform4fEXT+glProgramUniform4fEXT = unsafePerformIO $ readIORef glrefProgramUniform4fEXT+{-# INLINE glProgramUniform4fEXT #-}+type FuntypeProgramUniform1iEXT =+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1iEXT :: FunPtr FuntypeProgramUniform1iEXT -> FuntypeProgramUniform1iEXT+glrefProgramUniform1iEXT :: IORef FuntypeProgramUniform1iEXT+glrefProgramUniform1iEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1iEXT #-}+glProgramUniform1iEXT :: FuntypeProgramUniform1iEXT+glProgramUniform1iEXT = unsafePerformIO $ readIORef glrefProgramUniform1iEXT+{-# INLINE glProgramUniform1iEXT #-}+type FuntypeProgramUniform2iEXT =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2iEXT :: FunPtr FuntypeProgramUniform2iEXT -> FuntypeProgramUniform2iEXT+glrefProgramUniform2iEXT :: IORef FuntypeProgramUniform2iEXT+glrefProgramUniform2iEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2iEXT #-}+glProgramUniform2iEXT :: FuntypeProgramUniform2iEXT+glProgramUniform2iEXT = unsafePerformIO $ readIORef glrefProgramUniform2iEXT+{-# INLINE glProgramUniform2iEXT #-}+type FuntypeProgramUniform3iEXT =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3iEXT :: FunPtr FuntypeProgramUniform3iEXT -> FuntypeProgramUniform3iEXT+glrefProgramUniform3iEXT :: IORef FuntypeProgramUniform3iEXT+glrefProgramUniform3iEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3iEXT #-}+glProgramUniform3iEXT :: FuntypeProgramUniform3iEXT+glProgramUniform3iEXT = unsafePerformIO $ readIORef glrefProgramUniform3iEXT+{-# INLINE glProgramUniform3iEXT #-}+type FuntypeProgramUniform4iEXT =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4iEXT :: FunPtr FuntypeProgramUniform4iEXT -> FuntypeProgramUniform4iEXT+glrefProgramUniform4iEXT :: IORef FuntypeProgramUniform4iEXT+glrefProgramUniform4iEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4iEXT #-}+glProgramUniform4iEXT :: FuntypeProgramUniform4iEXT+glProgramUniform4iEXT = unsafePerformIO $ readIORef glrefProgramUniform4iEXT+{-# INLINE glProgramUniform4iEXT #-}+type FuntypeProgramUniform1fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1fvEXT :: FunPtr FuntypeProgramUniform1fvEXT -> FuntypeProgramUniform1fvEXT+glrefProgramUniform1fvEXT :: IORef FuntypeProgramUniform1fvEXT+glrefProgramUniform1fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1fvEXT #-}+glProgramUniform1fvEXT :: FuntypeProgramUniform1fvEXT+glProgramUniform1fvEXT = unsafePerformIO $ readIORef glrefProgramUniform1fvEXT+{-# INLINE glProgramUniform1fvEXT #-}+type FuntypeProgramUniform2fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2fvEXT :: FunPtr FuntypeProgramUniform2fvEXT -> FuntypeProgramUniform2fvEXT+glrefProgramUniform2fvEXT :: IORef FuntypeProgramUniform2fvEXT+glrefProgramUniform2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2fvEXT #-}+glProgramUniform2fvEXT :: FuntypeProgramUniform2fvEXT+glProgramUniform2fvEXT = unsafePerformIO $ readIORef glrefProgramUniform2fvEXT+{-# INLINE glProgramUniform2fvEXT #-}+type FuntypeProgramUniform3fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3fvEXT :: FunPtr FuntypeProgramUniform3fvEXT -> FuntypeProgramUniform3fvEXT+glrefProgramUniform3fvEXT :: IORef FuntypeProgramUniform3fvEXT+glrefProgramUniform3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3fvEXT #-}+glProgramUniform3fvEXT :: FuntypeProgramUniform3fvEXT+glProgramUniform3fvEXT = unsafePerformIO $ readIORef glrefProgramUniform3fvEXT+{-# INLINE glProgramUniform3fvEXT #-}+type FuntypeProgramUniform4fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4fvEXT :: FunPtr FuntypeProgramUniform4fvEXT -> FuntypeProgramUniform4fvEXT+glrefProgramUniform4fvEXT :: IORef FuntypeProgramUniform4fvEXT+glrefProgramUniform4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4fvEXT #-}+glProgramUniform4fvEXT :: FuntypeProgramUniform4fvEXT+glProgramUniform4fvEXT = unsafePerformIO $ readIORef glrefProgramUniform4fvEXT+{-# INLINE glProgramUniform4fvEXT #-}+type FuntypeProgramUniform1ivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1ivEXT :: FunPtr FuntypeProgramUniform1ivEXT -> FuntypeProgramUniform1ivEXT+glrefProgramUniform1ivEXT :: IORef FuntypeProgramUniform1ivEXT+glrefProgramUniform1ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1ivEXT #-}+glProgramUniform1ivEXT :: FuntypeProgramUniform1ivEXT+glProgramUniform1ivEXT = unsafePerformIO $ readIORef glrefProgramUniform1ivEXT+{-# INLINE glProgramUniform1ivEXT #-}+type FuntypeProgramUniform2ivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2ivEXT :: FunPtr FuntypeProgramUniform2ivEXT -> FuntypeProgramUniform2ivEXT+glrefProgramUniform2ivEXT :: IORef FuntypeProgramUniform2ivEXT+glrefProgramUniform2ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2ivEXT #-}+glProgramUniform2ivEXT :: FuntypeProgramUniform2ivEXT+glProgramUniform2ivEXT = unsafePerformIO $ readIORef glrefProgramUniform2ivEXT+{-# INLINE glProgramUniform2ivEXT #-}+type FuntypeProgramUniform3ivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3ivEXT :: FunPtr FuntypeProgramUniform3ivEXT -> FuntypeProgramUniform3ivEXT+glrefProgramUniform3ivEXT :: IORef FuntypeProgramUniform3ivEXT+glrefProgramUniform3ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3ivEXT #-}+glProgramUniform3ivEXT :: FuntypeProgramUniform3ivEXT+glProgramUniform3ivEXT = unsafePerformIO $ readIORef glrefProgramUniform3ivEXT+{-# INLINE glProgramUniform3ivEXT #-}+type FuntypeProgramUniform4ivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4ivEXT :: FunPtr FuntypeProgramUniform4ivEXT -> FuntypeProgramUniform4ivEXT+glrefProgramUniform4ivEXT :: IORef FuntypeProgramUniform4ivEXT+glrefProgramUniform4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4ivEXT #-}+glProgramUniform4ivEXT :: FuntypeProgramUniform4ivEXT+glProgramUniform4ivEXT = unsafePerformIO $ readIORef glrefProgramUniform4ivEXT+{-# INLINE glProgramUniform4ivEXT #-}+type FuntypeProgramUniformMatrix2fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2fvEXT :: FunPtr FuntypeProgramUniformMatrix2fvEXT -> FuntypeProgramUniformMatrix2fvEXT+glrefProgramUniformMatrix2fvEXT :: IORef FuntypeProgramUniformMatrix2fvEXT+glrefProgramUniformMatrix2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2fvEXT #-}+glProgramUniformMatrix2fvEXT :: FuntypeProgramUniformMatrix2fvEXT+glProgramUniformMatrix2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2fvEXT+{-# INLINE glProgramUniformMatrix2fvEXT #-}+type FuntypeProgramUniformMatrix3fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3fvEXT :: FunPtr FuntypeProgramUniformMatrix3fvEXT -> FuntypeProgramUniformMatrix3fvEXT+glrefProgramUniformMatrix3fvEXT :: IORef FuntypeProgramUniformMatrix3fvEXT+glrefProgramUniformMatrix3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3fvEXT #-}+glProgramUniformMatrix3fvEXT :: FuntypeProgramUniformMatrix3fvEXT+glProgramUniformMatrix3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3fvEXT+{-# INLINE glProgramUniformMatrix3fvEXT #-}+type FuntypeProgramUniformMatrix4fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4fvEXT :: FunPtr FuntypeProgramUniformMatrix4fvEXT -> FuntypeProgramUniformMatrix4fvEXT+glrefProgramUniformMatrix4fvEXT :: IORef FuntypeProgramUniformMatrix4fvEXT+glrefProgramUniformMatrix4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4fvEXT #-}+glProgramUniformMatrix4fvEXT :: FuntypeProgramUniformMatrix4fvEXT+glProgramUniformMatrix4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4fvEXT+{-# INLINE glProgramUniformMatrix4fvEXT #-}+type FuntypeProgramUniformMatrix2x3fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x3fvEXT :: FunPtr FuntypeProgramUniformMatrix2x3fvEXT -> FuntypeProgramUniformMatrix2x3fvEXT+glrefProgramUniformMatrix2x3fvEXT :: IORef FuntypeProgramUniformMatrix2x3fvEXT+glrefProgramUniformMatrix2x3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x3fvEXT #-}+glProgramUniformMatrix2x3fvEXT :: FuntypeProgramUniformMatrix2x3fvEXT+glProgramUniformMatrix2x3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3fvEXT+{-# INLINE glProgramUniformMatrix2x3fvEXT #-}+type FuntypeProgramUniformMatrix3x2fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x2fvEXT :: FunPtr FuntypeProgramUniformMatrix3x2fvEXT -> FuntypeProgramUniformMatrix3x2fvEXT+glrefProgramUniformMatrix3x2fvEXT :: IORef FuntypeProgramUniformMatrix3x2fvEXT+glrefProgramUniformMatrix3x2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x2fvEXT #-}+glProgramUniformMatrix3x2fvEXT :: FuntypeProgramUniformMatrix3x2fvEXT+glProgramUniformMatrix3x2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2fvEXT+{-# INLINE glProgramUniformMatrix3x2fvEXT #-}+type FuntypeProgramUniformMatrix2x4fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x4fvEXT :: FunPtr FuntypeProgramUniformMatrix2x4fvEXT -> FuntypeProgramUniformMatrix2x4fvEXT+glrefProgramUniformMatrix2x4fvEXT :: IORef FuntypeProgramUniformMatrix2x4fvEXT+glrefProgramUniformMatrix2x4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x4fvEXT #-}+glProgramUniformMatrix2x4fvEXT :: FuntypeProgramUniformMatrix2x4fvEXT+glProgramUniformMatrix2x4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4fvEXT+{-# INLINE glProgramUniformMatrix2x4fvEXT #-}+type FuntypeProgramUniformMatrix4x2fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x2fvEXT :: FunPtr FuntypeProgramUniformMatrix4x2fvEXT -> FuntypeProgramUniformMatrix4x2fvEXT+glrefProgramUniformMatrix4x2fvEXT :: IORef FuntypeProgramUniformMatrix4x2fvEXT+glrefProgramUniformMatrix4x2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x2fvEXT #-}+glProgramUniformMatrix4x2fvEXT :: FuntypeProgramUniformMatrix4x2fvEXT+glProgramUniformMatrix4x2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2fvEXT+{-# INLINE glProgramUniformMatrix4x2fvEXT #-}+type FuntypeProgramUniformMatrix3x4fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x4fvEXT :: FunPtr FuntypeProgramUniformMatrix3x4fvEXT -> FuntypeProgramUniformMatrix3x4fvEXT+glrefProgramUniformMatrix3x4fvEXT :: IORef FuntypeProgramUniformMatrix3x4fvEXT+glrefProgramUniformMatrix3x4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x4fvEXT #-}+glProgramUniformMatrix3x4fvEXT :: FuntypeProgramUniformMatrix3x4fvEXT+glProgramUniformMatrix3x4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4fvEXT+{-# INLINE glProgramUniformMatrix3x4fvEXT #-}+type FuntypeProgramUniformMatrix4x3fvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x3fvEXT :: FunPtr FuntypeProgramUniformMatrix4x3fvEXT -> FuntypeProgramUniformMatrix4x3fvEXT+glrefProgramUniformMatrix4x3fvEXT :: IORef FuntypeProgramUniformMatrix4x3fvEXT+glrefProgramUniformMatrix4x3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x3fvEXT #-}+glProgramUniformMatrix4x3fvEXT :: FuntypeProgramUniformMatrix4x3fvEXT+glProgramUniformMatrix4x3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3fvEXT+{-# INLINE glProgramUniformMatrix4x3fvEXT #-}+type FuntypeTextureBufferEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureBufferEXT :: FunPtr FuntypeTextureBufferEXT -> FuntypeTextureBufferEXT+glrefTextureBufferEXT :: IORef FuntypeTextureBufferEXT+glrefTextureBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureBufferEXT #-}+glTextureBufferEXT :: FuntypeTextureBufferEXT+glTextureBufferEXT = unsafePerformIO $ readIORef glrefTextureBufferEXT+{-# INLINE glTextureBufferEXT #-}+type FuntypeMultiTexBufferEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexBufferEXT :: FunPtr FuntypeMultiTexBufferEXT -> FuntypeMultiTexBufferEXT+glrefMultiTexBufferEXT :: IORef FuntypeMultiTexBufferEXT+glrefMultiTexBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexBufferEXT #-}+glMultiTexBufferEXT :: FuntypeMultiTexBufferEXT+glMultiTexBufferEXT = unsafePerformIO $ readIORef glrefMultiTexBufferEXT+{-# INLINE glMultiTexBufferEXT #-}+type FuntypeTextureParameterIivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameterIivEXT :: FunPtr FuntypeTextureParameterIivEXT -> FuntypeTextureParameterIivEXT+glrefTextureParameterIivEXT :: IORef FuntypeTextureParameterIivEXT+glrefTextureParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameterIivEXT #-}+glTextureParameterIivEXT :: FuntypeTextureParameterIivEXT+glTextureParameterIivEXT = unsafePerformIO $ readIORef glrefTextureParameterIivEXT+{-# INLINE glTextureParameterIivEXT #-}+type FuntypeTextureParameterIuivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureParameterIuivEXT :: FunPtr FuntypeTextureParameterIuivEXT -> FuntypeTextureParameterIuivEXT+glrefTextureParameterIuivEXT :: IORef FuntypeTextureParameterIuivEXT+glrefTextureParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureParameterIuivEXT #-}+glTextureParameterIuivEXT :: FuntypeTextureParameterIuivEXT+glTextureParameterIuivEXT = unsafePerformIO $ readIORef glrefTextureParameterIuivEXT+{-# INLINE glTextureParameterIuivEXT #-}+type FuntypeGetTextureParameterIivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureParameterIivEXT :: FunPtr FuntypeGetTextureParameterIivEXT -> FuntypeGetTextureParameterIivEXT+glrefGetTextureParameterIivEXT :: IORef FuntypeGetTextureParameterIivEXT+glrefGetTextureParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureParameterIivEXT #-}+glGetTextureParameterIivEXT :: FuntypeGetTextureParameterIivEXT+glGetTextureParameterIivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterIivEXT+{-# INLINE glGetTextureParameterIivEXT #-}+type FuntypeGetTextureParameterIuivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetTextureParameterIuivEXT :: FunPtr FuntypeGetTextureParameterIuivEXT -> FuntypeGetTextureParameterIuivEXT+glrefGetTextureParameterIuivEXT :: IORef FuntypeGetTextureParameterIuivEXT+glrefGetTextureParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetTextureParameterIuivEXT #-}+glGetTextureParameterIuivEXT :: FuntypeGetTextureParameterIuivEXT+glGetTextureParameterIuivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterIuivEXT+{-# INLINE glGetTextureParameterIuivEXT #-}+type FuntypeMultiTexParameterIivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameterIivEXT :: FunPtr FuntypeMultiTexParameterIivEXT -> FuntypeMultiTexParameterIivEXT+glrefMultiTexParameterIivEXT :: IORef FuntypeMultiTexParameterIivEXT+glrefMultiTexParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameterIivEXT #-}+glMultiTexParameterIivEXT :: FuntypeMultiTexParameterIivEXT+glMultiTexParameterIivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterIivEXT+{-# INLINE glMultiTexParameterIivEXT #-}+type FuntypeMultiTexParameterIuivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexParameterIuivEXT :: FunPtr FuntypeMultiTexParameterIuivEXT -> FuntypeMultiTexParameterIuivEXT+glrefMultiTexParameterIuivEXT :: IORef FuntypeMultiTexParameterIuivEXT+glrefMultiTexParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexParameterIuivEXT #-}+glMultiTexParameterIuivEXT :: FuntypeMultiTexParameterIuivEXT+glMultiTexParameterIuivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterIuivEXT+{-# INLINE glMultiTexParameterIuivEXT #-}+type FuntypeGetMultiTexParameterIivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexParameterIivEXT :: FunPtr FuntypeGetMultiTexParameterIivEXT -> FuntypeGetMultiTexParameterIivEXT+glrefGetMultiTexParameterIivEXT :: IORef FuntypeGetMultiTexParameterIivEXT+glrefGetMultiTexParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexParameterIivEXT #-}+glGetMultiTexParameterIivEXT :: FuntypeGetMultiTexParameterIivEXT+glGetMultiTexParameterIivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterIivEXT+{-# INLINE glGetMultiTexParameterIivEXT #-}+type FuntypeGetMultiTexParameterIuivEXT =+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetMultiTexParameterIuivEXT :: FunPtr FuntypeGetMultiTexParameterIuivEXT -> FuntypeGetMultiTexParameterIuivEXT+glrefGetMultiTexParameterIuivEXT :: IORef FuntypeGetMultiTexParameterIuivEXT+glrefGetMultiTexParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetMultiTexParameterIuivEXT #-}+glGetMultiTexParameterIuivEXT :: FuntypeGetMultiTexParameterIuivEXT+glGetMultiTexParameterIuivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterIuivEXT+{-# INLINE glGetMultiTexParameterIuivEXT #-}+type FuntypeProgramUniform1uiEXT =+    GLuint ->+    GLint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1uiEXT :: FunPtr FuntypeProgramUniform1uiEXT -> FuntypeProgramUniform1uiEXT+glrefProgramUniform1uiEXT :: IORef FuntypeProgramUniform1uiEXT+glrefProgramUniform1uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1uiEXT #-}+glProgramUniform1uiEXT :: FuntypeProgramUniform1uiEXT+glProgramUniform1uiEXT = unsafePerformIO $ readIORef glrefProgramUniform1uiEXT+{-# INLINE glProgramUniform1uiEXT #-}+type FuntypeProgramUniform2uiEXT =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2uiEXT :: FunPtr FuntypeProgramUniform2uiEXT -> FuntypeProgramUniform2uiEXT+glrefProgramUniform2uiEXT :: IORef FuntypeProgramUniform2uiEXT+glrefProgramUniform2uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2uiEXT #-}+glProgramUniform2uiEXT :: FuntypeProgramUniform2uiEXT+glProgramUniform2uiEXT = unsafePerformIO $ readIORef glrefProgramUniform2uiEXT+{-# INLINE glProgramUniform2uiEXT #-}+type FuntypeProgramUniform3uiEXT =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3uiEXT :: FunPtr FuntypeProgramUniform3uiEXT -> FuntypeProgramUniform3uiEXT+glrefProgramUniform3uiEXT :: IORef FuntypeProgramUniform3uiEXT+glrefProgramUniform3uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3uiEXT #-}+glProgramUniform3uiEXT :: FuntypeProgramUniform3uiEXT+glProgramUniform3uiEXT = unsafePerformIO $ readIORef glrefProgramUniform3uiEXT+{-# INLINE glProgramUniform3uiEXT #-}+type FuntypeProgramUniform4uiEXT =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4uiEXT :: FunPtr FuntypeProgramUniform4uiEXT -> FuntypeProgramUniform4uiEXT+glrefProgramUniform4uiEXT :: IORef FuntypeProgramUniform4uiEXT+glrefProgramUniform4uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4uiEXT #-}+glProgramUniform4uiEXT :: FuntypeProgramUniform4uiEXT+glProgramUniform4uiEXT = unsafePerformIO $ readIORef glrefProgramUniform4uiEXT+{-# INLINE glProgramUniform4uiEXT #-}+type FuntypeProgramUniform1uivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1uivEXT :: FunPtr FuntypeProgramUniform1uivEXT -> FuntypeProgramUniform1uivEXT+glrefProgramUniform1uivEXT :: IORef FuntypeProgramUniform1uivEXT+glrefProgramUniform1uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1uivEXT #-}+glProgramUniform1uivEXT :: FuntypeProgramUniform1uivEXT+glProgramUniform1uivEXT = unsafePerformIO $ readIORef glrefProgramUniform1uivEXT+{-# INLINE glProgramUniform1uivEXT #-}+type FuntypeProgramUniform2uivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2uivEXT :: FunPtr FuntypeProgramUniform2uivEXT -> FuntypeProgramUniform2uivEXT+glrefProgramUniform2uivEXT :: IORef FuntypeProgramUniform2uivEXT+glrefProgramUniform2uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2uivEXT #-}+glProgramUniform2uivEXT :: FuntypeProgramUniform2uivEXT+glProgramUniform2uivEXT = unsafePerformIO $ readIORef glrefProgramUniform2uivEXT+{-# INLINE glProgramUniform2uivEXT #-}+type FuntypeProgramUniform3uivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3uivEXT :: FunPtr FuntypeProgramUniform3uivEXT -> FuntypeProgramUniform3uivEXT+glrefProgramUniform3uivEXT :: IORef FuntypeProgramUniform3uivEXT+glrefProgramUniform3uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3uivEXT #-}+glProgramUniform3uivEXT :: FuntypeProgramUniform3uivEXT+glProgramUniform3uivEXT = unsafePerformIO $ readIORef glrefProgramUniform3uivEXT+{-# INLINE glProgramUniform3uivEXT #-}+type FuntypeProgramUniform4uivEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4uivEXT :: FunPtr FuntypeProgramUniform4uivEXT -> FuntypeProgramUniform4uivEXT+glrefProgramUniform4uivEXT :: IORef FuntypeProgramUniform4uivEXT+glrefProgramUniform4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4uivEXT #-}+glProgramUniform4uivEXT :: FuntypeProgramUniform4uivEXT+glProgramUniform4uivEXT = unsafePerformIO $ readIORef glrefProgramUniform4uivEXT+{-# INLINE glProgramUniform4uivEXT #-}+type FuntypeNamedProgramLocalParameters4fvEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameters4fvEXT :: FunPtr FuntypeNamedProgramLocalParameters4fvEXT -> FuntypeNamedProgramLocalParameters4fvEXT+glrefNamedProgramLocalParameters4fvEXT :: IORef FuntypeNamedProgramLocalParameters4fvEXT+glrefNamedProgramLocalParameters4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameters4fvEXT #-}+glNamedProgramLocalParameters4fvEXT :: FuntypeNamedProgramLocalParameters4fvEXT+glNamedProgramLocalParameters4fvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameters4fvEXT+{-# INLINE glNamedProgramLocalParameters4fvEXT #-}+type FuntypeNamedProgramLocalParameterI4iEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameterI4iEXT :: FunPtr FuntypeNamedProgramLocalParameterI4iEXT -> FuntypeNamedProgramLocalParameterI4iEXT+glrefNamedProgramLocalParameterI4iEXT :: IORef FuntypeNamedProgramLocalParameterI4iEXT+glrefNamedProgramLocalParameterI4iEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameterI4iEXT #-}+glNamedProgramLocalParameterI4iEXT :: FuntypeNamedProgramLocalParameterI4iEXT+glNamedProgramLocalParameterI4iEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4iEXT+{-# INLINE glNamedProgramLocalParameterI4iEXT #-}+type FuntypeNamedProgramLocalParameterI4ivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameterI4ivEXT :: FunPtr FuntypeNamedProgramLocalParameterI4ivEXT -> FuntypeNamedProgramLocalParameterI4ivEXT+glrefNamedProgramLocalParameterI4ivEXT :: IORef FuntypeNamedProgramLocalParameterI4ivEXT+glrefNamedProgramLocalParameterI4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameterI4ivEXT #-}+glNamedProgramLocalParameterI4ivEXT :: FuntypeNamedProgramLocalParameterI4ivEXT+glNamedProgramLocalParameterI4ivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4ivEXT+{-# INLINE glNamedProgramLocalParameterI4ivEXT #-}+type FuntypeNamedProgramLocalParametersI4ivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParametersI4ivEXT :: FunPtr FuntypeNamedProgramLocalParametersI4ivEXT -> FuntypeNamedProgramLocalParametersI4ivEXT+glrefNamedProgramLocalParametersI4ivEXT :: IORef FuntypeNamedProgramLocalParametersI4ivEXT+glrefNamedProgramLocalParametersI4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParametersI4ivEXT #-}+glNamedProgramLocalParametersI4ivEXT :: FuntypeNamedProgramLocalParametersI4ivEXT+glNamedProgramLocalParametersI4ivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParametersI4ivEXT+{-# INLINE glNamedProgramLocalParametersI4ivEXT #-}+type FuntypeNamedProgramLocalParameterI4uiEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameterI4uiEXT :: FunPtr FuntypeNamedProgramLocalParameterI4uiEXT -> FuntypeNamedProgramLocalParameterI4uiEXT+glrefNamedProgramLocalParameterI4uiEXT :: IORef FuntypeNamedProgramLocalParameterI4uiEXT+glrefNamedProgramLocalParameterI4uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameterI4uiEXT #-}+glNamedProgramLocalParameterI4uiEXT :: FuntypeNamedProgramLocalParameterI4uiEXT+glNamedProgramLocalParameterI4uiEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4uiEXT+{-# INLINE glNamedProgramLocalParameterI4uiEXT #-}+type FuntypeNamedProgramLocalParameterI4uivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameterI4uivEXT :: FunPtr FuntypeNamedProgramLocalParameterI4uivEXT -> FuntypeNamedProgramLocalParameterI4uivEXT+glrefNamedProgramLocalParameterI4uivEXT :: IORef FuntypeNamedProgramLocalParameterI4uivEXT+glrefNamedProgramLocalParameterI4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameterI4uivEXT #-}+glNamedProgramLocalParameterI4uivEXT :: FuntypeNamedProgramLocalParameterI4uivEXT+glNamedProgramLocalParameterI4uivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4uivEXT+{-# INLINE glNamedProgramLocalParameterI4uivEXT #-}+type FuntypeNamedProgramLocalParametersI4uivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParametersI4uivEXT :: FunPtr FuntypeNamedProgramLocalParametersI4uivEXT -> FuntypeNamedProgramLocalParametersI4uivEXT+glrefNamedProgramLocalParametersI4uivEXT :: IORef FuntypeNamedProgramLocalParametersI4uivEXT+glrefNamedProgramLocalParametersI4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParametersI4uivEXT #-}+glNamedProgramLocalParametersI4uivEXT :: FuntypeNamedProgramLocalParametersI4uivEXT+glNamedProgramLocalParametersI4uivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParametersI4uivEXT+{-# INLINE glNamedProgramLocalParametersI4uivEXT #-}+type FuntypeGetNamedProgramLocalParameterIivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramLocalParameterIivEXT :: FunPtr FuntypeGetNamedProgramLocalParameterIivEXT -> FuntypeGetNamedProgramLocalParameterIivEXT+glrefGetNamedProgramLocalParameterIivEXT :: IORef FuntypeGetNamedProgramLocalParameterIivEXT+glrefGetNamedProgramLocalParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramLocalParameterIivEXT #-}+glGetNamedProgramLocalParameterIivEXT :: FuntypeGetNamedProgramLocalParameterIivEXT+glGetNamedProgramLocalParameterIivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterIivEXT+{-# INLINE glGetNamedProgramLocalParameterIivEXT #-}+type FuntypeGetNamedProgramLocalParameterIuivEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramLocalParameterIuivEXT :: FunPtr FuntypeGetNamedProgramLocalParameterIuivEXT -> FuntypeGetNamedProgramLocalParameterIuivEXT+glrefGetNamedProgramLocalParameterIuivEXT :: IORef FuntypeGetNamedProgramLocalParameterIuivEXT+glrefGetNamedProgramLocalParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramLocalParameterIuivEXT #-}+glGetNamedProgramLocalParameterIuivEXT :: FuntypeGetNamedProgramLocalParameterIuivEXT+glGetNamedProgramLocalParameterIuivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterIuivEXT+{-# INLINE glGetNamedProgramLocalParameterIuivEXT #-}+type FuntypeEnableClientStateiEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableClientStateiEXT :: FunPtr FuntypeEnableClientStateiEXT -> FuntypeEnableClientStateiEXT+glrefEnableClientStateiEXT :: IORef FuntypeEnableClientStateiEXT+glrefEnableClientStateiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableClientStateiEXT #-}+glEnableClientStateiEXT :: FuntypeEnableClientStateiEXT+glEnableClientStateiEXT = unsafePerformIO $ readIORef glrefEnableClientStateiEXT+{-# INLINE glEnableClientStateiEXT #-}+type FuntypeDisableClientStateiEXT =+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableClientStateiEXT :: FunPtr FuntypeDisableClientStateiEXT -> FuntypeDisableClientStateiEXT+glrefDisableClientStateiEXT :: IORef FuntypeDisableClientStateiEXT+glrefDisableClientStateiEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableClientStateiEXT #-}+glDisableClientStateiEXT :: FuntypeDisableClientStateiEXT+glDisableClientStateiEXT = unsafePerformIO $ readIORef glrefDisableClientStateiEXT+{-# INLINE glDisableClientStateiEXT #-}+type FuntypeGetFloati_vEXT =+    GLenum ->+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFloati_vEXT :: FunPtr FuntypeGetFloati_vEXT -> FuntypeGetFloati_vEXT+glrefGetFloati_vEXT :: IORef FuntypeGetFloati_vEXT+glrefGetFloati_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFloati_vEXT #-}+glGetFloati_vEXT :: FuntypeGetFloati_vEXT+glGetFloati_vEXT = unsafePerformIO $ readIORef glrefGetFloati_vEXT+{-# INLINE glGetFloati_vEXT #-}+type FuntypeGetDoublei_vEXT =+    GLenum ->+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetDoublei_vEXT :: FunPtr FuntypeGetDoublei_vEXT -> FuntypeGetDoublei_vEXT+glrefGetDoublei_vEXT :: IORef FuntypeGetDoublei_vEXT+glrefGetDoublei_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetDoublei_vEXT #-}+glGetDoublei_vEXT :: FuntypeGetDoublei_vEXT+glGetDoublei_vEXT = unsafePerformIO $ readIORef glrefGetDoublei_vEXT+{-# INLINE glGetDoublei_vEXT #-}+type FuntypeGetPointeri_vEXT =+    GLenum ->+    GLuint ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetPointeri_vEXT :: FunPtr FuntypeGetPointeri_vEXT -> FuntypeGetPointeri_vEXT+glrefGetPointeri_vEXT :: IORef FuntypeGetPointeri_vEXT+glrefGetPointeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetPointeri_vEXT #-}+glGetPointeri_vEXT :: FuntypeGetPointeri_vEXT+glGetPointeri_vEXT = unsafePerformIO $ readIORef glrefGetPointeri_vEXT+{-# INLINE glGetPointeri_vEXT #-}+type FuntypeNamedProgramStringEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLsizei ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramStringEXT :: FunPtr FuntypeNamedProgramStringEXT -> FuntypeNamedProgramStringEXT+glrefNamedProgramStringEXT :: IORef FuntypeNamedProgramStringEXT+glrefNamedProgramStringEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramStringEXT #-}+glNamedProgramStringEXT :: FuntypeNamedProgramStringEXT+glNamedProgramStringEXT = unsafePerformIO $ readIORef glrefNamedProgramStringEXT+{-# INLINE glNamedProgramStringEXT #-}+type FuntypeNamedProgramLocalParameter4dEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameter4dEXT :: FunPtr FuntypeNamedProgramLocalParameter4dEXT -> FuntypeNamedProgramLocalParameter4dEXT+glrefNamedProgramLocalParameter4dEXT :: IORef FuntypeNamedProgramLocalParameter4dEXT+glrefNamedProgramLocalParameter4dEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameter4dEXT #-}+glNamedProgramLocalParameter4dEXT :: FuntypeNamedProgramLocalParameter4dEXT+glNamedProgramLocalParameter4dEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4dEXT+{-# INLINE glNamedProgramLocalParameter4dEXT #-}+type FuntypeNamedProgramLocalParameter4dvEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameter4dvEXT :: FunPtr FuntypeNamedProgramLocalParameter4dvEXT -> FuntypeNamedProgramLocalParameter4dvEXT+glrefNamedProgramLocalParameter4dvEXT :: IORef FuntypeNamedProgramLocalParameter4dvEXT+glrefNamedProgramLocalParameter4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameter4dvEXT #-}+glNamedProgramLocalParameter4dvEXT :: FuntypeNamedProgramLocalParameter4dvEXT+glNamedProgramLocalParameter4dvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4dvEXT+{-# INLINE glNamedProgramLocalParameter4dvEXT #-}+type FuntypeNamedProgramLocalParameter4fEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameter4fEXT :: FunPtr FuntypeNamedProgramLocalParameter4fEXT -> FuntypeNamedProgramLocalParameter4fEXT+glrefNamedProgramLocalParameter4fEXT :: IORef FuntypeNamedProgramLocalParameter4fEXT+glrefNamedProgramLocalParameter4fEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameter4fEXT #-}+glNamedProgramLocalParameter4fEXT :: FuntypeNamedProgramLocalParameter4fEXT+glNamedProgramLocalParameter4fEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4fEXT+{-# INLINE glNamedProgramLocalParameter4fEXT #-}+type FuntypeNamedProgramLocalParameter4fvEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedProgramLocalParameter4fvEXT :: FunPtr FuntypeNamedProgramLocalParameter4fvEXT -> FuntypeNamedProgramLocalParameter4fvEXT+glrefNamedProgramLocalParameter4fvEXT :: IORef FuntypeNamedProgramLocalParameter4fvEXT+glrefNamedProgramLocalParameter4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedProgramLocalParameter4fvEXT #-}+glNamedProgramLocalParameter4fvEXT :: FuntypeNamedProgramLocalParameter4fvEXT+glNamedProgramLocalParameter4fvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4fvEXT+{-# INLINE glNamedProgramLocalParameter4fvEXT #-}+type FuntypeGetNamedProgramLocalParameterdvEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramLocalParameterdvEXT :: FunPtr FuntypeGetNamedProgramLocalParameterdvEXT -> FuntypeGetNamedProgramLocalParameterdvEXT+glrefGetNamedProgramLocalParameterdvEXT :: IORef FuntypeGetNamedProgramLocalParameterdvEXT+glrefGetNamedProgramLocalParameterdvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramLocalParameterdvEXT #-}+glGetNamedProgramLocalParameterdvEXT :: FuntypeGetNamedProgramLocalParameterdvEXT+glGetNamedProgramLocalParameterdvEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterdvEXT+{-# INLINE glGetNamedProgramLocalParameterdvEXT #-}+type FuntypeGetNamedProgramLocalParameterfvEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramLocalParameterfvEXT :: FunPtr FuntypeGetNamedProgramLocalParameterfvEXT -> FuntypeGetNamedProgramLocalParameterfvEXT+glrefGetNamedProgramLocalParameterfvEXT :: IORef FuntypeGetNamedProgramLocalParameterfvEXT+glrefGetNamedProgramLocalParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramLocalParameterfvEXT #-}+glGetNamedProgramLocalParameterfvEXT :: FuntypeGetNamedProgramLocalParameterfvEXT+glGetNamedProgramLocalParameterfvEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterfvEXT+{-# INLINE glGetNamedProgramLocalParameterfvEXT #-}+type FuntypeGetNamedProgramivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramivEXT :: FunPtr FuntypeGetNamedProgramivEXT -> FuntypeGetNamedProgramivEXT+glrefGetNamedProgramivEXT :: IORef FuntypeGetNamedProgramivEXT+glrefGetNamedProgramivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramivEXT #-}+glGetNamedProgramivEXT :: FuntypeGetNamedProgramivEXT+glGetNamedProgramivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramivEXT+{-# INLINE glGetNamedProgramivEXT #-}+type FuntypeGetNamedProgramStringEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedProgramStringEXT :: FunPtr FuntypeGetNamedProgramStringEXT -> FuntypeGetNamedProgramStringEXT+glrefGetNamedProgramStringEXT :: IORef FuntypeGetNamedProgramStringEXT+glrefGetNamedProgramStringEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedProgramStringEXT #-}+glGetNamedProgramStringEXT :: FuntypeGetNamedProgramStringEXT+glGetNamedProgramStringEXT = unsafePerformIO $ readIORef glrefGetNamedProgramStringEXT+{-# INLINE glGetNamedProgramStringEXT #-}+type FuntypeNamedRenderbufferStorageEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedRenderbufferStorageEXT :: FunPtr FuntypeNamedRenderbufferStorageEXT -> FuntypeNamedRenderbufferStorageEXT+glrefNamedRenderbufferStorageEXT :: IORef FuntypeNamedRenderbufferStorageEXT+glrefNamedRenderbufferStorageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedRenderbufferStorageEXT #-}+glNamedRenderbufferStorageEXT :: FuntypeNamedRenderbufferStorageEXT+glNamedRenderbufferStorageEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageEXT+{-# INLINE glNamedRenderbufferStorageEXT #-}+type FuntypeGetNamedRenderbufferParameterivEXT =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedRenderbufferParameterivEXT :: FunPtr FuntypeGetNamedRenderbufferParameterivEXT -> FuntypeGetNamedRenderbufferParameterivEXT+glrefGetNamedRenderbufferParameterivEXT :: IORef FuntypeGetNamedRenderbufferParameterivEXT+glrefGetNamedRenderbufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedRenderbufferParameterivEXT #-}+glGetNamedRenderbufferParameterivEXT :: FuntypeGetNamedRenderbufferParameterivEXT+glGetNamedRenderbufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedRenderbufferParameterivEXT+{-# INLINE glGetNamedRenderbufferParameterivEXT #-}+type FuntypeNamedRenderbufferStorageMultisampleEXT =+    GLuint ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedRenderbufferStorageMultisampleEXT :: FunPtr FuntypeNamedRenderbufferStorageMultisampleEXT -> FuntypeNamedRenderbufferStorageMultisampleEXT+glrefNamedRenderbufferStorageMultisampleEXT :: IORef FuntypeNamedRenderbufferStorageMultisampleEXT+glrefNamedRenderbufferStorageMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedRenderbufferStorageMultisampleEXT #-}+glNamedRenderbufferStorageMultisampleEXT :: FuntypeNamedRenderbufferStorageMultisampleEXT+glNamedRenderbufferStorageMultisampleEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageMultisampleEXT+{-# INLINE glNamedRenderbufferStorageMultisampleEXT #-}+type FuntypeNamedRenderbufferStorageMultisampleCoverageEXT =+    GLuint ->+    GLsizei ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedRenderbufferStorageMultisampleCoverageEXT :: FunPtr FuntypeNamedRenderbufferStorageMultisampleCoverageEXT -> FuntypeNamedRenderbufferStorageMultisampleCoverageEXT+glrefNamedRenderbufferStorageMultisampleCoverageEXT :: IORef FuntypeNamedRenderbufferStorageMultisampleCoverageEXT+glrefNamedRenderbufferStorageMultisampleCoverageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedRenderbufferStorageMultisampleCoverageEXT #-}+glNamedRenderbufferStorageMultisampleCoverageEXT :: FuntypeNamedRenderbufferStorageMultisampleCoverageEXT+glNamedRenderbufferStorageMultisampleCoverageEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageMultisampleCoverageEXT+{-# INLINE glNamedRenderbufferStorageMultisampleCoverageEXT #-}+type FuntypeCheckNamedFramebufferStatusEXT =+    GLuint ->+    GLenum ->+    IO ( GLenum )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCheckNamedFramebufferStatusEXT :: FunPtr FuntypeCheckNamedFramebufferStatusEXT -> FuntypeCheckNamedFramebufferStatusEXT+glrefCheckNamedFramebufferStatusEXT :: IORef FuntypeCheckNamedFramebufferStatusEXT+glrefCheckNamedFramebufferStatusEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCheckNamedFramebufferStatusEXT #-}+glCheckNamedFramebufferStatusEXT :: FuntypeCheckNamedFramebufferStatusEXT+glCheckNamedFramebufferStatusEXT = unsafePerformIO $ readIORef glrefCheckNamedFramebufferStatusEXT+{-# INLINE glCheckNamedFramebufferStatusEXT #-}+type FuntypeNamedFramebufferTexture1DEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTexture1DEXT :: FunPtr FuntypeNamedFramebufferTexture1DEXT -> FuntypeNamedFramebufferTexture1DEXT+glrefNamedFramebufferTexture1DEXT :: IORef FuntypeNamedFramebufferTexture1DEXT+glrefNamedFramebufferTexture1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTexture1DEXT #-}+glNamedFramebufferTexture1DEXT :: FuntypeNamedFramebufferTexture1DEXT+glNamedFramebufferTexture1DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture1DEXT+{-# INLINE glNamedFramebufferTexture1DEXT #-}+type FuntypeNamedFramebufferTexture2DEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTexture2DEXT :: FunPtr FuntypeNamedFramebufferTexture2DEXT -> FuntypeNamedFramebufferTexture2DEXT+glrefNamedFramebufferTexture2DEXT :: IORef FuntypeNamedFramebufferTexture2DEXT+glrefNamedFramebufferTexture2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTexture2DEXT #-}+glNamedFramebufferTexture2DEXT :: FuntypeNamedFramebufferTexture2DEXT+glNamedFramebufferTexture2DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture2DEXT+{-# INLINE glNamedFramebufferTexture2DEXT #-}+type FuntypeNamedFramebufferTexture3DEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTexture3DEXT :: FunPtr FuntypeNamedFramebufferTexture3DEXT -> FuntypeNamedFramebufferTexture3DEXT+glrefNamedFramebufferTexture3DEXT :: IORef FuntypeNamedFramebufferTexture3DEXT+glrefNamedFramebufferTexture3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTexture3DEXT #-}+glNamedFramebufferTexture3DEXT :: FuntypeNamedFramebufferTexture3DEXT+glNamedFramebufferTexture3DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture3DEXT+{-# INLINE glNamedFramebufferTexture3DEXT #-}+type FuntypeNamedFramebufferRenderbufferEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferRenderbufferEXT :: FunPtr FuntypeNamedFramebufferRenderbufferEXT -> FuntypeNamedFramebufferRenderbufferEXT+glrefNamedFramebufferRenderbufferEXT :: IORef FuntypeNamedFramebufferRenderbufferEXT+glrefNamedFramebufferRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferRenderbufferEXT #-}+glNamedFramebufferRenderbufferEXT :: FuntypeNamedFramebufferRenderbufferEXT+glNamedFramebufferRenderbufferEXT = unsafePerformIO $ readIORef glrefNamedFramebufferRenderbufferEXT+{-# INLINE glNamedFramebufferRenderbufferEXT #-}+type FuntypeGetNamedFramebufferAttachmentParameterivEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedFramebufferAttachmentParameterivEXT :: FunPtr FuntypeGetNamedFramebufferAttachmentParameterivEXT -> FuntypeGetNamedFramebufferAttachmentParameterivEXT+glrefGetNamedFramebufferAttachmentParameterivEXT :: IORef FuntypeGetNamedFramebufferAttachmentParameterivEXT+glrefGetNamedFramebufferAttachmentParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedFramebufferAttachmentParameterivEXT #-}+glGetNamedFramebufferAttachmentParameterivEXT :: FuntypeGetNamedFramebufferAttachmentParameterivEXT+glGetNamedFramebufferAttachmentParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedFramebufferAttachmentParameterivEXT+{-# INLINE glGetNamedFramebufferAttachmentParameterivEXT #-}+type FuntypeGenerateTextureMipmapEXT =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenerateTextureMipmapEXT :: FunPtr FuntypeGenerateTextureMipmapEXT -> FuntypeGenerateTextureMipmapEXT+glrefGenerateTextureMipmapEXT :: IORef FuntypeGenerateTextureMipmapEXT+glrefGenerateTextureMipmapEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenerateTextureMipmapEXT #-}+glGenerateTextureMipmapEXT :: FuntypeGenerateTextureMipmapEXT+glGenerateTextureMipmapEXT = unsafePerformIO $ readIORef glrefGenerateTextureMipmapEXT+{-# INLINE glGenerateTextureMipmapEXT #-}+type FuntypeGenerateMultiTexMipmapEXT =+    GLenum ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenerateMultiTexMipmapEXT :: FunPtr FuntypeGenerateMultiTexMipmapEXT -> FuntypeGenerateMultiTexMipmapEXT+glrefGenerateMultiTexMipmapEXT :: IORef FuntypeGenerateMultiTexMipmapEXT+glrefGenerateMultiTexMipmapEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenerateMultiTexMipmapEXT #-}+glGenerateMultiTexMipmapEXT :: FuntypeGenerateMultiTexMipmapEXT+glGenerateMultiTexMipmapEXT = unsafePerformIO $ readIORef glrefGenerateMultiTexMipmapEXT+{-# INLINE glGenerateMultiTexMipmapEXT #-}+type FuntypeFramebufferDrawBufferEXT =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferDrawBufferEXT :: FunPtr FuntypeFramebufferDrawBufferEXT -> FuntypeFramebufferDrawBufferEXT+glrefFramebufferDrawBufferEXT :: IORef FuntypeFramebufferDrawBufferEXT+glrefFramebufferDrawBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferDrawBufferEXT #-}+glFramebufferDrawBufferEXT :: FuntypeFramebufferDrawBufferEXT+glFramebufferDrawBufferEXT = unsafePerformIO $ readIORef glrefFramebufferDrawBufferEXT+{-# INLINE glFramebufferDrawBufferEXT #-}+type FuntypeFramebufferDrawBuffersEXT =+    GLuint ->+    GLsizei ->+    Ptr (GLenum) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferDrawBuffersEXT :: FunPtr FuntypeFramebufferDrawBuffersEXT -> FuntypeFramebufferDrawBuffersEXT+glrefFramebufferDrawBuffersEXT :: IORef FuntypeFramebufferDrawBuffersEXT+glrefFramebufferDrawBuffersEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferDrawBuffersEXT #-}+glFramebufferDrawBuffersEXT :: FuntypeFramebufferDrawBuffersEXT+glFramebufferDrawBuffersEXT = unsafePerformIO $ readIORef glrefFramebufferDrawBuffersEXT+{-# INLINE glFramebufferDrawBuffersEXT #-}+type FuntypeFramebufferReadBufferEXT =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFramebufferReadBufferEXT :: FunPtr FuntypeFramebufferReadBufferEXT -> FuntypeFramebufferReadBufferEXT+glrefFramebufferReadBufferEXT :: IORef FuntypeFramebufferReadBufferEXT+glrefFramebufferReadBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFramebufferReadBufferEXT #-}+glFramebufferReadBufferEXT :: FuntypeFramebufferReadBufferEXT+glFramebufferReadBufferEXT = unsafePerformIO $ readIORef glrefFramebufferReadBufferEXT+{-# INLINE glFramebufferReadBufferEXT #-}+type FuntypeGetFramebufferParameterivEXT =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetFramebufferParameterivEXT :: FunPtr FuntypeGetFramebufferParameterivEXT -> FuntypeGetFramebufferParameterivEXT+glrefGetFramebufferParameterivEXT :: IORef FuntypeGetFramebufferParameterivEXT+glrefGetFramebufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetFramebufferParameterivEXT #-}+glGetFramebufferParameterivEXT :: FuntypeGetFramebufferParameterivEXT+glGetFramebufferParameterivEXT = unsafePerformIO $ readIORef glrefGetFramebufferParameterivEXT+{-# INLINE glGetFramebufferParameterivEXT #-}+type FuntypeNamedCopyBufferSubDataEXT =+    GLuint ->+    GLuint ->+    GLintptr ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedCopyBufferSubDataEXT :: FunPtr FuntypeNamedCopyBufferSubDataEXT -> FuntypeNamedCopyBufferSubDataEXT+glrefNamedCopyBufferSubDataEXT :: IORef FuntypeNamedCopyBufferSubDataEXT+glrefNamedCopyBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedCopyBufferSubDataEXT #-}+glNamedCopyBufferSubDataEXT :: FuntypeNamedCopyBufferSubDataEXT+glNamedCopyBufferSubDataEXT = unsafePerformIO $ readIORef glrefNamedCopyBufferSubDataEXT+{-# INLINE glNamedCopyBufferSubDataEXT #-}+type FuntypeNamedFramebufferTextureEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTextureEXT :: FunPtr FuntypeNamedFramebufferTextureEXT -> FuntypeNamedFramebufferTextureEXT+glrefNamedFramebufferTextureEXT :: IORef FuntypeNamedFramebufferTextureEXT+glrefNamedFramebufferTextureEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTextureEXT #-}+glNamedFramebufferTextureEXT :: FuntypeNamedFramebufferTextureEXT+glNamedFramebufferTextureEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureEXT+{-# INLINE glNamedFramebufferTextureEXT #-}+type FuntypeNamedFramebufferTextureLayerEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTextureLayerEXT :: FunPtr FuntypeNamedFramebufferTextureLayerEXT -> FuntypeNamedFramebufferTextureLayerEXT+glrefNamedFramebufferTextureLayerEXT :: IORef FuntypeNamedFramebufferTextureLayerEXT+glrefNamedFramebufferTextureLayerEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTextureLayerEXT #-}+glNamedFramebufferTextureLayerEXT :: FuntypeNamedFramebufferTextureLayerEXT+glNamedFramebufferTextureLayerEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureLayerEXT+{-# INLINE glNamedFramebufferTextureLayerEXT #-}+type FuntypeNamedFramebufferTextureFaceEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    GLint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferTextureFaceEXT :: FunPtr FuntypeNamedFramebufferTextureFaceEXT -> FuntypeNamedFramebufferTextureFaceEXT+glrefNamedFramebufferTextureFaceEXT :: IORef FuntypeNamedFramebufferTextureFaceEXT+glrefNamedFramebufferTextureFaceEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferTextureFaceEXT #-}+glNamedFramebufferTextureFaceEXT :: FuntypeNamedFramebufferTextureFaceEXT+glNamedFramebufferTextureFaceEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureFaceEXT+{-# INLINE glNamedFramebufferTextureFaceEXT #-}+type FuntypeTextureRenderbufferEXT =+    GLuint ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureRenderbufferEXT :: FunPtr FuntypeTextureRenderbufferEXT -> FuntypeTextureRenderbufferEXT+glrefTextureRenderbufferEXT :: IORef FuntypeTextureRenderbufferEXT+glrefTextureRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureRenderbufferEXT #-}+glTextureRenderbufferEXT :: FuntypeTextureRenderbufferEXT+glTextureRenderbufferEXT = unsafePerformIO $ readIORef glrefTextureRenderbufferEXT+{-# INLINE glTextureRenderbufferEXT #-}+type FuntypeMultiTexRenderbufferEXT =+    GLenum ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMultiTexRenderbufferEXT :: FunPtr FuntypeMultiTexRenderbufferEXT -> FuntypeMultiTexRenderbufferEXT+glrefMultiTexRenderbufferEXT :: IORef FuntypeMultiTexRenderbufferEXT+glrefMultiTexRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMultiTexRenderbufferEXT #-}+glMultiTexRenderbufferEXT :: FuntypeMultiTexRenderbufferEXT+glMultiTexRenderbufferEXT = unsafePerformIO $ readIORef glrefMultiTexRenderbufferEXT+{-# INLINE glMultiTexRenderbufferEXT #-}+type FuntypeVertexArrayVertexOffsetEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexOffsetEXT :: FunPtr FuntypeVertexArrayVertexOffsetEXT -> FuntypeVertexArrayVertexOffsetEXT+glrefVertexArrayVertexOffsetEXT :: IORef FuntypeVertexArrayVertexOffsetEXT+glrefVertexArrayVertexOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexOffsetEXT #-}+glVertexArrayVertexOffsetEXT :: FuntypeVertexArrayVertexOffsetEXT+glVertexArrayVertexOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexOffsetEXT+{-# INLINE glVertexArrayVertexOffsetEXT #-}+type FuntypeVertexArrayColorOffsetEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayColorOffsetEXT :: FunPtr FuntypeVertexArrayColorOffsetEXT -> FuntypeVertexArrayColorOffsetEXT+glrefVertexArrayColorOffsetEXT :: IORef FuntypeVertexArrayColorOffsetEXT+glrefVertexArrayColorOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayColorOffsetEXT #-}+glVertexArrayColorOffsetEXT :: FuntypeVertexArrayColorOffsetEXT+glVertexArrayColorOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayColorOffsetEXT+{-# INLINE glVertexArrayColorOffsetEXT #-}+type FuntypeVertexArrayEdgeFlagOffsetEXT =+    GLuint ->+    GLuint ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayEdgeFlagOffsetEXT :: FunPtr FuntypeVertexArrayEdgeFlagOffsetEXT -> FuntypeVertexArrayEdgeFlagOffsetEXT+glrefVertexArrayEdgeFlagOffsetEXT :: IORef FuntypeVertexArrayEdgeFlagOffsetEXT+glrefVertexArrayEdgeFlagOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayEdgeFlagOffsetEXT #-}+glVertexArrayEdgeFlagOffsetEXT :: FuntypeVertexArrayEdgeFlagOffsetEXT+glVertexArrayEdgeFlagOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayEdgeFlagOffsetEXT+{-# INLINE glVertexArrayEdgeFlagOffsetEXT #-}+type FuntypeVertexArrayIndexOffsetEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayIndexOffsetEXT :: FunPtr FuntypeVertexArrayIndexOffsetEXT -> FuntypeVertexArrayIndexOffsetEXT+glrefVertexArrayIndexOffsetEXT :: IORef FuntypeVertexArrayIndexOffsetEXT+glrefVertexArrayIndexOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayIndexOffsetEXT #-}+glVertexArrayIndexOffsetEXT :: FuntypeVertexArrayIndexOffsetEXT+glVertexArrayIndexOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayIndexOffsetEXT+{-# INLINE glVertexArrayIndexOffsetEXT #-}+type FuntypeVertexArrayNormalOffsetEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayNormalOffsetEXT :: FunPtr FuntypeVertexArrayNormalOffsetEXT -> FuntypeVertexArrayNormalOffsetEXT+glrefVertexArrayNormalOffsetEXT :: IORef FuntypeVertexArrayNormalOffsetEXT+glrefVertexArrayNormalOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayNormalOffsetEXT #-}+glVertexArrayNormalOffsetEXT :: FuntypeVertexArrayNormalOffsetEXT+glVertexArrayNormalOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayNormalOffsetEXT+{-# INLINE glVertexArrayNormalOffsetEXT #-}+type FuntypeVertexArrayTexCoordOffsetEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayTexCoordOffsetEXT :: FunPtr FuntypeVertexArrayTexCoordOffsetEXT -> FuntypeVertexArrayTexCoordOffsetEXT+glrefVertexArrayTexCoordOffsetEXT :: IORef FuntypeVertexArrayTexCoordOffsetEXT+glrefVertexArrayTexCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayTexCoordOffsetEXT #-}+glVertexArrayTexCoordOffsetEXT :: FuntypeVertexArrayTexCoordOffsetEXT+glVertexArrayTexCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayTexCoordOffsetEXT+{-# INLINE glVertexArrayTexCoordOffsetEXT #-}+type FuntypeVertexArrayMultiTexCoordOffsetEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayMultiTexCoordOffsetEXT :: FunPtr FuntypeVertexArrayMultiTexCoordOffsetEXT -> FuntypeVertexArrayMultiTexCoordOffsetEXT+glrefVertexArrayMultiTexCoordOffsetEXT :: IORef FuntypeVertexArrayMultiTexCoordOffsetEXT+glrefVertexArrayMultiTexCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayMultiTexCoordOffsetEXT #-}+glVertexArrayMultiTexCoordOffsetEXT :: FuntypeVertexArrayMultiTexCoordOffsetEXT+glVertexArrayMultiTexCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayMultiTexCoordOffsetEXT+{-# INLINE glVertexArrayMultiTexCoordOffsetEXT #-}+type FuntypeVertexArrayFogCoordOffsetEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayFogCoordOffsetEXT :: FunPtr FuntypeVertexArrayFogCoordOffsetEXT -> FuntypeVertexArrayFogCoordOffsetEXT+glrefVertexArrayFogCoordOffsetEXT :: IORef FuntypeVertexArrayFogCoordOffsetEXT+glrefVertexArrayFogCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayFogCoordOffsetEXT #-}+glVertexArrayFogCoordOffsetEXT :: FuntypeVertexArrayFogCoordOffsetEXT+glVertexArrayFogCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayFogCoordOffsetEXT+{-# INLINE glVertexArrayFogCoordOffsetEXT #-}+type FuntypeVertexArraySecondaryColorOffsetEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArraySecondaryColorOffsetEXT :: FunPtr FuntypeVertexArraySecondaryColorOffsetEXT -> FuntypeVertexArraySecondaryColorOffsetEXT+glrefVertexArraySecondaryColorOffsetEXT :: IORef FuntypeVertexArraySecondaryColorOffsetEXT+glrefVertexArraySecondaryColorOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArraySecondaryColorOffsetEXT #-}+glVertexArraySecondaryColorOffsetEXT :: FuntypeVertexArraySecondaryColorOffsetEXT+glVertexArraySecondaryColorOffsetEXT = unsafePerformIO $ readIORef glrefVertexArraySecondaryColorOffsetEXT+{-# INLINE glVertexArraySecondaryColorOffsetEXT #-}+type FuntypeVertexArrayVertexAttribOffsetEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLboolean ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribOffsetEXT -> FuntypeVertexArrayVertexAttribOffsetEXT+glrefVertexArrayVertexAttribOffsetEXT :: IORef FuntypeVertexArrayVertexAttribOffsetEXT+glrefVertexArrayVertexAttribOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribOffsetEXT #-}+glVertexArrayVertexAttribOffsetEXT :: FuntypeVertexArrayVertexAttribOffsetEXT+glVertexArrayVertexAttribOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribOffsetEXT+{-# INLINE glVertexArrayVertexAttribOffsetEXT #-}+type FuntypeVertexArrayVertexAttribIOffsetEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribIOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribIOffsetEXT -> FuntypeVertexArrayVertexAttribIOffsetEXT+glrefVertexArrayVertexAttribIOffsetEXT :: IORef FuntypeVertexArrayVertexAttribIOffsetEXT+glrefVertexArrayVertexAttribIOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribIOffsetEXT #-}+glVertexArrayVertexAttribIOffsetEXT :: FuntypeVertexArrayVertexAttribIOffsetEXT+glVertexArrayVertexAttribIOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribIOffsetEXT+{-# INLINE glVertexArrayVertexAttribIOffsetEXT #-}+type FuntypeEnableVertexArrayEXT =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableVertexArrayEXT :: FunPtr FuntypeEnableVertexArrayEXT -> FuntypeEnableVertexArrayEXT+glrefEnableVertexArrayEXT :: IORef FuntypeEnableVertexArrayEXT+glrefEnableVertexArrayEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableVertexArrayEXT #-}+glEnableVertexArrayEXT :: FuntypeEnableVertexArrayEXT+glEnableVertexArrayEXT = unsafePerformIO $ readIORef glrefEnableVertexArrayEXT+{-# INLINE glEnableVertexArrayEXT #-}+type FuntypeDisableVertexArrayEXT =+    GLuint ->+    GLenum ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableVertexArrayEXT :: FunPtr FuntypeDisableVertexArrayEXT -> FuntypeDisableVertexArrayEXT+glrefDisableVertexArrayEXT :: IORef FuntypeDisableVertexArrayEXT+glrefDisableVertexArrayEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableVertexArrayEXT #-}+glDisableVertexArrayEXT :: FuntypeDisableVertexArrayEXT+glDisableVertexArrayEXT = unsafePerformIO $ readIORef glrefDisableVertexArrayEXT+{-# INLINE glDisableVertexArrayEXT #-}+type FuntypeEnableVertexArrayAttribEXT =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynEnableVertexArrayAttribEXT :: FunPtr FuntypeEnableVertexArrayAttribEXT -> FuntypeEnableVertexArrayAttribEXT+glrefEnableVertexArrayAttribEXT :: IORef FuntypeEnableVertexArrayAttribEXT+glrefEnableVertexArrayAttribEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefEnableVertexArrayAttribEXT #-}+glEnableVertexArrayAttribEXT :: FuntypeEnableVertexArrayAttribEXT+glEnableVertexArrayAttribEXT = unsafePerformIO $ readIORef glrefEnableVertexArrayAttribEXT+{-# INLINE glEnableVertexArrayAttribEXT #-}+type FuntypeDisableVertexArrayAttribEXT =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDisableVertexArrayAttribEXT :: FunPtr FuntypeDisableVertexArrayAttribEXT -> FuntypeDisableVertexArrayAttribEXT+glrefDisableVertexArrayAttribEXT :: IORef FuntypeDisableVertexArrayAttribEXT+glrefDisableVertexArrayAttribEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDisableVertexArrayAttribEXT #-}+glDisableVertexArrayAttribEXT :: FuntypeDisableVertexArrayAttribEXT+glDisableVertexArrayAttribEXT = unsafePerformIO $ readIORef glrefDisableVertexArrayAttribEXT+{-# INLINE glDisableVertexArrayAttribEXT #-}+type FuntypeGetVertexArrayIntegervEXT =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexArrayIntegervEXT :: FunPtr FuntypeGetVertexArrayIntegervEXT -> FuntypeGetVertexArrayIntegervEXT+glrefGetVertexArrayIntegervEXT :: IORef FuntypeGetVertexArrayIntegervEXT+glrefGetVertexArrayIntegervEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexArrayIntegervEXT #-}+glGetVertexArrayIntegervEXT :: FuntypeGetVertexArrayIntegervEXT+glGetVertexArrayIntegervEXT = unsafePerformIO $ readIORef glrefGetVertexArrayIntegervEXT+{-# INLINE glGetVertexArrayIntegervEXT #-}+type FuntypeGetVertexArrayPointervEXT =+    GLuint ->+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexArrayPointervEXT :: FunPtr FuntypeGetVertexArrayPointervEXT -> FuntypeGetVertexArrayPointervEXT+glrefGetVertexArrayPointervEXT :: IORef FuntypeGetVertexArrayPointervEXT+glrefGetVertexArrayPointervEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexArrayPointervEXT #-}+glGetVertexArrayPointervEXT :: FuntypeGetVertexArrayPointervEXT+glGetVertexArrayPointervEXT = unsafePerformIO $ readIORef glrefGetVertexArrayPointervEXT+{-# INLINE glGetVertexArrayPointervEXT #-}+type FuntypeGetVertexArrayIntegeri_vEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexArrayIntegeri_vEXT :: FunPtr FuntypeGetVertexArrayIntegeri_vEXT -> FuntypeGetVertexArrayIntegeri_vEXT+glrefGetVertexArrayIntegeri_vEXT :: IORef FuntypeGetVertexArrayIntegeri_vEXT+glrefGetVertexArrayIntegeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexArrayIntegeri_vEXT #-}+glGetVertexArrayIntegeri_vEXT :: FuntypeGetVertexArrayIntegeri_vEXT+glGetVertexArrayIntegeri_vEXT = unsafePerformIO $ readIORef glrefGetVertexArrayIntegeri_vEXT+{-# INLINE glGetVertexArrayIntegeri_vEXT #-}+type FuntypeGetVertexArrayPointeri_vEXT =+    GLuint ->+    GLuint ->+    GLenum ->+    Ptr (Ptr ()) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetVertexArrayPointeri_vEXT :: FunPtr FuntypeGetVertexArrayPointeri_vEXT -> FuntypeGetVertexArrayPointeri_vEXT+glrefGetVertexArrayPointeri_vEXT :: IORef FuntypeGetVertexArrayPointeri_vEXT+glrefGetVertexArrayPointeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetVertexArrayPointeri_vEXT #-}+glGetVertexArrayPointeri_vEXT :: FuntypeGetVertexArrayPointeri_vEXT+glGetVertexArrayPointeri_vEXT = unsafePerformIO $ readIORef glrefGetVertexArrayPointeri_vEXT+{-# INLINE glGetVertexArrayPointeri_vEXT #-}+type FuntypeMapNamedBufferRangeEXT =+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    GLbitfield ->+    IO ( Ptr () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynMapNamedBufferRangeEXT :: FunPtr FuntypeMapNamedBufferRangeEXT -> FuntypeMapNamedBufferRangeEXT+glrefMapNamedBufferRangeEXT :: IORef FuntypeMapNamedBufferRangeEXT+glrefMapNamedBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefMapNamedBufferRangeEXT #-}+glMapNamedBufferRangeEXT :: FuntypeMapNamedBufferRangeEXT+glMapNamedBufferRangeEXT = unsafePerformIO $ readIORef glrefMapNamedBufferRangeEXT+{-# INLINE glMapNamedBufferRangeEXT #-}+type FuntypeFlushMappedNamedBufferRangeEXT =+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynFlushMappedNamedBufferRangeEXT :: FunPtr FuntypeFlushMappedNamedBufferRangeEXT -> FuntypeFlushMappedNamedBufferRangeEXT+glrefFlushMappedNamedBufferRangeEXT :: IORef FuntypeFlushMappedNamedBufferRangeEXT+glrefFlushMappedNamedBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefFlushMappedNamedBufferRangeEXT #-}+glFlushMappedNamedBufferRangeEXT :: FuntypeFlushMappedNamedBufferRangeEXT+glFlushMappedNamedBufferRangeEXT = unsafePerformIO $ readIORef glrefFlushMappedNamedBufferRangeEXT+{-# INLINE glFlushMappedNamedBufferRangeEXT #-}+type FuntypeNamedBufferStorageEXT =+    GLuint ->+    GLsizeiptr ->+    Ptr () ->+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedBufferStorageEXT :: FunPtr FuntypeNamedBufferStorageEXT -> FuntypeNamedBufferStorageEXT+glrefNamedBufferStorageEXT :: IORef FuntypeNamedBufferStorageEXT+glrefNamedBufferStorageEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedBufferStorageEXT #-}+glNamedBufferStorageEXT :: FuntypeNamedBufferStorageEXT+glNamedBufferStorageEXT = unsafePerformIO $ readIORef glrefNamedBufferStorageEXT+{-# INLINE glNamedBufferStorageEXT #-}+type FuntypeClearNamedBufferDataEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearNamedBufferDataEXT :: FunPtr FuntypeClearNamedBufferDataEXT -> FuntypeClearNamedBufferDataEXT+glrefClearNamedBufferDataEXT :: IORef FuntypeClearNamedBufferDataEXT+glrefClearNamedBufferDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearNamedBufferDataEXT #-}+glClearNamedBufferDataEXT :: FuntypeClearNamedBufferDataEXT+glClearNamedBufferDataEXT = unsafePerformIO $ readIORef glrefClearNamedBufferDataEXT+{-# INLINE glClearNamedBufferDataEXT #-}+type FuntypeClearNamedBufferSubDataEXT =+    GLuint ->+    GLenum ->+    GLsizeiptr ->+    GLsizeiptr ->+    GLenum ->+    GLenum ->+    Ptr () ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynClearNamedBufferSubDataEXT :: FunPtr FuntypeClearNamedBufferSubDataEXT -> FuntypeClearNamedBufferSubDataEXT+glrefClearNamedBufferSubDataEXT :: IORef FuntypeClearNamedBufferSubDataEXT+glrefClearNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefClearNamedBufferSubDataEXT #-}+glClearNamedBufferSubDataEXT :: FuntypeClearNamedBufferSubDataEXT+glClearNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefClearNamedBufferSubDataEXT+{-# INLINE glClearNamedBufferSubDataEXT #-}+type FuntypeNamedFramebufferParameteriEXT =+    GLuint ->+    GLenum ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynNamedFramebufferParameteriEXT :: FunPtr FuntypeNamedFramebufferParameteriEXT -> FuntypeNamedFramebufferParameteriEXT+glrefNamedFramebufferParameteriEXT :: IORef FuntypeNamedFramebufferParameteriEXT+glrefNamedFramebufferParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefNamedFramebufferParameteriEXT #-}+glNamedFramebufferParameteriEXT :: FuntypeNamedFramebufferParameteriEXT+glNamedFramebufferParameteriEXT = unsafePerformIO $ readIORef glrefNamedFramebufferParameteriEXT+{-# INLINE glNamedFramebufferParameteriEXT #-}+type FuntypeGetNamedFramebufferParameterivEXT =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetNamedFramebufferParameterivEXT :: FunPtr FuntypeGetNamedFramebufferParameterivEXT -> FuntypeGetNamedFramebufferParameterivEXT+glrefGetNamedFramebufferParameterivEXT :: IORef FuntypeGetNamedFramebufferParameterivEXT+glrefGetNamedFramebufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetNamedFramebufferParameterivEXT #-}+glGetNamedFramebufferParameterivEXT :: FuntypeGetNamedFramebufferParameterivEXT+glGetNamedFramebufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedFramebufferParameterivEXT+{-# INLINE glGetNamedFramebufferParameterivEXT #-}+type FuntypeProgramUniform1dEXT =+    GLuint ->+    GLint ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1dEXT :: FunPtr FuntypeProgramUniform1dEXT -> FuntypeProgramUniform1dEXT+glrefProgramUniform1dEXT :: IORef FuntypeProgramUniform1dEXT+glrefProgramUniform1dEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1dEXT #-}+glProgramUniform1dEXT :: FuntypeProgramUniform1dEXT+glProgramUniform1dEXT = unsafePerformIO $ readIORef glrefProgramUniform1dEXT+{-# INLINE glProgramUniform1dEXT #-}+type FuntypeProgramUniform2dEXT =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2dEXT :: FunPtr FuntypeProgramUniform2dEXT -> FuntypeProgramUniform2dEXT+glrefProgramUniform2dEXT :: IORef FuntypeProgramUniform2dEXT+glrefProgramUniform2dEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2dEXT #-}+glProgramUniform2dEXT :: FuntypeProgramUniform2dEXT+glProgramUniform2dEXT = unsafePerformIO $ readIORef glrefProgramUniform2dEXT+{-# INLINE glProgramUniform2dEXT #-}+type FuntypeProgramUniform3dEXT =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3dEXT :: FunPtr FuntypeProgramUniform3dEXT -> FuntypeProgramUniform3dEXT+glrefProgramUniform3dEXT :: IORef FuntypeProgramUniform3dEXT+glrefProgramUniform3dEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3dEXT #-}+glProgramUniform3dEXT :: FuntypeProgramUniform3dEXT+glProgramUniform3dEXT = unsafePerformIO $ readIORef glrefProgramUniform3dEXT+{-# INLINE glProgramUniform3dEXT #-}+type FuntypeProgramUniform4dEXT =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4dEXT :: FunPtr FuntypeProgramUniform4dEXT -> FuntypeProgramUniform4dEXT+glrefProgramUniform4dEXT :: IORef FuntypeProgramUniform4dEXT+glrefProgramUniform4dEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4dEXT #-}+glProgramUniform4dEXT :: FuntypeProgramUniform4dEXT+glProgramUniform4dEXT = unsafePerformIO $ readIORef glrefProgramUniform4dEXT+{-# INLINE glProgramUniform4dEXT #-}+type FuntypeProgramUniform1dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1dvEXT :: FunPtr FuntypeProgramUniform1dvEXT -> FuntypeProgramUniform1dvEXT+glrefProgramUniform1dvEXT :: IORef FuntypeProgramUniform1dvEXT+glrefProgramUniform1dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1dvEXT #-}+glProgramUniform1dvEXT :: FuntypeProgramUniform1dvEXT+glProgramUniform1dvEXT = unsafePerformIO $ readIORef glrefProgramUniform1dvEXT+{-# INLINE glProgramUniform1dvEXT #-}+type FuntypeProgramUniform2dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2dvEXT :: FunPtr FuntypeProgramUniform2dvEXT -> FuntypeProgramUniform2dvEXT+glrefProgramUniform2dvEXT :: IORef FuntypeProgramUniform2dvEXT+glrefProgramUniform2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2dvEXT #-}+glProgramUniform2dvEXT :: FuntypeProgramUniform2dvEXT+glProgramUniform2dvEXT = unsafePerformIO $ readIORef glrefProgramUniform2dvEXT+{-# INLINE glProgramUniform2dvEXT #-}+type FuntypeProgramUniform3dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3dvEXT :: FunPtr FuntypeProgramUniform3dvEXT -> FuntypeProgramUniform3dvEXT+glrefProgramUniform3dvEXT :: IORef FuntypeProgramUniform3dvEXT+glrefProgramUniform3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3dvEXT #-}+glProgramUniform3dvEXT :: FuntypeProgramUniform3dvEXT+glProgramUniform3dvEXT = unsafePerformIO $ readIORef glrefProgramUniform3dvEXT+{-# INLINE glProgramUniform3dvEXT #-}+type FuntypeProgramUniform4dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4dvEXT :: FunPtr FuntypeProgramUniform4dvEXT -> FuntypeProgramUniform4dvEXT+glrefProgramUniform4dvEXT :: IORef FuntypeProgramUniform4dvEXT+glrefProgramUniform4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4dvEXT #-}+glProgramUniform4dvEXT :: FuntypeProgramUniform4dvEXT+glProgramUniform4dvEXT = unsafePerformIO $ readIORef glrefProgramUniform4dvEXT+{-# INLINE glProgramUniform4dvEXT #-}+type FuntypeProgramUniformMatrix2dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2dvEXT :: FunPtr FuntypeProgramUniformMatrix2dvEXT -> FuntypeProgramUniformMatrix2dvEXT+glrefProgramUniformMatrix2dvEXT :: IORef FuntypeProgramUniformMatrix2dvEXT+glrefProgramUniformMatrix2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2dvEXT #-}+glProgramUniformMatrix2dvEXT :: FuntypeProgramUniformMatrix2dvEXT+glProgramUniformMatrix2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2dvEXT+{-# INLINE glProgramUniformMatrix2dvEXT #-}+type FuntypeProgramUniformMatrix3dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3dvEXT :: FunPtr FuntypeProgramUniformMatrix3dvEXT -> FuntypeProgramUniformMatrix3dvEXT+glrefProgramUniformMatrix3dvEXT :: IORef FuntypeProgramUniformMatrix3dvEXT+glrefProgramUniformMatrix3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3dvEXT #-}+glProgramUniformMatrix3dvEXT :: FuntypeProgramUniformMatrix3dvEXT+glProgramUniformMatrix3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3dvEXT+{-# INLINE glProgramUniformMatrix3dvEXT #-}+type FuntypeProgramUniformMatrix4dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4dvEXT :: FunPtr FuntypeProgramUniformMatrix4dvEXT -> FuntypeProgramUniformMatrix4dvEXT+glrefProgramUniformMatrix4dvEXT :: IORef FuntypeProgramUniformMatrix4dvEXT+glrefProgramUniformMatrix4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4dvEXT #-}+glProgramUniformMatrix4dvEXT :: FuntypeProgramUniformMatrix4dvEXT+glProgramUniformMatrix4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4dvEXT+{-# INLINE glProgramUniformMatrix4dvEXT #-}+type FuntypeProgramUniformMatrix2x3dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x3dvEXT :: FunPtr FuntypeProgramUniformMatrix2x3dvEXT -> FuntypeProgramUniformMatrix2x3dvEXT+glrefProgramUniformMatrix2x3dvEXT :: IORef FuntypeProgramUniformMatrix2x3dvEXT+glrefProgramUniformMatrix2x3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x3dvEXT #-}+glProgramUniformMatrix2x3dvEXT :: FuntypeProgramUniformMatrix2x3dvEXT+glProgramUniformMatrix2x3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3dvEXT+{-# INLINE glProgramUniformMatrix2x3dvEXT #-}+type FuntypeProgramUniformMatrix2x4dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x4dvEXT :: FunPtr FuntypeProgramUniformMatrix2x4dvEXT -> FuntypeProgramUniformMatrix2x4dvEXT+glrefProgramUniformMatrix2x4dvEXT :: IORef FuntypeProgramUniformMatrix2x4dvEXT+glrefProgramUniformMatrix2x4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x4dvEXT #-}+glProgramUniformMatrix2x4dvEXT :: FuntypeProgramUniformMatrix2x4dvEXT+glProgramUniformMatrix2x4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4dvEXT+{-# INLINE glProgramUniformMatrix2x4dvEXT #-}+type FuntypeProgramUniformMatrix3x2dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x2dvEXT :: FunPtr FuntypeProgramUniformMatrix3x2dvEXT -> FuntypeProgramUniformMatrix3x2dvEXT+glrefProgramUniformMatrix3x2dvEXT :: IORef FuntypeProgramUniformMatrix3x2dvEXT+glrefProgramUniformMatrix3x2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x2dvEXT #-}+glProgramUniformMatrix3x2dvEXT :: FuntypeProgramUniformMatrix3x2dvEXT+glProgramUniformMatrix3x2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2dvEXT+{-# INLINE glProgramUniformMatrix3x2dvEXT #-}+type FuntypeProgramUniformMatrix3x4dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x4dvEXT :: FunPtr FuntypeProgramUniformMatrix3x4dvEXT -> FuntypeProgramUniformMatrix3x4dvEXT+glrefProgramUniformMatrix3x4dvEXT :: IORef FuntypeProgramUniformMatrix3x4dvEXT+glrefProgramUniformMatrix3x4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x4dvEXT #-}+glProgramUniformMatrix3x4dvEXT :: FuntypeProgramUniformMatrix3x4dvEXT+glProgramUniformMatrix3x4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4dvEXT+{-# INLINE glProgramUniformMatrix3x4dvEXT #-}+type FuntypeProgramUniformMatrix4x2dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x2dvEXT :: FunPtr FuntypeProgramUniformMatrix4x2dvEXT -> FuntypeProgramUniformMatrix4x2dvEXT+glrefProgramUniformMatrix4x2dvEXT :: IORef FuntypeProgramUniformMatrix4x2dvEXT+glrefProgramUniformMatrix4x2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x2dvEXT #-}+glProgramUniformMatrix4x2dvEXT :: FuntypeProgramUniformMatrix4x2dvEXT+glProgramUniformMatrix4x2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2dvEXT+{-# INLINE glProgramUniformMatrix4x2dvEXT #-}+type FuntypeProgramUniformMatrix4x3dvEXT =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x3dvEXT :: FunPtr FuntypeProgramUniformMatrix4x3dvEXT -> FuntypeProgramUniformMatrix4x3dvEXT+glrefProgramUniformMatrix4x3dvEXT :: IORef FuntypeProgramUniformMatrix4x3dvEXT+glrefProgramUniformMatrix4x3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x3dvEXT #-}+glProgramUniformMatrix4x3dvEXT :: FuntypeProgramUniformMatrix4x3dvEXT+glProgramUniformMatrix4x3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3dvEXT+{-# INLINE glProgramUniformMatrix4x3dvEXT #-}+type FuntypeTextureBufferRangeEXT =+    GLuint ->+    GLenum ->+    GLenum ->+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureBufferRangeEXT :: FunPtr FuntypeTextureBufferRangeEXT -> FuntypeTextureBufferRangeEXT+glrefTextureBufferRangeEXT :: IORef FuntypeTextureBufferRangeEXT+glrefTextureBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureBufferRangeEXT #-}+glTextureBufferRangeEXT :: FuntypeTextureBufferRangeEXT+glTextureBufferRangeEXT = unsafePerformIO $ readIORef glrefTextureBufferRangeEXT+{-# INLINE glTextureBufferRangeEXT #-}+type FuntypeTextureStorage1DEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureStorage1DEXT :: FunPtr FuntypeTextureStorage1DEXT -> FuntypeTextureStorage1DEXT+glrefTextureStorage1DEXT :: IORef FuntypeTextureStorage1DEXT+glrefTextureStorage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureStorage1DEXT #-}+glTextureStorage1DEXT :: FuntypeTextureStorage1DEXT+glTextureStorage1DEXT = unsafePerformIO $ readIORef glrefTextureStorage1DEXT+{-# INLINE glTextureStorage1DEXT #-}+type FuntypeTextureStorage2DEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureStorage2DEXT :: FunPtr FuntypeTextureStorage2DEXT -> FuntypeTextureStorage2DEXT+glrefTextureStorage2DEXT :: IORef FuntypeTextureStorage2DEXT+glrefTextureStorage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureStorage2DEXT #-}+glTextureStorage2DEXT :: FuntypeTextureStorage2DEXT+glTextureStorage2DEXT = unsafePerformIO $ readIORef glrefTextureStorage2DEXT+{-# INLINE glTextureStorage2DEXT #-}+type FuntypeTextureStorage3DEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureStorage3DEXT :: FunPtr FuntypeTextureStorage3DEXT -> FuntypeTextureStorage3DEXT+glrefTextureStorage3DEXT :: IORef FuntypeTextureStorage3DEXT+glrefTextureStorage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureStorage3DEXT #-}+glTextureStorage3DEXT :: FuntypeTextureStorage3DEXT+glTextureStorage3DEXT = unsafePerformIO $ readIORef glrefTextureStorage3DEXT+{-# INLINE glTextureStorage3DEXT #-}+type FuntypeTextureStorage2DMultisampleEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureStorage2DMultisampleEXT :: FunPtr FuntypeTextureStorage2DMultisampleEXT -> FuntypeTextureStorage2DMultisampleEXT+glrefTextureStorage2DMultisampleEXT :: IORef FuntypeTextureStorage2DMultisampleEXT+glrefTextureStorage2DMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureStorage2DMultisampleEXT #-}+glTextureStorage2DMultisampleEXT :: FuntypeTextureStorage2DMultisampleEXT+glTextureStorage2DMultisampleEXT = unsafePerformIO $ readIORef glrefTextureStorage2DMultisampleEXT+{-# INLINE glTextureStorage2DMultisampleEXT #-}+type FuntypeTextureStorage3DMultisampleEXT =+    GLuint ->+    GLenum ->+    GLsizei ->+    GLenum ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTextureStorage3DMultisampleEXT :: FunPtr FuntypeTextureStorage3DMultisampleEXT -> FuntypeTextureStorage3DMultisampleEXT+glrefTextureStorage3DMultisampleEXT :: IORef FuntypeTextureStorage3DMultisampleEXT+glrefTextureStorage3DMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTextureStorage3DMultisampleEXT #-}+glTextureStorage3DMultisampleEXT :: FuntypeTextureStorage3DMultisampleEXT+glTextureStorage3DMultisampleEXT = unsafePerformIO $ readIORef glrefTextureStorage3DMultisampleEXT+{-# INLINE glTextureStorage3DMultisampleEXT #-}+type FuntypeVertexArrayBindVertexBufferEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    GLintptr ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayBindVertexBufferEXT :: FunPtr FuntypeVertexArrayBindVertexBufferEXT -> FuntypeVertexArrayBindVertexBufferEXT+glrefVertexArrayBindVertexBufferEXT :: IORef FuntypeVertexArrayBindVertexBufferEXT+glrefVertexArrayBindVertexBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayBindVertexBufferEXT #-}+glVertexArrayBindVertexBufferEXT :: FuntypeVertexArrayBindVertexBufferEXT+glVertexArrayBindVertexBufferEXT = unsafePerformIO $ readIORef glrefVertexArrayBindVertexBufferEXT+{-# INLINE glVertexArrayBindVertexBufferEXT #-}+type FuntypeVertexArrayVertexAttribFormatEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLboolean ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribFormatEXT -> FuntypeVertexArrayVertexAttribFormatEXT+glrefVertexArrayVertexAttribFormatEXT :: IORef FuntypeVertexArrayVertexAttribFormatEXT+glrefVertexArrayVertexAttribFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribFormatEXT #-}+glVertexArrayVertexAttribFormatEXT :: FuntypeVertexArrayVertexAttribFormatEXT+glVertexArrayVertexAttribFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribFormatEXT+{-# INLINE glVertexArrayVertexAttribFormatEXT #-}+type FuntypeVertexArrayVertexAttribIFormatEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribIFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribIFormatEXT -> FuntypeVertexArrayVertexAttribIFormatEXT+glrefVertexArrayVertexAttribIFormatEXT :: IORef FuntypeVertexArrayVertexAttribIFormatEXT+glrefVertexArrayVertexAttribIFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribIFormatEXT #-}+glVertexArrayVertexAttribIFormatEXT :: FuntypeVertexArrayVertexAttribIFormatEXT+glVertexArrayVertexAttribIFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribIFormatEXT+{-# INLINE glVertexArrayVertexAttribIFormatEXT #-}+type FuntypeVertexArrayVertexAttribLFormatEXT =+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribLFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribLFormatEXT -> FuntypeVertexArrayVertexAttribLFormatEXT+glrefVertexArrayVertexAttribLFormatEXT :: IORef FuntypeVertexArrayVertexAttribLFormatEXT+glrefVertexArrayVertexAttribLFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribLFormatEXT #-}+glVertexArrayVertexAttribLFormatEXT :: FuntypeVertexArrayVertexAttribLFormatEXT+glVertexArrayVertexAttribLFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribLFormatEXT+{-# INLINE glVertexArrayVertexAttribLFormatEXT #-}+type FuntypeVertexArrayVertexAttribBindingEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribBindingEXT :: FunPtr FuntypeVertexArrayVertexAttribBindingEXT -> FuntypeVertexArrayVertexAttribBindingEXT+glrefVertexArrayVertexAttribBindingEXT :: IORef FuntypeVertexArrayVertexAttribBindingEXT+glrefVertexArrayVertexAttribBindingEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribBindingEXT #-}+glVertexArrayVertexAttribBindingEXT :: FuntypeVertexArrayVertexAttribBindingEXT+glVertexArrayVertexAttribBindingEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribBindingEXT+{-# INLINE glVertexArrayVertexAttribBindingEXT #-}+type FuntypeVertexArrayVertexBindingDivisorEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexBindingDivisorEXT :: FunPtr FuntypeVertexArrayVertexBindingDivisorEXT -> FuntypeVertexArrayVertexBindingDivisorEXT+glrefVertexArrayVertexBindingDivisorEXT :: IORef FuntypeVertexArrayVertexBindingDivisorEXT+glrefVertexArrayVertexBindingDivisorEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexBindingDivisorEXT #-}+glVertexArrayVertexBindingDivisorEXT :: FuntypeVertexArrayVertexBindingDivisorEXT+glVertexArrayVertexBindingDivisorEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexBindingDivisorEXT+{-# INLINE glVertexArrayVertexBindingDivisorEXT #-}+type FuntypeVertexArrayVertexAttribLOffsetEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    GLint ->+    GLenum ->+    GLsizei ->+    GLintptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribLOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribLOffsetEXT -> FuntypeVertexArrayVertexAttribLOffsetEXT+glrefVertexArrayVertexAttribLOffsetEXT :: IORef FuntypeVertexArrayVertexAttribLOffsetEXT+glrefVertexArrayVertexAttribLOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribLOffsetEXT #-}+glVertexArrayVertexAttribLOffsetEXT :: FuntypeVertexArrayVertexAttribLOffsetEXT+glVertexArrayVertexAttribLOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribLOffsetEXT+{-# INLINE glVertexArrayVertexAttribLOffsetEXT #-}+type FuntypeTexturePageCommitmentEXT =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    GLboolean ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynTexturePageCommitmentEXT :: FunPtr FuntypeTexturePageCommitmentEXT -> FuntypeTexturePageCommitmentEXT+glrefTexturePageCommitmentEXT :: IORef FuntypeTexturePageCommitmentEXT+glrefTexturePageCommitmentEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefTexturePageCommitmentEXT #-}+glTexturePageCommitmentEXT :: FuntypeTexturePageCommitmentEXT+glTexturePageCommitmentEXT = unsafePerformIO $ readIORef glrefTexturePageCommitmentEXT+{-# INLINE glTexturePageCommitmentEXT #-}+type FuntypeVertexArrayVertexAttribDivisorEXT =+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynVertexArrayVertexAttribDivisorEXT :: FunPtr FuntypeVertexArrayVertexAttribDivisorEXT -> FuntypeVertexArrayVertexAttribDivisorEXT+glrefVertexArrayVertexAttribDivisorEXT :: IORef FuntypeVertexArrayVertexAttribDivisorEXT+glrefVertexArrayVertexAttribDivisorEXT = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefVertexArrayVertexAttribDivisorEXT #-}+glVertexArrayVertexAttribDivisorEXT :: FuntypeVertexArrayVertexAttribDivisorEXT+glVertexArrayVertexAttribDivisorEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribDivisorEXT+{-# INLINE glVertexArrayVertexAttribDivisorEXT #-}++-- GL_ARB_buffer_storage++type FuntypeBufferStorage =+    GLenum ->+    GLsizeiptr ->+    Ptr () ->+    GLbitfield ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBufferStorage :: FunPtr FuntypeBufferStorage -> FuntypeBufferStorage+glrefBufferStorage :: IORef FuntypeBufferStorage+glrefBufferStorage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBufferStorage #-}+glBufferStorage :: FuntypeBufferStorage+glBufferStorage = unsafePerformIO $ readIORef glrefBufferStorage+{-# INLINE glBufferStorage #-}++-- GL_ARB_separate_shader_objects++type FuntypeUseProgramStages =+    GLuint ->+    GLbitfield ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynUseProgramStages :: FunPtr FuntypeUseProgramStages -> FuntypeUseProgramStages+glrefUseProgramStages :: IORef FuntypeUseProgramStages+glrefUseProgramStages = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefUseProgramStages #-}+glUseProgramStages :: FuntypeUseProgramStages+glUseProgramStages = unsafePerformIO $ readIORef glrefUseProgramStages+{-# INLINE glUseProgramStages #-}+type FuntypeActiveShaderProgram =+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynActiveShaderProgram :: FunPtr FuntypeActiveShaderProgram -> FuntypeActiveShaderProgram+glrefActiveShaderProgram :: IORef FuntypeActiveShaderProgram+glrefActiveShaderProgram = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefActiveShaderProgram #-}+glActiveShaderProgram :: FuntypeActiveShaderProgram+glActiveShaderProgram = unsafePerformIO $ readIORef glrefActiveShaderProgram+{-# INLINE glActiveShaderProgram #-}+type FuntypeCreateShaderProgramv =+    GLenum ->+    GLsizei ->+    Ptr (Ptr (GLchar)) ->+    IO ( GLuint )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynCreateShaderProgramv :: FunPtr FuntypeCreateShaderProgramv -> FuntypeCreateShaderProgramv+glrefCreateShaderProgramv :: IORef FuntypeCreateShaderProgramv+glrefCreateShaderProgramv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefCreateShaderProgramv #-}+glCreateShaderProgramv :: FuntypeCreateShaderProgramv+glCreateShaderProgramv = unsafePerformIO $ readIORef glrefCreateShaderProgramv+{-# INLINE glCreateShaderProgramv #-}+type FuntypeBindProgramPipeline =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynBindProgramPipeline :: FunPtr FuntypeBindProgramPipeline -> FuntypeBindProgramPipeline+glrefBindProgramPipeline :: IORef FuntypeBindProgramPipeline+glrefBindProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefBindProgramPipeline #-}+glBindProgramPipeline :: FuntypeBindProgramPipeline+glBindProgramPipeline = unsafePerformIO $ readIORef glrefBindProgramPipeline+{-# INLINE glBindProgramPipeline #-}+type FuntypeDeleteProgramPipelines =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynDeleteProgramPipelines :: FunPtr FuntypeDeleteProgramPipelines -> FuntypeDeleteProgramPipelines+glrefDeleteProgramPipelines :: IORef FuntypeDeleteProgramPipelines+glrefDeleteProgramPipelines = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefDeleteProgramPipelines #-}+glDeleteProgramPipelines :: FuntypeDeleteProgramPipelines+glDeleteProgramPipelines = unsafePerformIO $ readIORef glrefDeleteProgramPipelines+{-# INLINE glDeleteProgramPipelines #-}+type FuntypeGenProgramPipelines =+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGenProgramPipelines :: FunPtr FuntypeGenProgramPipelines -> FuntypeGenProgramPipelines+glrefGenProgramPipelines :: IORef FuntypeGenProgramPipelines+glrefGenProgramPipelines = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGenProgramPipelines #-}+glGenProgramPipelines :: FuntypeGenProgramPipelines+glGenProgramPipelines = unsafePerformIO $ readIORef glrefGenProgramPipelines+{-# INLINE glGenProgramPipelines #-}+type FuntypeIsProgramPipeline =+    GLuint ->+    IO ( GLboolean )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynIsProgramPipeline :: FunPtr FuntypeIsProgramPipeline -> FuntypeIsProgramPipeline+glrefIsProgramPipeline :: IORef FuntypeIsProgramPipeline+glrefIsProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefIsProgramPipeline #-}+glIsProgramPipeline :: FuntypeIsProgramPipeline+glIsProgramPipeline = unsafePerformIO $ readIORef glrefIsProgramPipeline+{-# INLINE glIsProgramPipeline #-}+type FuntypeGetProgramPipelineiv =+    GLuint ->+    GLenum ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetProgramPipelineiv :: FunPtr FuntypeGetProgramPipelineiv -> FuntypeGetProgramPipelineiv+glrefGetProgramPipelineiv :: IORef FuntypeGetProgramPipelineiv+glrefGetProgramPipelineiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetProgramPipelineiv #-}+glGetProgramPipelineiv :: FuntypeGetProgramPipelineiv+glGetProgramPipelineiv = unsafePerformIO $ readIORef glrefGetProgramPipelineiv+{-# INLINE glGetProgramPipelineiv #-}+type FuntypeProgramUniform1i =+    GLuint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1i :: FunPtr FuntypeProgramUniform1i -> FuntypeProgramUniform1i+glrefProgramUniform1i :: IORef FuntypeProgramUniform1i+glrefProgramUniform1i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1i #-}+glProgramUniform1i :: FuntypeProgramUniform1i+glProgramUniform1i = unsafePerformIO $ readIORef glrefProgramUniform1i+{-# INLINE glProgramUniform1i #-}+type FuntypeProgramUniform1iv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1iv :: FunPtr FuntypeProgramUniform1iv -> FuntypeProgramUniform1iv+glrefProgramUniform1iv :: IORef FuntypeProgramUniform1iv+glrefProgramUniform1iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1iv #-}+glProgramUniform1iv :: FuntypeProgramUniform1iv+glProgramUniform1iv = unsafePerformIO $ readIORef glrefProgramUniform1iv+{-# INLINE glProgramUniform1iv #-}+type FuntypeProgramUniform1f =+    GLuint ->+    GLint ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1f :: FunPtr FuntypeProgramUniform1f -> FuntypeProgramUniform1f+glrefProgramUniform1f :: IORef FuntypeProgramUniform1f+glrefProgramUniform1f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1f #-}+glProgramUniform1f :: FuntypeProgramUniform1f+glProgramUniform1f = unsafePerformIO $ readIORef glrefProgramUniform1f+{-# INLINE glProgramUniform1f #-}+type FuntypeProgramUniform1fv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1fv :: FunPtr FuntypeProgramUniform1fv -> FuntypeProgramUniform1fv+glrefProgramUniform1fv :: IORef FuntypeProgramUniform1fv+glrefProgramUniform1fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1fv #-}+glProgramUniform1fv :: FuntypeProgramUniform1fv+glProgramUniform1fv = unsafePerformIO $ readIORef glrefProgramUniform1fv+{-# INLINE glProgramUniform1fv #-}+type FuntypeProgramUniform1d =+    GLuint ->+    GLint ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1d :: FunPtr FuntypeProgramUniform1d -> FuntypeProgramUniform1d+glrefProgramUniform1d :: IORef FuntypeProgramUniform1d+glrefProgramUniform1d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1d #-}+glProgramUniform1d :: FuntypeProgramUniform1d+glProgramUniform1d = unsafePerformIO $ readIORef glrefProgramUniform1d+{-# INLINE glProgramUniform1d #-}+type FuntypeProgramUniform1dv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1dv :: FunPtr FuntypeProgramUniform1dv -> FuntypeProgramUniform1dv+glrefProgramUniform1dv :: IORef FuntypeProgramUniform1dv+glrefProgramUniform1dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1dv #-}+glProgramUniform1dv :: FuntypeProgramUniform1dv+glProgramUniform1dv = unsafePerformIO $ readIORef glrefProgramUniform1dv+{-# INLINE glProgramUniform1dv #-}+type FuntypeProgramUniform1ui =+    GLuint ->+    GLint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1ui :: FunPtr FuntypeProgramUniform1ui -> FuntypeProgramUniform1ui+glrefProgramUniform1ui :: IORef FuntypeProgramUniform1ui+glrefProgramUniform1ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1ui #-}+glProgramUniform1ui :: FuntypeProgramUniform1ui+glProgramUniform1ui = unsafePerformIO $ readIORef glrefProgramUniform1ui+{-# INLINE glProgramUniform1ui #-}+type FuntypeProgramUniform1uiv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform1uiv :: FunPtr FuntypeProgramUniform1uiv -> FuntypeProgramUniform1uiv+glrefProgramUniform1uiv :: IORef FuntypeProgramUniform1uiv+glrefProgramUniform1uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform1uiv #-}+glProgramUniform1uiv :: FuntypeProgramUniform1uiv+glProgramUniform1uiv = unsafePerformIO $ readIORef glrefProgramUniform1uiv+{-# INLINE glProgramUniform1uiv #-}+type FuntypeProgramUniform2i =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2i :: FunPtr FuntypeProgramUniform2i -> FuntypeProgramUniform2i+glrefProgramUniform2i :: IORef FuntypeProgramUniform2i+glrefProgramUniform2i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2i #-}+glProgramUniform2i :: FuntypeProgramUniform2i+glProgramUniform2i = unsafePerformIO $ readIORef glrefProgramUniform2i+{-# INLINE glProgramUniform2i #-}+type FuntypeProgramUniform2iv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2iv :: FunPtr FuntypeProgramUniform2iv -> FuntypeProgramUniform2iv+glrefProgramUniform2iv :: IORef FuntypeProgramUniform2iv+glrefProgramUniform2iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2iv #-}+glProgramUniform2iv :: FuntypeProgramUniform2iv+glProgramUniform2iv = unsafePerformIO $ readIORef glrefProgramUniform2iv+{-# INLINE glProgramUniform2iv #-}+type FuntypeProgramUniform2f =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2f :: FunPtr FuntypeProgramUniform2f -> FuntypeProgramUniform2f+glrefProgramUniform2f :: IORef FuntypeProgramUniform2f+glrefProgramUniform2f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2f #-}+glProgramUniform2f :: FuntypeProgramUniform2f+glProgramUniform2f = unsafePerformIO $ readIORef glrefProgramUniform2f+{-# INLINE glProgramUniform2f #-}+type FuntypeProgramUniform2fv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2fv :: FunPtr FuntypeProgramUniform2fv -> FuntypeProgramUniform2fv+glrefProgramUniform2fv :: IORef FuntypeProgramUniform2fv+glrefProgramUniform2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2fv #-}+glProgramUniform2fv :: FuntypeProgramUniform2fv+glProgramUniform2fv = unsafePerformIO $ readIORef glrefProgramUniform2fv+{-# INLINE glProgramUniform2fv #-}+type FuntypeProgramUniform2d =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2d :: FunPtr FuntypeProgramUniform2d -> FuntypeProgramUniform2d+glrefProgramUniform2d :: IORef FuntypeProgramUniform2d+glrefProgramUniform2d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2d #-}+glProgramUniform2d :: FuntypeProgramUniform2d+glProgramUniform2d = unsafePerformIO $ readIORef glrefProgramUniform2d+{-# INLINE glProgramUniform2d #-}+type FuntypeProgramUniform2dv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2dv :: FunPtr FuntypeProgramUniform2dv -> FuntypeProgramUniform2dv+glrefProgramUniform2dv :: IORef FuntypeProgramUniform2dv+glrefProgramUniform2dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2dv #-}+glProgramUniform2dv :: FuntypeProgramUniform2dv+glProgramUniform2dv = unsafePerformIO $ readIORef glrefProgramUniform2dv+{-# INLINE glProgramUniform2dv #-}+type FuntypeProgramUniform2ui =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2ui :: FunPtr FuntypeProgramUniform2ui -> FuntypeProgramUniform2ui+glrefProgramUniform2ui :: IORef FuntypeProgramUniform2ui+glrefProgramUniform2ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2ui #-}+glProgramUniform2ui :: FuntypeProgramUniform2ui+glProgramUniform2ui = unsafePerformIO $ readIORef glrefProgramUniform2ui+{-# INLINE glProgramUniform2ui #-}+type FuntypeProgramUniform2uiv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform2uiv :: FunPtr FuntypeProgramUniform2uiv -> FuntypeProgramUniform2uiv+glrefProgramUniform2uiv :: IORef FuntypeProgramUniform2uiv+glrefProgramUniform2uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform2uiv #-}+glProgramUniform2uiv :: FuntypeProgramUniform2uiv+glProgramUniform2uiv = unsafePerformIO $ readIORef glrefProgramUniform2uiv+{-# INLINE glProgramUniform2uiv #-}+type FuntypeProgramUniform3i =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3i :: FunPtr FuntypeProgramUniform3i -> FuntypeProgramUniform3i+glrefProgramUniform3i :: IORef FuntypeProgramUniform3i+glrefProgramUniform3i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3i #-}+glProgramUniform3i :: FuntypeProgramUniform3i+glProgramUniform3i = unsafePerformIO $ readIORef glrefProgramUniform3i+{-# INLINE glProgramUniform3i #-}+type FuntypeProgramUniform3iv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3iv :: FunPtr FuntypeProgramUniform3iv -> FuntypeProgramUniform3iv+glrefProgramUniform3iv :: IORef FuntypeProgramUniform3iv+glrefProgramUniform3iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3iv #-}+glProgramUniform3iv :: FuntypeProgramUniform3iv+glProgramUniform3iv = unsafePerformIO $ readIORef glrefProgramUniform3iv+{-# INLINE glProgramUniform3iv #-}+type FuntypeProgramUniform3f =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3f :: FunPtr FuntypeProgramUniform3f -> FuntypeProgramUniform3f+glrefProgramUniform3f :: IORef FuntypeProgramUniform3f+glrefProgramUniform3f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3f #-}+glProgramUniform3f :: FuntypeProgramUniform3f+glProgramUniform3f = unsafePerformIO $ readIORef glrefProgramUniform3f+{-# INLINE glProgramUniform3f #-}+type FuntypeProgramUniform3fv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3fv :: FunPtr FuntypeProgramUniform3fv -> FuntypeProgramUniform3fv+glrefProgramUniform3fv :: IORef FuntypeProgramUniform3fv+glrefProgramUniform3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3fv #-}+glProgramUniform3fv :: FuntypeProgramUniform3fv+glProgramUniform3fv = unsafePerformIO $ readIORef glrefProgramUniform3fv+{-# INLINE glProgramUniform3fv #-}+type FuntypeProgramUniform3d =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3d :: FunPtr FuntypeProgramUniform3d -> FuntypeProgramUniform3d+glrefProgramUniform3d :: IORef FuntypeProgramUniform3d+glrefProgramUniform3d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3d #-}+glProgramUniform3d :: FuntypeProgramUniform3d+glProgramUniform3d = unsafePerformIO $ readIORef glrefProgramUniform3d+{-# INLINE glProgramUniform3d #-}+type FuntypeProgramUniform3dv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3dv :: FunPtr FuntypeProgramUniform3dv -> FuntypeProgramUniform3dv+glrefProgramUniform3dv :: IORef FuntypeProgramUniform3dv+glrefProgramUniform3dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3dv #-}+glProgramUniform3dv :: FuntypeProgramUniform3dv+glProgramUniform3dv = unsafePerformIO $ readIORef glrefProgramUniform3dv+{-# INLINE glProgramUniform3dv #-}+type FuntypeProgramUniform3ui =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3ui :: FunPtr FuntypeProgramUniform3ui -> FuntypeProgramUniform3ui+glrefProgramUniform3ui :: IORef FuntypeProgramUniform3ui+glrefProgramUniform3ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3ui #-}+glProgramUniform3ui :: FuntypeProgramUniform3ui+glProgramUniform3ui = unsafePerformIO $ readIORef glrefProgramUniform3ui+{-# INLINE glProgramUniform3ui #-}+type FuntypeProgramUniform3uiv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform3uiv :: FunPtr FuntypeProgramUniform3uiv -> FuntypeProgramUniform3uiv+glrefProgramUniform3uiv :: IORef FuntypeProgramUniform3uiv+glrefProgramUniform3uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform3uiv #-}+glProgramUniform3uiv :: FuntypeProgramUniform3uiv+glProgramUniform3uiv = unsafePerformIO $ readIORef glrefProgramUniform3uiv+{-# INLINE glProgramUniform3uiv #-}+type FuntypeProgramUniform4i =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4i :: FunPtr FuntypeProgramUniform4i -> FuntypeProgramUniform4i+glrefProgramUniform4i :: IORef FuntypeProgramUniform4i+glrefProgramUniform4i = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4i #-}+glProgramUniform4i :: FuntypeProgramUniform4i+glProgramUniform4i = unsafePerformIO $ readIORef glrefProgramUniform4i+{-# INLINE glProgramUniform4i #-}+type FuntypeProgramUniform4iv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4iv :: FunPtr FuntypeProgramUniform4iv -> FuntypeProgramUniform4iv+glrefProgramUniform4iv :: IORef FuntypeProgramUniform4iv+glrefProgramUniform4iv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4iv #-}+glProgramUniform4iv :: FuntypeProgramUniform4iv+glProgramUniform4iv = unsafePerformIO $ readIORef glrefProgramUniform4iv+{-# INLINE glProgramUniform4iv #-}+type FuntypeProgramUniform4f =+    GLuint ->+    GLint ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    GLfloat ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4f :: FunPtr FuntypeProgramUniform4f -> FuntypeProgramUniform4f+glrefProgramUniform4f :: IORef FuntypeProgramUniform4f+glrefProgramUniform4f = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4f #-}+glProgramUniform4f :: FuntypeProgramUniform4f+glProgramUniform4f = unsafePerformIO $ readIORef glrefProgramUniform4f+{-# INLINE glProgramUniform4f #-}+type FuntypeProgramUniform4fv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4fv :: FunPtr FuntypeProgramUniform4fv -> FuntypeProgramUniform4fv+glrefProgramUniform4fv :: IORef FuntypeProgramUniform4fv+glrefProgramUniform4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4fv #-}+glProgramUniform4fv :: FuntypeProgramUniform4fv+glProgramUniform4fv = unsafePerformIO $ readIORef glrefProgramUniform4fv+{-# INLINE glProgramUniform4fv #-}+type FuntypeProgramUniform4d =+    GLuint ->+    GLint ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    GLdouble ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4d :: FunPtr FuntypeProgramUniform4d -> FuntypeProgramUniform4d+glrefProgramUniform4d :: IORef FuntypeProgramUniform4d+glrefProgramUniform4d = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4d #-}+glProgramUniform4d :: FuntypeProgramUniform4d+glProgramUniform4d = unsafePerformIO $ readIORef glrefProgramUniform4d+{-# INLINE glProgramUniform4d #-}+type FuntypeProgramUniform4dv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4dv :: FunPtr FuntypeProgramUniform4dv -> FuntypeProgramUniform4dv+glrefProgramUniform4dv :: IORef FuntypeProgramUniform4dv+glrefProgramUniform4dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4dv #-}+glProgramUniform4dv :: FuntypeProgramUniform4dv+glProgramUniform4dv = unsafePerformIO $ readIORef glrefProgramUniform4dv+{-# INLINE glProgramUniform4dv #-}+type FuntypeProgramUniform4ui =+    GLuint ->+    GLint ->+    GLuint ->+    GLuint ->+    GLuint ->+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4ui :: FunPtr FuntypeProgramUniform4ui -> FuntypeProgramUniform4ui+glrefProgramUniform4ui :: IORef FuntypeProgramUniform4ui+glrefProgramUniform4ui = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4ui #-}+glProgramUniform4ui :: FuntypeProgramUniform4ui+glProgramUniform4ui = unsafePerformIO $ readIORef glrefProgramUniform4ui+{-# INLINE glProgramUniform4ui #-}+type FuntypeProgramUniform4uiv =+    GLuint ->+    GLint ->+    GLsizei ->+    Ptr (GLuint) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniform4uiv :: FunPtr FuntypeProgramUniform4uiv -> FuntypeProgramUniform4uiv+glrefProgramUniform4uiv :: IORef FuntypeProgramUniform4uiv+glrefProgramUniform4uiv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniform4uiv #-}+glProgramUniform4uiv :: FuntypeProgramUniform4uiv+glProgramUniform4uiv = unsafePerformIO $ readIORef glrefProgramUniform4uiv+{-# INLINE glProgramUniform4uiv #-}+type FuntypeProgramUniformMatrix2fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2fv :: FunPtr FuntypeProgramUniformMatrix2fv -> FuntypeProgramUniformMatrix2fv+glrefProgramUniformMatrix2fv :: IORef FuntypeProgramUniformMatrix2fv+glrefProgramUniformMatrix2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2fv #-}+glProgramUniformMatrix2fv :: FuntypeProgramUniformMatrix2fv+glProgramUniformMatrix2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2fv+{-# INLINE glProgramUniformMatrix2fv #-}+type FuntypeProgramUniformMatrix3fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3fv :: FunPtr FuntypeProgramUniformMatrix3fv -> FuntypeProgramUniformMatrix3fv+glrefProgramUniformMatrix3fv :: IORef FuntypeProgramUniformMatrix3fv+glrefProgramUniformMatrix3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3fv #-}+glProgramUniformMatrix3fv :: FuntypeProgramUniformMatrix3fv+glProgramUniformMatrix3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3fv+{-# INLINE glProgramUniformMatrix3fv #-}+type FuntypeProgramUniformMatrix4fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4fv :: FunPtr FuntypeProgramUniformMatrix4fv -> FuntypeProgramUniformMatrix4fv+glrefProgramUniformMatrix4fv :: IORef FuntypeProgramUniformMatrix4fv+glrefProgramUniformMatrix4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4fv #-}+glProgramUniformMatrix4fv :: FuntypeProgramUniformMatrix4fv+glProgramUniformMatrix4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4fv+{-# INLINE glProgramUniformMatrix4fv #-}+type FuntypeProgramUniformMatrix2dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2dv :: FunPtr FuntypeProgramUniformMatrix2dv -> FuntypeProgramUniformMatrix2dv+glrefProgramUniformMatrix2dv :: IORef FuntypeProgramUniformMatrix2dv+glrefProgramUniformMatrix2dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2dv #-}+glProgramUniformMatrix2dv :: FuntypeProgramUniformMatrix2dv+glProgramUniformMatrix2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2dv+{-# INLINE glProgramUniformMatrix2dv #-}+type FuntypeProgramUniformMatrix3dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3dv :: FunPtr FuntypeProgramUniformMatrix3dv -> FuntypeProgramUniformMatrix3dv+glrefProgramUniformMatrix3dv :: IORef FuntypeProgramUniformMatrix3dv+glrefProgramUniformMatrix3dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3dv #-}+glProgramUniformMatrix3dv :: FuntypeProgramUniformMatrix3dv+glProgramUniformMatrix3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3dv+{-# INLINE glProgramUniformMatrix3dv #-}+type FuntypeProgramUniformMatrix4dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4dv :: FunPtr FuntypeProgramUniformMatrix4dv -> FuntypeProgramUniformMatrix4dv+glrefProgramUniformMatrix4dv :: IORef FuntypeProgramUniformMatrix4dv+glrefProgramUniformMatrix4dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4dv #-}+glProgramUniformMatrix4dv :: FuntypeProgramUniformMatrix4dv+glProgramUniformMatrix4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4dv+{-# INLINE glProgramUniformMatrix4dv #-}+type FuntypeProgramUniformMatrix2x3fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x3fv :: FunPtr FuntypeProgramUniformMatrix2x3fv -> FuntypeProgramUniformMatrix2x3fv+glrefProgramUniformMatrix2x3fv :: IORef FuntypeProgramUniformMatrix2x3fv+glrefProgramUniformMatrix2x3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x3fv #-}+glProgramUniformMatrix2x3fv :: FuntypeProgramUniformMatrix2x3fv+glProgramUniformMatrix2x3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3fv+{-# INLINE glProgramUniformMatrix2x3fv #-}+type FuntypeProgramUniformMatrix3x2fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x2fv :: FunPtr FuntypeProgramUniformMatrix3x2fv -> FuntypeProgramUniformMatrix3x2fv+glrefProgramUniformMatrix3x2fv :: IORef FuntypeProgramUniformMatrix3x2fv+glrefProgramUniformMatrix3x2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x2fv #-}+glProgramUniformMatrix3x2fv :: FuntypeProgramUniformMatrix3x2fv+glProgramUniformMatrix3x2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2fv+{-# INLINE glProgramUniformMatrix3x2fv #-}+type FuntypeProgramUniformMatrix2x4fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x4fv :: FunPtr FuntypeProgramUniformMatrix2x4fv -> FuntypeProgramUniformMatrix2x4fv+glrefProgramUniformMatrix2x4fv :: IORef FuntypeProgramUniformMatrix2x4fv+glrefProgramUniformMatrix2x4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x4fv #-}+glProgramUniformMatrix2x4fv :: FuntypeProgramUniformMatrix2x4fv+glProgramUniformMatrix2x4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4fv+{-# INLINE glProgramUniformMatrix2x4fv #-}+type FuntypeProgramUniformMatrix4x2fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x2fv :: FunPtr FuntypeProgramUniformMatrix4x2fv -> FuntypeProgramUniformMatrix4x2fv+glrefProgramUniformMatrix4x2fv :: IORef FuntypeProgramUniformMatrix4x2fv+glrefProgramUniformMatrix4x2fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x2fv #-}+glProgramUniformMatrix4x2fv :: FuntypeProgramUniformMatrix4x2fv+glProgramUniformMatrix4x2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2fv+{-# INLINE glProgramUniformMatrix4x2fv #-}+type FuntypeProgramUniformMatrix3x4fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x4fv :: FunPtr FuntypeProgramUniformMatrix3x4fv -> FuntypeProgramUniformMatrix3x4fv+glrefProgramUniformMatrix3x4fv :: IORef FuntypeProgramUniformMatrix3x4fv+glrefProgramUniformMatrix3x4fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x4fv #-}+glProgramUniformMatrix3x4fv :: FuntypeProgramUniformMatrix3x4fv+glProgramUniformMatrix3x4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4fv+{-# INLINE glProgramUniformMatrix3x4fv #-}+type FuntypeProgramUniformMatrix4x3fv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLfloat) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x3fv :: FunPtr FuntypeProgramUniformMatrix4x3fv -> FuntypeProgramUniformMatrix4x3fv+glrefProgramUniformMatrix4x3fv :: IORef FuntypeProgramUniformMatrix4x3fv+glrefProgramUniformMatrix4x3fv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x3fv #-}+glProgramUniformMatrix4x3fv :: FuntypeProgramUniformMatrix4x3fv+glProgramUniformMatrix4x3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3fv+{-# INLINE glProgramUniformMatrix4x3fv #-}+type FuntypeProgramUniformMatrix2x3dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x3dv :: FunPtr FuntypeProgramUniformMatrix2x3dv -> FuntypeProgramUniformMatrix2x3dv+glrefProgramUniformMatrix2x3dv :: IORef FuntypeProgramUniformMatrix2x3dv+glrefProgramUniformMatrix2x3dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x3dv #-}+glProgramUniformMatrix2x3dv :: FuntypeProgramUniformMatrix2x3dv+glProgramUniformMatrix2x3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3dv+{-# INLINE glProgramUniformMatrix2x3dv #-}+type FuntypeProgramUniformMatrix3x2dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x2dv :: FunPtr FuntypeProgramUniformMatrix3x2dv -> FuntypeProgramUniformMatrix3x2dv+glrefProgramUniformMatrix3x2dv :: IORef FuntypeProgramUniformMatrix3x2dv+glrefProgramUniformMatrix3x2dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x2dv #-}+glProgramUniformMatrix3x2dv :: FuntypeProgramUniformMatrix3x2dv+glProgramUniformMatrix3x2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2dv+{-# INLINE glProgramUniformMatrix3x2dv #-}+type FuntypeProgramUniformMatrix2x4dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix2x4dv :: FunPtr FuntypeProgramUniformMatrix2x4dv -> FuntypeProgramUniformMatrix2x4dv+glrefProgramUniformMatrix2x4dv :: IORef FuntypeProgramUniformMatrix2x4dv+glrefProgramUniformMatrix2x4dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix2x4dv #-}+glProgramUniformMatrix2x4dv :: FuntypeProgramUniformMatrix2x4dv+glProgramUniformMatrix2x4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4dv+{-# INLINE glProgramUniformMatrix2x4dv #-}+type FuntypeProgramUniformMatrix4x2dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x2dv :: FunPtr FuntypeProgramUniformMatrix4x2dv -> FuntypeProgramUniformMatrix4x2dv+glrefProgramUniformMatrix4x2dv :: IORef FuntypeProgramUniformMatrix4x2dv+glrefProgramUniformMatrix4x2dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x2dv #-}+glProgramUniformMatrix4x2dv :: FuntypeProgramUniformMatrix4x2dv+glProgramUniformMatrix4x2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2dv+{-# INLINE glProgramUniformMatrix4x2dv #-}+type FuntypeProgramUniformMatrix3x4dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix3x4dv :: FunPtr FuntypeProgramUniformMatrix3x4dv -> FuntypeProgramUniformMatrix3x4dv+glrefProgramUniformMatrix3x4dv :: IORef FuntypeProgramUniformMatrix3x4dv+glrefProgramUniformMatrix3x4dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix3x4dv #-}+glProgramUniformMatrix3x4dv :: FuntypeProgramUniformMatrix3x4dv+glProgramUniformMatrix3x4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4dv+{-# INLINE glProgramUniformMatrix3x4dv #-}+type FuntypeProgramUniformMatrix4x3dv =+    GLuint ->+    GLint ->+    GLsizei ->+    GLboolean ->+    Ptr (GLdouble) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynProgramUniformMatrix4x3dv :: FunPtr FuntypeProgramUniformMatrix4x3dv -> FuntypeProgramUniformMatrix4x3dv+glrefProgramUniformMatrix4x3dv :: IORef FuntypeProgramUniformMatrix4x3dv+glrefProgramUniformMatrix4x3dv = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefProgramUniformMatrix4x3dv #-}+glProgramUniformMatrix4x3dv :: FuntypeProgramUniformMatrix4x3dv+glProgramUniformMatrix4x3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3dv+{-# INLINE glProgramUniformMatrix4x3dv #-}+type FuntypeValidateProgramPipeline =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynValidateProgramPipeline :: FunPtr FuntypeValidateProgramPipeline -> FuntypeValidateProgramPipeline+glrefValidateProgramPipeline :: IORef FuntypeValidateProgramPipeline+glrefValidateProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefValidateProgramPipeline #-}+glValidateProgramPipeline :: FuntypeValidateProgramPipeline+glValidateProgramPipeline = unsafePerformIO $ readIORef glrefValidateProgramPipeline+{-# INLINE glValidateProgramPipeline #-}+type FuntypeGetProgramPipelineInfoLog =+    GLuint ->+    GLsizei ->+    Ptr (GLsizei) ->+    Ptr (GLchar) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynGetProgramPipelineInfoLog :: FunPtr FuntypeGetProgramPipelineInfoLog -> FuntypeGetProgramPipelineInfoLog+glrefGetProgramPipelineInfoLog :: IORef FuntypeGetProgramPipelineInfoLog+glrefGetProgramPipelineInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefGetProgramPipelineInfoLog #-}+glGetProgramPipelineInfoLog :: FuntypeGetProgramPipelineInfoLog+glGetProgramPipelineInfoLog = unsafePerformIO $ readIORef glrefGetProgramPipelineInfoLog+{-# INLINE glGetProgramPipelineInfoLog #-}++-- GL_ATI_meminfo+++-- GL_NVX_gpu_memory_info+++-- GL_ARB_invalidate_subdata++type FuntypeInvalidateTexSubImage =+    GLuint ->+    GLint ->+    GLint ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateTexSubImage :: FunPtr FuntypeInvalidateTexSubImage -> FuntypeInvalidateTexSubImage+glrefInvalidateTexSubImage :: IORef FuntypeInvalidateTexSubImage+glrefInvalidateTexSubImage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateTexSubImage #-}+glInvalidateTexSubImage :: FuntypeInvalidateTexSubImage+glInvalidateTexSubImage = unsafePerformIO $ readIORef glrefInvalidateTexSubImage+{-# INLINE glInvalidateTexSubImage #-}+type FuntypeInvalidateTexImage =+    GLuint ->+    GLint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateTexImage :: FunPtr FuntypeInvalidateTexImage -> FuntypeInvalidateTexImage+glrefInvalidateTexImage :: IORef FuntypeInvalidateTexImage+glrefInvalidateTexImage = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateTexImage #-}+glInvalidateTexImage :: FuntypeInvalidateTexImage+glInvalidateTexImage = unsafePerformIO $ readIORef glrefInvalidateTexImage+{-# INLINE glInvalidateTexImage #-}+type FuntypeInvalidateBufferSubData =+    GLuint ->+    GLintptr ->+    GLsizeiptr ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateBufferSubData :: FunPtr FuntypeInvalidateBufferSubData -> FuntypeInvalidateBufferSubData+glrefInvalidateBufferSubData :: IORef FuntypeInvalidateBufferSubData+glrefInvalidateBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateBufferSubData #-}+glInvalidateBufferSubData :: FuntypeInvalidateBufferSubData+glInvalidateBufferSubData = unsafePerformIO $ readIORef glrefInvalidateBufferSubData+{-# INLINE glInvalidateBufferSubData #-}+type FuntypeInvalidateBufferData =+    GLuint ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateBufferData :: FunPtr FuntypeInvalidateBufferData -> FuntypeInvalidateBufferData+glrefInvalidateBufferData :: IORef FuntypeInvalidateBufferData+glrefInvalidateBufferData = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateBufferData #-}+glInvalidateBufferData :: FuntypeInvalidateBufferData+glInvalidateBufferData = unsafePerformIO $ readIORef glrefInvalidateBufferData+{-# INLINE glInvalidateBufferData #-}+type FuntypeInvalidateFramebuffer =+    GLenum ->+    GLsizei ->+    Ptr (GLenum) ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateFramebuffer :: FunPtr FuntypeInvalidateFramebuffer -> FuntypeInvalidateFramebuffer+glrefInvalidateFramebuffer :: IORef FuntypeInvalidateFramebuffer+glrefInvalidateFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateFramebuffer #-}+glInvalidateFramebuffer :: FuntypeInvalidateFramebuffer+glInvalidateFramebuffer = unsafePerformIO $ readIORef glrefInvalidateFramebuffer+{-# INLINE glInvalidateFramebuffer #-}+type FuntypeInvalidateSubFramebuffer =+    GLenum ->+    GLsizei ->+    Ptr (GLenum) ->+    GLint ->+    GLint ->+    GLsizei ->+    GLsizei ->+    IO ( () )+foreign import ccall APIENTRY unsafe "dynamic"+    gldynInvalidateSubFramebuffer :: FunPtr FuntypeInvalidateSubFramebuffer -> FuntypeInvalidateSubFramebuffer+glrefInvalidateSubFramebuffer :: IORef FuntypeInvalidateSubFramebuffer+glrefInvalidateSubFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved."+{-# NOINLINE glrefInvalidateSubFramebuffer #-}+glInvalidateSubFramebuffer :: FuntypeInvalidateSubFramebuffer+glInvalidateSubFramebuffer = unsafePerformIO $ readIORef glrefInvalidateSubFramebuffer+{-# INLINE glInvalidateSubFramebuffer #-}++gl_UNSIGNED_INT_10_10_10_2_EXT :: GLenum+gl_UNSIGNED_INT_10_10_10_2_EXT = 0x8036+gl_ACTIVE_RESOURCES :: GLenum+gl_ACTIVE_RESOURCES = 0x92F5+gl_MAX_GEOMETRY_SHADER_INVOCATIONS :: GLenum+gl_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A+gl_RESTART_PATH_NV :: GLenum+gl_RESTART_PATH_NV = 0xF0+gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV :: GLenum+gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV = 0x90D1+gl_PACK_SKIP_IMAGES :: GLenum+gl_PACK_SKIP_IMAGES = 0x806B+gl_IMAGE_CLASS_2_X_16 :: GLenum+gl_IMAGE_CLASS_2_X_16 = 0x82BD+gl_FRAMEBUFFER_COMPLETE :: GLenum+gl_FRAMEBUFFER_COMPLETE = 0x8CD5+gl_HSL_LUMINOSITY_NV :: GLenum+gl_HSL_LUMINOSITY_NV = 0x92B0+gl_IMAGE_BINDING_LAYERED_EXT :: GLenum+gl_IMAGE_BINDING_LAYERED_EXT = 0x8F3C+gl_ZOOM_Y :: GLenum+gl_ZOOM_Y = 0x0D17+gl_TEXTURE_LUMINANCE_TYPE_ARB :: GLenum+gl_TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14+gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B+gl_TEXTURE_HEIGHT :: GLenum+gl_TEXTURE_HEIGHT = 0x1001+gl_OUTPUT_TEXTURE_COORD0_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD0_EXT = 0x879D+gl_FLOAT_CLEAR_COLOR_VALUE_NV :: GLenum+gl_FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D+gl_LIGHT_MODEL_AMBIENT :: GLenum+gl_LIGHT_MODEL_AMBIENT = 0x0B53+gl_INT16_VEC3_NV :: GLenum+gl_INT16_VEC3_NV = 0x8FE6+gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = 0x8C74+gl_MATRIX6_NV :: GLenum+gl_MATRIX6_NV = 0x8636+gl_COMPUTE_PROGRAM_NV :: GLenum+gl_COMPUTE_PROGRAM_NV = 0x90FB+gl_SCALED_RESOLVE_FASTEST_EXT :: GLenum+gl_SCALED_RESOLVE_FASTEST_EXT = 0x90BA+gl_REPLACEMENT_CODE_ARRAY_SUN :: GLenum+gl_REPLACEMENT_CODE_ARRAY_SUN = 0x85C0+gl_TEXTURE_DT_SIZE_NV :: GLenum+gl_TEXTURE_DT_SIZE_NV = 0x871E+gl_NUM_SPARSE_LEVELS_ARB :: GLenum+gl_NUM_SPARSE_LEVELS_ARB = 0x91AA+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR :: GLenum+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243+gl_NO_ERROR :: GLenum+gl_NO_ERROR = 0+gl_INTERNALFORMAT_ALPHA_TYPE :: GLenum+gl_INTERNALFORMAT_ALPHA_TYPE = 0x827B+gl_FONT_HEIGHT_BIT_NV :: GLenum+gl_FONT_HEIGHT_BIT_NV = 0x00800000+gl_TANGENT_ARRAY_POINTER_EXT :: GLenum+gl_TANGENT_ARRAY_POINTER_EXT = 0x8442+gl_LOCAL_CONSTANT_VALUE_EXT :: GLenum+gl_LOCAL_CONSTANT_VALUE_EXT = 0x87EC+gl_READ_WRITE :: GLenum+gl_READ_WRITE = 0x88BA+gl_TEXTURE_2D :: GLenum+gl_TEXTURE_2D = 0x0DE1+gl_UNSIGNED_INT_2_10_10_10_REV_EXT :: GLenum+gl_UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368+gl_TEXTURE_WRAP_R :: GLenum+gl_TEXTURE_WRAP_R = 0x8072+gl_FLOAT_MAT4x2 :: GLenum+gl_FLOAT_MAT4x2 = 0x8B69+gl_MAX_COMPUTE_WORK_GROUP_SIZE :: GLenum+gl_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF+gl_POLYGON_OFFSET_CLAMP_EXT :: GLenum+gl_POLYGON_OFFSET_CLAMP_EXT = 0x8E1B+gl_SYNC_FLUSH_COMMANDS_BIT :: GLenum+gl_SYNC_FLUSH_COMMANDS_BIT = 0x00000001+gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809+gl_INT_IMAGE_BUFFER :: GLenum+gl_INT_IMAGE_BUFFER = 0x905C+gl_VERTEX_ATTRIB_ARRAY_TYPE :: GLenum+gl_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625+gl_ONE :: GLenum+gl_ONE = 1+gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI :: GLenum+gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835+gl_TRANSLATE_X_NV :: GLenum+gl_TRANSLATE_X_NV = 0x908E+gl_HI_SCALE_NV :: GLenum+gl_HI_SCALE_NV = 0x870E+gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT :: GLenum+gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT = 0x9308+gl_HILO_NV :: GLenum+gl_HILO_NV = 0x86F4+gl_TRIANGLES :: GLenum+gl_TRIANGLES = 0x0004+gl_LINEARLIGHT_NV :: GLenum+gl_LINEARLIGHT_NV = 0x92A7+gl_MAX_3D_TEXTURE_SIZE_OES :: GLenum+gl_MAX_3D_TEXTURE_SIZE_OES = 0x8073+gl_ANY_SAMPLES_PASSED_CONSERVATIVE :: GLenum+gl_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A+gl_UNIFORM_BLOCK_BINDING :: GLenum+gl_UNIFORM_BLOCK_BINDING = 0x8A3F+gl_MAX_TESS_CONTROL_INPUT_COMPONENTS :: GLenum+gl_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C+gl_TEXTURE_ALPHA_TYPE_ARB :: GLenum+gl_TEXTURE_ALPHA_TYPE_ARB = 0x8C13+gl_MAX_CONVOLUTION_HEIGHT :: GLenum+gl_MAX_CONVOLUTION_HEIGHT = 0x801B+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9+gl_DEPTH_BUFFER_BIT5_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT5_QCOM = 0x00002000+gl_PROGRAM_TEX_INDIRECTIONS_ARB :: GLenum+gl_PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807+gl_BLUE :: GLenum+gl_BLUE = 0x1905+gl_RGBA_S3TC :: GLenum+gl_RGBA_S3TC = 0x83A2+gl_DECR :: GLenum+gl_DECR = 0x1E03+gl_MAJOR_VERSION :: GLenum+gl_MAJOR_VERSION = 0x821B+gl_ARRAY_STRIDE :: GLenum+gl_ARRAY_STRIDE = 0x92FE+gl_CONSTANT_COLOR1_NV :: GLenum+gl_CONSTANT_COLOR1_NV = 0x852B+gl_SAMPLES_EXT :: GLenum+gl_SAMPLES_EXT = 0x80A9+gl_MAX_SAMPLES_APPLE :: GLenum+gl_MAX_SAMPLES_APPLE = 0x8D57+gl_COLOR_ARRAY_SIZE :: GLenum+gl_COLOR_ARRAY_SIZE = 0x8081+gl_SAMPLE_ALPHA_TO_MASK_SGIS :: GLenum+gl_SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E+gl_DUP_LAST_CUBIC_CURVE_TO_NV :: GLenum+gl_DUP_LAST_CUBIC_CURVE_TO_NV = 0xF4+gl_TEXTURE10 :: GLenum+gl_TEXTURE10 = 0x84CA+gl_R1UI_T2F_C4F_N3F_V3F_SUN :: GLenum+gl_R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB+gl_MAX_VARYING_COMPONENTS :: GLenum+gl_MAX_VARYING_COMPONENTS = 0x8B4B+gl_DRAW_BUFFER7_EXT :: GLenum+gl_DRAW_BUFFER7_EXT = 0x882C+gl_MAX_COMBINED_ATOMIC_COUNTERS :: GLenum+gl_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7+gl_PROGRAM_ERROR_STRING_ARB :: GLenum+gl_PROGRAM_ERROR_STRING_ARB = 0x8874+gl_TRACE_ALL_BITS_MESA :: GLenum+gl_TRACE_ALL_BITS_MESA = 0xFFFF+gl_DEPTH_CLAMP_NV :: GLenum+gl_DEPTH_CLAMP_NV = 0x864F+gl_REDUCE :: GLenum+gl_REDUCE = 0x8016+gl_UNSIGNED_SHORT_4_4_4_4 :: GLenum+gl_UNSIGNED_SHORT_4_4_4_4 = 0x8033+gl_SKIP_COMPONENTS1_NV :: GLenum+gl_SKIP_COMPONENTS1_NV = -6+gl_PIXEL_TILE_CACHE_INCREMENT_SGIX :: GLenum+gl_PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F+gl_COLOR_ARRAY :: GLenum+gl_COLOR_ARRAY = 0x8076+gl_STATIC_VERTEX_ARRAY_IBM :: GLenum+gl_STATIC_VERTEX_ARRAY_IBM = 103061+gl_INDEX_BIT_PGI :: GLenum+gl_INDEX_BIT_PGI = 0x00080000+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519+gl_ETC1_SRGB8_NV :: GLenum+gl_ETC1_SRGB8_NV = 0x88EE+gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81+gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT :: GLenum+gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 0x00000001+gl_LIGHT_MODEL_COLOR_CONTROL_EXT :: GLenum+gl_LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8+gl_PATCH_DEFAULT_OUTER_LEVEL_EXT :: GLenum+gl_PATCH_DEFAULT_OUTER_LEVEL_EXT = 0x8E74+gl_SAMPLER_CUBE_ARB :: GLenum+gl_SAMPLER_CUBE_ARB = 0x8B60+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT :: GLenum+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1+gl_STORAGE_PRIVATE_APPLE :: GLenum+gl_STORAGE_PRIVATE_APPLE = 0x85BD+gl_MAP1_TEXTURE_COORD_2 :: GLenum+gl_MAP1_TEXTURE_COORD_2 = 0x0D94+gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN :: GLenum+gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2+gl_VERTEX_ATTRIB_ARRAY8_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY8_NV = 0x8658+gl_LUMINANCE16F_ARB :: GLenum+gl_LUMINANCE16F_ARB = 0x881E+gl_DEPTH_COMPONENT32F_NV :: GLenum+gl_DEPTH_COMPONENT32F_NV = 0x8DAB+gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT :: GLenum+gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2+gl_MATRIX28_ARB :: GLenum+gl_MATRIX28_ARB = 0x88DC+gl_SYNC_FLUSH_COMMANDS_BIT_APPLE :: GLenum+gl_SYNC_FLUSH_COMMANDS_BIT_APPLE = 0x00000001+gl_READ_FRAMEBUFFER_BINDING_ANGLE :: GLenum+gl_READ_FRAMEBUFFER_BINDING_ANGLE = 0x8CAA+gl_FOG_COORDINATE_ARRAY_TYPE :: GLenum+gl_FOG_COORDINATE_ARRAY_TYPE = 0x8454+gl_RGBA32UI_EXT :: GLenum+gl_RGBA32UI_EXT = 0x8D70+gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG :: GLenum+gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02+gl_2_BYTES_NV :: GLenum+gl_2_BYTES_NV = 0x1407+gl_TEXTURE_HI_SIZE_NV :: GLenum+gl_TEXTURE_HI_SIZE_NV = 0x871B+gl_PACK_SWAP_BYTES :: GLenum+gl_PACK_SWAP_BYTES = 0x0D00+gl_EVAL_FRACTIONAL_TESSELLATION_NV :: GLenum+gl_EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5+gl_RG16 :: GLenum+gl_RG16 = 0x822C+gl_SWIZZLE_STR_ATI :: GLenum+gl_SWIZZLE_STR_ATI = 0x8976+gl_CON_6_ATI :: GLenum+gl_CON_6_ATI = 0x8947+gl_PATH_FOG_GEN_MODE_NV :: GLenum+gl_PATH_FOG_GEN_MODE_NV = 0x90AC+gl_SRGB8_ALPHA8_EXT :: GLenum+gl_SRGB8_ALPHA8_EXT = 0x8C43+gl_COMPRESSED_SLUMINANCE_ALPHA_EXT :: GLenum+gl_COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B+gl_TEXTURE_COMPARE_FUNC_EXT :: GLenum+gl_TEXTURE_COMPARE_FUNC_EXT = 0x884D+gl_UNIFORM_MATRIX_STRIDE :: GLenum+gl_UNIFORM_MATRIX_STRIDE = 0x8A3D+gl_INVALID_OPERATION :: GLenum+gl_INVALID_OPERATION = 0x0502+gl_DRAW_BUFFER4_ATI :: GLenum+gl_DRAW_BUFFER4_ATI = 0x8829+gl_BYTE :: GLenum+gl_BYTE = 0x1400+gl_SECONDARY_COLOR_ARRAY_POINTER :: GLenum+gl_SECONDARY_COLOR_ARRAY_POINTER = 0x845D+gl_TEXTURE_CUBE_MAP_POSITIVE_X :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515+gl_TEXTURE_2D_ARRAY :: GLenum+gl_TEXTURE_2D_ARRAY = 0x8C1A+gl_OFFSET_TEXTURE_MATRIX_NV :: GLenum+gl_OFFSET_TEXTURE_MATRIX_NV = 0x86E1+gl_FLOAT_MAT2x4 :: GLenum+gl_FLOAT_MAT2x4 = 0x8B66+gl_REG_31_ATI :: GLenum+gl_REG_31_ATI = 0x8940+gl_DEBUG_TYPE_PORTABILITY :: GLenum+gl_DEBUG_TYPE_PORTABILITY = 0x824F+gl_SAMPLER_2D_ARB :: GLenum+gl_SAMPLER_2D_ARB = 0x8B5E+gl_DRAW_BUFFER11 :: GLenum+gl_DRAW_BUFFER11 = 0x8830+gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS :: GLenum+gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB+gl_TEXTURE5_ARB :: GLenum+gl_TEXTURE5_ARB = 0x84C5+gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT :: GLenum+gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT = 0x90D7+gl_COLOR_TABLE_SCALE :: GLenum+gl_COLOR_TABLE_SCALE = 0x80D6+gl_POINT_FADE_THRESHOLD_SIZE_SGIS :: GLenum+gl_POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128+gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB :: GLenum+gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199+gl_ACCUM_CLEAR_VALUE :: GLenum+gl_ACCUM_CLEAR_VALUE = 0x0B80+gl_OPERAND0_ALPHA_EXT :: GLenum+gl_OPERAND0_ALPHA_EXT = 0x8598+gl_QUERY_NO_WAIT :: GLenum+gl_QUERY_NO_WAIT = 0x8E14+gl_PRIMITIVE_RESTART :: GLenum+gl_PRIMITIVE_RESTART = 0x8F9D+gl_STENCIL_ATTACHMENT_OES :: GLenum+gl_STENCIL_ATTACHMENT_OES = 0x8D20+gl_BUFFER_USAGE :: GLenum+gl_BUFFER_USAGE = 0x8765+gl_COLOR_TABLE_BLUE_SIZE :: GLenum+gl_COLOR_TABLE_BLUE_SIZE = 0x80DC+gl_VERTEX_ARRAY_SIZE_EXT :: GLenum+gl_VERTEX_ARRAY_SIZE_EXT = 0x807A+gl_ALPHA8 :: GLenum+gl_ALPHA8 = 0x803C+gl_PROXY_TEXTURE_2D :: GLenum+gl_PROXY_TEXTURE_2D = 0x8064+gl_HALF_BIT_ATI :: GLenum+gl_HALF_BIT_ATI = 0x00000008+gl_TRANSPOSE_MODELVIEW_MATRIX :: GLenum+gl_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3+gl_DRAW_BUFFER3 :: GLenum+gl_DRAW_BUFFER3 = 0x8828+gl_4PASS_2_SGIS :: GLenum+gl_4PASS_2_SGIS = 0x80A6+gl_MAX_GEOMETRY_OUTPUT_COMPONENTS :: GLenum+gl_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124+gl_SAMPLER_2D_ARRAY_SHADOW_EXT :: GLenum+gl_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4+gl_TEXTURE_FORMAT_QCOM :: GLenum+gl_TEXTURE_FORMAT_QCOM = 0x8BD6+gl_RGB16_SNORM :: GLenum+gl_RGB16_SNORM = 0x8F9A+gl_DRAW_BUFFER8_NV :: GLenum+gl_DRAW_BUFFER8_NV = 0x882D+gl_AUX_BUFFERS :: GLenum+gl_AUX_BUFFERS = 0x0C00+gl_CONVOLUTION_HINT_SGIX :: GLenum+gl_CONVOLUTION_HINT_SGIX = 0x8316+gl_FOG_COLOR :: GLenum+gl_FOG_COLOR = 0x0B66+gl_COLOR_TABLE_RED_SIZE_SGI :: GLenum+gl_COLOR_TABLE_RED_SIZE_SGI = 0x80DA+gl_FUNC_SUBTRACT_OES :: GLenum+gl_FUNC_SUBTRACT_OES = 0x800A+gl_LUMINANCE_ALPHA16F_ARB :: GLenum+gl_LUMINANCE_ALPHA16F_ARB = 0x881F+gl_MODELVIEW10_ARB :: GLenum+gl_MODELVIEW10_ARB = 0x872A+gl_LOGIC_OP :: GLenum+gl_LOGIC_OP = 0x0BF1+gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2+gl_SOURCE0_ALPHA_EXT :: GLenum+gl_SOURCE0_ALPHA_EXT = 0x8588+gl_INDEX_SHIFT :: GLenum+gl_INDEX_SHIFT = 0x0D12+gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS :: GLenum+gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354+gl_RG32F_EXT :: GLenum+gl_RG32F_EXT = 0x8230+gl_GEOMETRY_LINKED_VERTICES_OUT_EXT :: GLenum+gl_GEOMETRY_LINKED_VERTICES_OUT_EXT = 0x8916+gl_STACK_UNDERFLOW_KHR :: GLenum+gl_STACK_UNDERFLOW_KHR = 0x0504+gl_TESS_GEN_POINT_MODE_EXT :: GLenum+gl_TESS_GEN_POINT_MODE_EXT = 0x8E79+gl_BUFFER_ACCESS_ARB :: GLenum+gl_BUFFER_ACCESS_ARB = 0x88BB+gl_DOT_PRODUCT_NV :: GLenum+gl_DOT_PRODUCT_NV = 0x86EC+gl_INVERTED_SCREEN_W_REND :: GLenum+gl_INVERTED_SCREEN_W_REND = 0x8491+gl_REG_11_ATI :: GLenum+gl_REG_11_ATI = 0x892C+gl_MAX_FRAMEZOOM_FACTOR_SGIX :: GLenum+gl_MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D+gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD :: GLenum+gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD = 0x00000008+gl_MATRIX20_ARB :: GLenum+gl_MATRIX20_ARB = 0x88D4+gl_EVAL_VERTEX_ATTRIB1_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB1_NV = 0x86C7+gl_COLOR_ATTACHMENT10_NV :: GLenum+gl_COLOR_ATTACHMENT10_NV = 0x8CEA+gl_OUTPUT_TEXTURE_COORD28_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD28_EXT = 0x87B9+gl_MAX_TEXTURE_COORDS_ARB :: GLenum+gl_MAX_TEXTURE_COORDS_ARB = 0x8871+gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum+gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7+gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES :: GLenum+gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39+gl_RENDERBUFFER_BLUE_SIZE :: GLenum+gl_RENDERBUFFER_BLUE_SIZE = 0x8D52+gl_MULTISAMPLE_BIT :: GLenum+gl_MULTISAMPLE_BIT = 0x20000000+gl_CURRENT_PROGRAM :: GLenum+gl_CURRENT_PROGRAM = 0x8B8D+gl_AUX_DEPTH_STENCIL_APPLE :: GLenum+gl_AUX_DEPTH_STENCIL_APPLE = 0x8A14+gl_LUMINANCE8_ALPHA8_EXT :: GLenum+gl_LUMINANCE8_ALPHA8_EXT = 0x8045+gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV :: GLenum+gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 0x903C+gl_INTERLACE_OML :: GLenum+gl_INTERLACE_OML = 0x8980+gl_REG_27_ATI :: GLenum+gl_REG_27_ATI = 0x893C+gl_UNSIGNED_INT_24_8_OES :: GLenum+gl_UNSIGNED_INT_24_8_OES = 0x84FA+gl_COMBINER_AB_OUTPUT_NV :: GLenum+gl_COMBINER_AB_OUTPUT_NV = 0x854A+gl_CURRENT_RASTER_INDEX :: GLenum+gl_CURRENT_RASTER_INDEX = 0x0B05+gl_SYNC_FENCE_APPLE :: GLenum+gl_SYNC_FENCE_APPLE = 0x9116+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3+gl_MAX_TEXTURE_SIZE :: GLenum+gl_MAX_TEXTURE_SIZE = 0x0D33+gl_TEXTURE24 :: GLenum+gl_TEXTURE24 = 0x84D8+gl_STENCIL_BACK_FUNC :: GLenum+gl_STENCIL_BACK_FUNC = 0x8800+gl_LUMINANCE12 :: GLenum+gl_LUMINANCE12 = 0x8041+gl_PARAMETER_BUFFER_ARB :: GLenum+gl_PARAMETER_BUFFER_ARB = 0x80EE+gl_AUX2 :: GLenum+gl_AUX2 = 0x040B+gl_SLICE_ACCUM_SUN :: GLenum+gl_SLICE_ACCUM_SUN = 0x85CC+gl_COLOR_TABLE_ALPHA_SIZE :: GLenum+gl_COLOR_TABLE_ALPHA_SIZE = 0x80DD+gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515+gl_DRAW_FRAMEBUFFER_BINDING_ANGLE :: GLenum+gl_DRAW_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9+gl_SUBTRACT :: GLenum+gl_SUBTRACT = 0x84E7+gl_MAX_PROGRAM_IF_DEPTH_NV :: GLenum+gl_MAX_PROGRAM_IF_DEPTH_NV = 0x88F6+gl_T2F_C4F_N3F_V3F :: GLenum+gl_T2F_C4F_N3F_V3F = 0x2A2C+gl_ACTIVE_SUBROUTINE_UNIFORMS :: GLenum+gl_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6+gl_EMBOSS_LIGHT_NV :: GLenum+gl_EMBOSS_LIGHT_NV = 0x855D+gl_POINT_SIZE_RANGE :: GLenum+gl_POINT_SIZE_RANGE = 0x0B12+gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT :: GLenum+gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT = 0x8918+gl_CLAMP_TO_BORDER :: GLenum+gl_CLAMP_TO_BORDER = 0x812D+gl_TEXTURE_BUFFER_OFFSET_EXT :: GLenum+gl_TEXTURE_BUFFER_OFFSET_EXT = 0x919D+gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV = 0x90FC+gl_COMPRESSED_INTENSITY :: GLenum+gl_COMPRESSED_INTENSITY = 0x84EC+gl_MAX_PROGRAM_OUTPUT_VERTICES_NV :: GLenum+gl_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES = 0x93E6+gl_MAX_PROGRAM_ATTRIBS_ARB :: GLenum+gl_MAX_PROGRAM_ATTRIBS_ARB = 0x88AD+gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI :: GLenum+gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5+gl_TEXTURE_3D_BINDING_EXT :: GLenum+gl_TEXTURE_3D_BINDING_EXT = 0x806A+gl_SHADER_STORAGE_BUFFER_START :: GLenum+gl_SHADER_STORAGE_BUFFER_START = 0x90D4+gl_MAP2_INDEX :: GLenum+gl_MAP2_INDEX = 0x0DB1+gl_CONSTANT_COLOR_EXT :: GLenum+gl_CONSTANT_COLOR_EXT = 0x8001+gl_RG32UI :: GLenum+gl_RG32UI = 0x823C+gl_BGRA :: GLenum+gl_BGRA = 0x80E1+gl_FRAGMENT_DEPTH_EXT :: GLenum+gl_FRAGMENT_DEPTH_EXT = 0x8452+gl_GENERATE_MIPMAP_HINT_SGIS :: GLenum+gl_GENERATE_MIPMAP_HINT_SGIS = 0x8192+gl_DIFFERENCE_NV :: GLenum+gl_DIFFERENCE_NV = 0x929E+gl_UNSIGNED_SHORT_1_15_REV_MESA :: GLenum+gl_UNSIGNED_SHORT_1_15_REV_MESA = 0x8754+gl_PROGRAM_BINARY_RETRIEVABLE_HINT :: GLenum+gl_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257+gl_RGBA32I :: GLenum+gl_RGBA32I = 0x8D82+gl_UNSIGNED_INT_8_8_8_8 :: GLenum+gl_UNSIGNED_INT_8_8_8_8 = 0x8035+gl_DOMAIN :: GLenum+gl_DOMAIN = 0x0A02+gl_COLOR_MATRIX :: GLenum+gl_COLOR_MATRIX = 0x80B1+gl_PROGRAM_NATIVE_ATTRIBS_ARB :: GLenum+gl_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE+gl_OP_ROUND_EXT :: GLenum+gl_OP_ROUND_EXT = 0x8790+gl_VIEW_CLASS_96_BITS :: GLenum+gl_VIEW_CLASS_96_BITS = 0x82C5+gl_TEXTURE_WRAP_R_OES :: GLenum+gl_TEXTURE_WRAP_R_OES = 0x8072+gl_VERTEX_ARRAY_TYPE :: GLenum+gl_VERTEX_ARRAY_TYPE = 0x807B+gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV :: GLenum+gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 0x902D+gl_PIXEL_MAP_R_TO_R_SIZE :: GLenum+gl_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6+gl_UNSIGNED_NORMALIZED_ARB :: GLenum+gl_UNSIGNED_NORMALIZED_ARB = 0x8C17+gl_UNSIGNED_INT8_VEC3_NV :: GLenum+gl_UNSIGNED_INT8_VEC3_NV = 0x8FEE+gl_COMPRESSED_RGBA8_ETC2_EAC_OES :: GLenum+gl_COMPRESSED_RGBA8_ETC2_EAC_OES = 0x9278+gl_HI_BIAS_NV :: GLenum+gl_HI_BIAS_NV = 0x8714+gl_SECONDARY_COLOR_ARRAY_EXT :: GLenum+gl_SECONDARY_COLOR_ARRAY_EXT = 0x845E+gl_BUFFER_MAP_OFFSET :: GLenum+gl_BUFFER_MAP_OFFSET = 0x9121+gl_LUMINANCE4_ALPHA4_OES :: GLenum+gl_LUMINANCE4_ALPHA4_OES = 0x8043+gl_FORMAT_SUBSAMPLE_244_244_OML :: GLenum+gl_FORMAT_SUBSAMPLE_244_244_OML = 0x8983+gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA :: GLenum+gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB2+gl_PLUS_CLAMPED_ALPHA_NV :: GLenum+gl_PLUS_CLAMPED_ALPHA_NV = 0x92B2+gl_COLOR_ATTACHMENT0_NV :: GLenum+gl_COLOR_ATTACHMENT0_NV = 0x8CE0+gl_COMPRESSED_RGB_S3TC_DXT1_EXT :: GLenum+gl_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0+gl_GEOMETRY_OUTPUT_TYPE :: GLenum+gl_GEOMETRY_OUTPUT_TYPE = 0x8918+gl_INTENSITY8_EXT :: GLenum+gl_INTENSITY8_EXT = 0x804B+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517+gl_COMPRESSED_RED_GREEN_RGTC2_EXT :: GLenum+gl_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD+gl_DEBUG_SOURCE_API_KHR :: GLenum+gl_DEBUG_SOURCE_API_KHR = 0x8246+gl_BLEND_PREMULTIPLIED_SRC_NV :: GLenum+gl_BLEND_PREMULTIPLIED_SRC_NV = 0x9280+gl_CLIENT_STORAGE_BIT :: GLenum+gl_CLIENT_STORAGE_BIT = 0x0200+gl_INTENSITY12_EXT :: GLenum+gl_INTENSITY12_EXT = 0x804C+gl_MATRIX_INDEX_ARRAY_STRIDE_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_STRIDE_OES = 0x8848+gl_CURRENT_RASTER_SECONDARY_COLOR :: GLenum+gl_CURRENT_RASTER_SECONDARY_COLOR = 0x845F+gl_REPLACE :: GLenum+gl_REPLACE = 0x1E01+gl_LINEAR :: GLenum+gl_LINEAR = 0x2601+gl_COMBINER_INPUT_NV :: GLenum+gl_COMBINER_INPUT_NV = 0x8542+gl_TRANSFORM_FEEDBACK_VARYINGS :: GLenum+gl_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES = 0x93E2+gl_IMAGE_BINDING_ACCESS :: GLenum+gl_IMAGE_BINDING_ACCESS = 0x8F3E+gl_NUM_LOOPBACK_COMPONENTS_ATI :: GLenum+gl_NUM_LOOPBACK_COMPONENTS_ATI = 0x8974+gl_ARRAY_ELEMENT_LOCK_COUNT_EXT :: GLenum+gl_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9+gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN :: GLenum+gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3+gl_TEXTURE_4DSIZE_SGIS :: GLenum+gl_TEXTURE_4DSIZE_SGIS = 0x8136+gl_COUNTER_RANGE_AMD :: GLenum+gl_COUNTER_RANGE_AMD = 0x8BC1+gl_RGB8_OES :: GLenum+gl_RGB8_OES = 0x8051+gl_ALPHA16F_EXT :: GLenum+gl_ALPHA16F_EXT = 0x881C+gl_C4F_N3F_V3F :: GLenum+gl_C4F_N3F_V3F = 0x2A26+gl_NEAREST_MIPMAP_LINEAR :: GLenum+gl_NEAREST_MIPMAP_LINEAR = 0x2702+gl_DEBUG_SEVERITY_LOW_KHR :: GLenum+gl_DEBUG_SEVERITY_LOW_KHR = 0x9148+gl_DISCARD_ATI :: GLenum+gl_DISCARD_ATI = 0x8763+gl_LOCAL_CONSTANT_DATATYPE_EXT :: GLenum+gl_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED+gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT :: GLenum+gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT = 0x9123+gl_LOWER_LEFT :: GLenum+gl_LOWER_LEFT = 0x8CA1+gl_RENDERBUFFER_HEIGHT_OES :: GLenum+gl_RENDERBUFFER_HEIGHT_OES = 0x8D43+gl_SPRITE_MODE_SGIX :: GLenum+gl_SPRITE_MODE_SGIX = 0x8149+gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN :: GLenum+gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1+gl_UNSIGNED_INT8_VEC2_NV :: GLenum+gl_UNSIGNED_INT8_VEC2_NV = 0x8FED+gl_NONE_OES :: GLenum+gl_NONE_OES = 0+gl_POINT_SIZE_MIN_ARB :: GLenum+gl_POINT_SIZE_MIN_ARB = 0x8126+gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV :: GLenum+gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = 0x8E5D+gl_RENDERBUFFER_DEPTH_SIZE_EXT :: GLenum+gl_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54+gl_BUFFER_MAP_LENGTH :: GLenum+gl_BUFFER_MAP_LENGTH = 0x9120+gl_WRITE_ONLY :: GLenum+gl_WRITE_ONLY = 0x88B9+gl_NEAREST_CLIPMAP_NEAREST_SGIX :: GLenum+gl_NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D+gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV :: GLenum+gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10+gl_ALREADY_SIGNALED_APPLE :: GLenum+gl_ALREADY_SIGNALED_APPLE = 0x911A+gl_REPLICATE_BORDER :: GLenum+gl_REPLICATE_BORDER = 0x8153+gl_SUBPIXEL_BITS :: GLenum+gl_SUBPIXEL_BITS = 0x0D50+gl_ALPHA_MIN_SGIX :: GLenum+gl_ALPHA_MIN_SGIX = 0x8320+gl_BLUE_BIT_ATI :: GLenum+gl_BLUE_BIT_ATI = 0x00000004+gl_UNSIGNED_INT_IMAGE_2D_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_EXT = 0x9063+gl_TRANSFORM_FEEDBACK_VARYINGS_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_VARYINGS_EXT = 0x8C83+gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT :: GLenum+gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73+gl_PIXEL_COUNTER_BITS_NV :: GLenum+gl_PIXEL_COUNTER_BITS_NV = 0x8864+gl_422_REV_AVERAGE_EXT :: GLenum+gl_422_REV_AVERAGE_EXT = 0x80CF+gl_TEXTURE_RESIDENT_EXT :: GLenum+gl_TEXTURE_RESIDENT_EXT = 0x8067+gl_STENCIL_WRITEMASK :: GLenum+gl_STENCIL_WRITEMASK = 0x0B98+gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: GLenum+gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43+gl_FLOAT_VEC3_ARB :: GLenum+gl_FLOAT_VEC3_ARB = 0x8B51+gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM :: GLenum+gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D+gl_DYNAMIC_STORAGE_BIT :: GLenum+gl_DYNAMIC_STORAGE_BIT = 0x0100+gl_DRAW_FRAMEBUFFER_BINDING_APPLE :: GLenum+gl_DRAW_FRAMEBUFFER_BINDING_APPLE = 0x8CA6+gl_CLIP_PLANE4_IMG :: GLenum+gl_CLIP_PLANE4_IMG = 0x3004+gl_CON_26_ATI :: GLenum+gl_CON_26_ATI = 0x895B+gl_COMPRESSED_SIGNED_R11_EAC_OES :: GLenum+gl_COMPRESSED_SIGNED_R11_EAC_OES = 0x9271+gl_LINES_ADJACENCY_EXT :: GLenum+gl_LINES_ADJACENCY_EXT = 0x000A+gl_AUTO_GENERATE_MIPMAP :: GLenum+gl_AUTO_GENERATE_MIPMAP = 0x8295+gl_OP_EXP_BASE_2_EXT :: GLenum+gl_OP_EXP_BASE_2_EXT = 0x8791+gl_ATTRIB_STACK_DEPTH :: GLenum+gl_ATTRIB_STACK_DEPTH = 0x0BB0+gl_ALPHA32F_EXT :: GLenum+gl_ALPHA32F_EXT = 0x8816+gl_KEEP :: GLenum+gl_KEEP = 0x1E00+gl_TEXTURE_FILTER4_SIZE_SGIS :: GLenum+gl_TEXTURE_FILTER4_SIZE_SGIS = 0x8147+gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A+gl_INT_VEC3 :: GLenum+gl_INT_VEC3 = 0x8B54+gl_MATRIX_MODE :: GLenum+gl_MATRIX_MODE = 0x0BA0+gl_UNSIGNED_NORMALIZED :: GLenum+gl_UNSIGNED_NORMALIZED = 0x8C17+gl_DEBUG_PRINT_MESA :: GLenum+gl_DEBUG_PRINT_MESA = 0x875A+gl_DST_OUT_NV :: GLenum+gl_DST_OUT_NV = 0x928D+gl_CLEAR_BUFFER :: GLenum+gl_CLEAR_BUFFER = 0x82B4+gl_COMBINER_SCALE_NV :: GLenum+gl_COMBINER_SCALE_NV = 0x8548+gl_WRITE_ONLY_OES :: GLenum+gl_WRITE_ONLY_OES = 0x88B9+gl_422_AVERAGE_EXT :: GLenum+gl_422_AVERAGE_EXT = 0x80CE+gl_COLOR_INDEX12_EXT :: GLenum+gl_COLOR_INDEX12_EXT = 0x80E6+gl_COLOR_BUFFER_BIT0_QCOM :: GLenum+gl_COLOR_BUFFER_BIT0_QCOM = 0x00000001+gl_CAVEAT_SUPPORT :: GLenum+gl_CAVEAT_SUPPORT = 0x82B8+gl_BLUE_INTEGER :: GLenum+gl_BLUE_INTEGER = 0x8D96+gl_IUI_N3F_V2F_EXT :: GLenum+gl_IUI_N3F_V2F_EXT = 0x81AF+gl_VERTEX_DATA_HINT_PGI :: GLenum+gl_VERTEX_DATA_HINT_PGI = 0x1A22A+gl_REG_13_ATI :: GLenum+gl_REG_13_ATI = 0x892E+gl_NEGATIVE_ONE_EXT :: GLenum+gl_NEGATIVE_ONE_EXT = 0x87DF+gl_CON_16_ATI :: GLenum+gl_CON_16_ATI = 0x8951+gl_TEXTURE_EXTERNAL_OES :: GLenum+gl_TEXTURE_EXTERNAL_OES = 0x8D65+gl_SHADER_TYPE :: GLenum+gl_SHADER_TYPE = 0x8B4F+gl_OVERLAY_KHR :: GLenum+gl_OVERLAY_KHR = 0x9296+gl_LUMINANCE6_ALPHA2_EXT :: GLenum+gl_LUMINANCE6_ALPHA2_EXT = 0x8044+gl_COLOR_TABLE_SGI :: GLenum+gl_COLOR_TABLE_SGI = 0x80D0+gl_TEXTURE_STENCIL_SIZE_EXT :: GLenum+gl_TEXTURE_STENCIL_SIZE_EXT = 0x88F1+gl_NEAREST :: GLenum+gl_NEAREST = 0x2600+gl_RGB8I :: GLenum+gl_RGB8I = 0x8D8F+gl_TEXTURE_SPARSE_ARB :: GLenum+gl_TEXTURE_SPARSE_ARB = 0x91A6+gl_MATRIX9_ARB :: GLenum+gl_MATRIX9_ARB = 0x88C9+gl_TEXTURE_TARGET :: GLenum+gl_TEXTURE_TARGET = 0x1006+gl_SECONDARY_COLOR_ARRAY_TYPE_EXT :: GLenum+gl_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B+gl_RENDERER :: GLenum+gl_RENDERER = 0x1F01+gl_TEXTURE_BINDING_BUFFER :: GLenum+gl_TEXTURE_BINDING_BUFFER = 0x8C2C+gl_INT_VEC3_ARB :: GLenum+gl_INT_VEC3_ARB = 0x8B54+gl_MATRIX12_ARB :: GLenum+gl_MATRIX12_ARB = 0x88CC+gl_VERTEX_ATTRIB_ARRAY_ENABLED :: GLenum+gl_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622+gl_RENDERBUFFER_SAMPLES_NV :: GLenum+gl_RENDERBUFFER_SAMPLES_NV = 0x8CAB+gl_COLOR_ATTACHMENT1_EXT :: GLenum+gl_COLOR_ATTACHMENT1_EXT = 0x8CE1+gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211+gl_LINEAR_DETAIL_SGIS :: GLenum+gl_LINEAR_DETAIL_SGIS = 0x8097+gl_CURRENT_RASTER_POSITION_VALID :: GLenum+gl_CURRENT_RASTER_POSITION_VALID = 0x0B08+gl_LINEAR_DETAIL_COLOR_SGIS :: GLenum+gl_LINEAR_DETAIL_COLOR_SGIS = 0x8099+gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT :: GLenum+gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT = 0x8A54+gl_POINT_SIZE_MIN_EXT :: GLenum+gl_POINT_SIZE_MIN_EXT = 0x8126+gl_GPU_DISJOINT_EXT :: GLenum+gl_GPU_DISJOINT_EXT = 0x8FBB+gl_LIGHT_MODEL_COLOR_CONTROL :: GLenum+gl_LIGHT_MODEL_COLOR_CONTROL = 0x81F8+gl_MAX_TESS_PATCH_COMPONENTS :: GLenum+gl_MAX_TESS_PATCH_COMPONENTS = 0x8E84+gl_CURRENT_PALETTE_MATRIX_OES :: GLenum+gl_CURRENT_PALETTE_MATRIX_OES = 0x8843+gl_SAMPLES_SGIS :: GLenum+gl_SAMPLES_SGIS = 0x80A9+gl_FUNC_REVERSE_SUBTRACT_OES :: GLenum+gl_FUNC_REVERSE_SUBTRACT_OES = 0x800B+gl_TEXTURE13_ARB :: GLenum+gl_TEXTURE13_ARB = 0x84CD+gl_SMOOTH_CUBIC_CURVE_TO_NV :: GLenum+gl_SMOOTH_CUBIC_CURVE_TO_NV = 0x10+gl_COMPRESSED_RGBA_ASTC_3x3x3_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_3x3x3_OES = 0x93C0+gl_MODELVIEW15_ARB :: GLenum+gl_MODELVIEW15_ARB = 0x872F+gl_EYE_PLANE_ABSOLUTE_NV :: GLenum+gl_EYE_PLANE_ABSOLUTE_NV = 0x855C+gl_READ_FRAMEBUFFER_BINDING_NV :: GLenum+gl_READ_FRAMEBUFFER_BINDING_NV = 0x8CAA+gl_RENDERBUFFER_RED_SIZE :: GLenum+gl_RENDERBUFFER_RED_SIZE = 0x8D50+gl_PIXEL_PACK_BUFFER_BINDING_EXT :: GLenum+gl_PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED+gl_MAX_RENDERBUFFER_SIZE :: GLenum+gl_MAX_RENDERBUFFER_SIZE = 0x84E8+gl_DOUBLE_MAT4_EXT :: GLenum+gl_DOUBLE_MAT4_EXT = 0x8F48+gl_COMPRESSED_R11_EAC :: GLenum+gl_COMPRESSED_R11_EAC = 0x9270+gl_INT_IMAGE_2D_RECT :: GLenum+gl_INT_IMAGE_2D_RECT = 0x905A+gl_MAD_ATI :: GLenum+gl_MAD_ATI = 0x8968+gl_IMAGE_CLASS_4_X_32 :: GLenum+gl_IMAGE_CLASS_4_X_32 = 0x82B9+gl_VIDEO_COLOR_CONVERSION_OFFSET_NV :: GLenum+gl_VIDEO_COLOR_CONVERSION_OFFSET_NV = 0x902C+gl_BOOL_VEC4 :: GLenum+gl_BOOL_VEC4 = 0x8B59+gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D+gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES :: GLenum+gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = 0x8E5D+gl_HISTOGRAM_FORMAT_EXT :: GLenum+gl_HISTOGRAM_FORMAT_EXT = 0x8027+gl_UNSIGNED_INT_8_8_8_8_REV_EXT :: GLenum+gl_UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367+gl_R1UI_C3F_V3F_SUN :: GLenum+gl_R1UI_C3F_V3F_SUN = 0x85C6+gl_SAMPLER_1D_ARRAY_SHADOW_EXT :: GLenum+gl_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3+gl_TEXTURE_BINDING_2D_ARRAY :: GLenum+gl_TEXTURE_BINDING_2D_ARRAY = 0x8C1D+gl_TEXTURE_RANGE_POINTER_APPLE :: GLenum+gl_TEXTURE_RANGE_POINTER_APPLE = 0x85B8+gl_SMALL_CCW_ARC_TO_NV :: GLenum+gl_SMALL_CCW_ARC_TO_NV = 0x12+gl_SHADER_COMPILER :: GLenum+gl_SHADER_COMPILER = 0x8DFA+gl_DEPTH_COMPONENT24_ARB :: GLenum+gl_DEPTH_COMPONENT24_ARB = 0x81A6+gl_COLOR_ATTACHMENT14_NV :: GLenum+gl_COLOR_ATTACHMENT14_NV = 0x8CEE+gl_TIME_ELAPSED :: GLenum+gl_TIME_ELAPSED = 0x88BF+gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT :: GLenum+gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT = 0x9312+gl_MATRIX11_ARB :: GLenum+gl_MATRIX11_ARB = 0x88CB+gl_XOR :: GLenum+gl_XOR = 0x1506+gl_HSL_SATURATION_KHR :: GLenum+gl_HSL_SATURATION_KHR = 0x92AE+gl_R1UI_T2F_V3F_SUN :: GLenum+gl_R1UI_T2F_V3F_SUN = 0x85C9+gl_COMPUTE_WORK_GROUP_SIZE :: GLenum+gl_COMPUTE_WORK_GROUP_SIZE = 0x8267+gl_BLEND_EQUATION_EXT :: GLenum+gl_BLEND_EQUATION_EXT = 0x8009+gl_SAMPLER :: GLenum+gl_SAMPLER = 0x82E6+gl_NUM_FRAGMENT_REGISTERS_ATI :: GLenum+gl_NUM_FRAGMENT_REGISTERS_ATI = 0x896E+gl_REG_5_ATI :: GLenum+gl_REG_5_ATI = 0x8926+gl_DSDT8_MAG8_INTENSITY8_NV :: GLenum+gl_DSDT8_MAG8_INTENSITY8_NV = 0x870B+gl_PIXEL_MAP_S_TO_S_SIZE :: GLenum+gl_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7+gl_OR_REVERSE :: GLenum+gl_OR_REVERSE = 0x150B+gl_QUERY_BUFFER_BARRIER_BIT :: GLenum+gl_QUERY_BUFFER_BARRIER_BIT = 0x00008000+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F+gl_SAMPLER_1D :: GLenum+gl_SAMPLER_1D = 0x8B5D+gl_COLOR_TABLE_INTENSITY_SIZE :: GLenum+gl_COLOR_TABLE_INTENSITY_SIZE = 0x80DF+gl_TRIANGLE_FAN :: GLenum+gl_TRIANGLE_FAN = 0x0006+gl_POINT_SIZE_MAX_SGIS :: GLenum+gl_POINT_SIZE_MAX_SGIS = 0x8127+gl_ELEMENT_ARRAY_POINTER_ATI :: GLenum+gl_ELEMENT_ARRAY_POINTER_ATI = 0x876A+gl_INT_IMAGE_1D_EXT :: GLenum+gl_INT_IMAGE_1D_EXT = 0x9057+gl_CONVOLUTION_FILTER_SCALE_EXT :: GLenum+gl_CONVOLUTION_FILTER_SCALE_EXT = 0x8014+gl_EVAL_VERTEX_ATTRIB8_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB8_NV = 0x86CE+gl_DYNAMIC_COPY_ARB :: GLenum+gl_DYNAMIC_COPY_ARB = 0x88EA+gl_REG_12_ATI :: GLenum+gl_REG_12_ATI = 0x892D+gl_SIGNED_NORMALIZED :: GLenum+gl_SIGNED_NORMALIZED = 0x8F9C+gl_REG_8_ATI :: GLenum+gl_REG_8_ATI = 0x8929+gl_SAMPLE_COVERAGE_ARB :: GLenum+gl_SAMPLE_COVERAGE_ARB = 0x80A0+gl_ALLOW_DRAW_MEM_HINT_PGI :: GLenum+gl_ALLOW_DRAW_MEM_HINT_PGI = 0x1A211+gl_INTENSITY16F_ARB :: GLenum+gl_INTENSITY16F_ARB = 0x881D+gl_PATH_FORMAT_PS_NV :: GLenum+gl_PATH_FORMAT_PS_NV = 0x9071+gl_TEXTURE_FREE_MEMORY_ATI :: GLenum+gl_TEXTURE_FREE_MEMORY_ATI = 0x87FC+gl_SYNC_FENCE :: GLenum+gl_SYNC_FENCE = 0x9116+gl_WRITE_ONLY_ARB :: GLenum+gl_WRITE_ONLY_ARB = 0x88B9+gl_INVERT :: GLenum+gl_INVERT = 0x150A+gl_TRANSLATE_Y_NV :: GLenum+gl_TRANSLATE_Y_NV = 0x908F+gl_SAMPLER_3D :: GLenum+gl_SAMPLER_3D = 0x8B5F+gl_LINE_STRIP_ADJACENCY :: GLenum+gl_LINE_STRIP_ADJACENCY = 0x000B+gl_OPERAND2_RGB_EXT :: GLenum+gl_OPERAND2_RGB_EXT = 0x8592+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG = 0x9134+gl_COLOR_ARRAY_ADDRESS_NV :: GLenum+gl_COLOR_ARRAY_ADDRESS_NV = 0x8F23+gl_POST_CONVOLUTION_BLUE_SCALE_EXT :: GLenum+gl_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E+gl_HIGH_FLOAT :: GLenum+gl_HIGH_FLOAT = 0x8DF2+gl_TESS_GEN_MODE_EXT :: GLenum+gl_TESS_GEN_MODE_EXT = 0x8E76+gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV :: GLenum+gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E+gl_MAX_LABEL_LENGTH :: GLenum+gl_MAX_LABEL_LENGTH = 0x82E8+gl_QUERY_BY_REGION_NO_WAIT :: GLenum+gl_QUERY_BY_REGION_NO_WAIT = 0x8E16+gl_OP_RECIP_EXT :: GLenum+gl_OP_RECIP_EXT = 0x8794+gl_PROXY_TEXTURE_2D_ARRAY :: GLenum+gl_PROXY_TEXTURE_2D_ARRAY = 0x8C1B+gl_COMPRESSED_RGBA_FXT1_3DFX :: GLenum+gl_COMPRESSED_RGBA_FXT1_3DFX = 0x86B1+gl_PRIMITIVES_GENERATED :: GLenum+gl_PRIMITIVES_GENERATED = 0x8C87+gl_TEXTURE26_ARB :: GLenum+gl_TEXTURE26_ARB = 0x84DA+gl_TESS_EVALUATION_TEXTURE :: GLenum+gl_TESS_EVALUATION_TEXTURE = 0x829D+gl_TEXTURE1 :: GLenum+gl_TEXTURE1 = 0x84C1+gl_TRANSFORM_FEEDBACK_RECORD_NV :: GLenum+gl_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86+gl_DRAW_FRAMEBUFFER_NV :: GLenum+gl_DRAW_FRAMEBUFFER_NV = 0x8CA9+gl_MODELVIEW8_ARB :: GLenum+gl_MODELVIEW8_ARB = 0x8728+gl_UNSIGNED_INT_SAMPLER_BUFFER :: GLenum+gl_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8+gl_CONVOLUTION_1D :: GLenum+gl_CONVOLUTION_1D = 0x8010+gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23+gl_SAMPLER_1D_ARRAY :: GLenum+gl_SAMPLER_1D_ARRAY = 0x8DC0+gl_TRANSFORM_FEEDBACK_BINDING :: GLenum+gl_TRANSFORM_FEEDBACK_BINDING = 0x8E25+gl_LIGHTING_BIT :: GLenum+gl_LIGHTING_BIT = 0x00000040+gl_R1UI_C4F_N3F_V3F_SUN :: GLenum+gl_R1UI_C4F_N3F_V3F_SUN = 0x85C8+gl_TEXTURE_RED_SIZE_EXT :: GLenum+gl_TEXTURE_RED_SIZE_EXT = 0x805C+gl_VERTEX_ARRAY_KHR :: GLenum+gl_VERTEX_ARRAY_KHR = 0x8074+gl_ALPHA_BITS :: GLenum+gl_ALPHA_BITS = 0x0D55+gl_MAX_VERTEX_SHADER_INVARIANTS_EXT :: GLenum+gl_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7+gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31+gl_SAMPLE_MASK_INVERT_EXT :: GLenum+gl_SAMPLE_MASK_INVERT_EXT = 0x80AB+gl_TRANSPOSE_PROGRAM_MATRIX_EXT :: GLenum+gl_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E+gl_ABGR_EXT :: GLenum+gl_ABGR_EXT = 0x8000+gl_MULTISAMPLE_BIT_3DFX :: GLenum+gl_MULTISAMPLE_BIT_3DFX = 0x20000000+gl_MATRIX0_NV :: GLenum+gl_MATRIX0_NV = 0x8630+gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210+gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG :: GLenum+gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG = 0x93F0+gl_RGB9_E5 :: GLenum+gl_RGB9_E5 = 0x8C3D+gl_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum+gl_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056+gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F+gl_GEOMETRY_PROGRAM_NV :: GLenum+gl_GEOMETRY_PROGRAM_NV = 0x8C26+gl_RGB10_EXT :: GLenum+gl_RGB10_EXT = 0x8052+gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT :: GLenum+gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F+gl_ALWAYS_SOFT_HINT_PGI :: GLenum+gl_ALWAYS_SOFT_HINT_PGI = 0x1A20D+gl_WEIGHT_ARRAY_BUFFER_BINDING :: GLenum+gl_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E+gl_BLEND_DST_ALPHA_OES :: GLenum+gl_BLEND_DST_ALPHA_OES = 0x80CA+gl_UNIFORM_BUFFER_BINDING_EXT :: GLenum+gl_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF+gl_CONTINUOUS_AMD :: GLenum+gl_CONTINUOUS_AMD = 0x9007+gl_STENCIL_BUFFER_BIT4_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT4_QCOM = 0x00100000+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV :: GLenum+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88+gl_TESS_EVALUATION_SHADER_BIT :: GLenum+gl_TESS_EVALUATION_SHADER_BIT = 0x00000010+gl_TEXTURE_COORD_ARRAY_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_EXT = 0x8078+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET :: GLenum+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F+gl_PROGRAM_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_INSTRUCTIONS_ARB = 0x88A0+gl_PROXY_TEXTURE_3D :: GLenum+gl_PROXY_TEXTURE_3D = 0x8070+gl_CLIP_PLANE0 :: GLenum+gl_CLIP_PLANE0 = 0x3000+gl_CURRENT_QUERY_EXT :: GLenum+gl_CURRENT_QUERY_EXT = 0x8865+gl_T4F_C4F_N3F_V4F :: GLenum+gl_T4F_C4F_N3F_V4F = 0x2A2D+gl_ADD :: GLenum+gl_ADD = 0x0104+gl_STENCIL_EXT :: GLenum+gl_STENCIL_EXT = 0x1802+gl_TEXTURE_BLUE_TYPE :: GLenum+gl_TEXTURE_BLUE_TYPE = 0x8C12+gl_OUTPUT_TEXTURE_COORD8_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD8_EXT = 0x87A5+gl_OBJECT_TYPE_ARB :: GLenum+gl_OBJECT_TYPE_ARB = 0x8B4E+gl_RESET_NOTIFICATION_STRATEGY :: GLenum+gl_RESET_NOTIFICATION_STRATEGY = 0x8256+gl_UNSIGNED_INT_VEC2_EXT :: GLenum+gl_UNSIGNED_INT_VEC2_EXT = 0x8DC6+gl_DRAW_BUFFER6_NV :: GLenum+gl_DRAW_BUFFER6_NV = 0x882B+gl_ASYNC_DRAW_PIXELS_SGIX :: GLenum+gl_ASYNC_DRAW_PIXELS_SGIX = 0x835D+gl_INTERNALFORMAT_GREEN_SIZE :: GLenum+gl_INTERNALFORMAT_GREEN_SIZE = 0x8272+gl_TEXTURE_GREEN_SIZE :: GLenum+gl_TEXTURE_GREEN_SIZE = 0x805D+gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL :: GLenum+gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE+gl_VIRTUAL_PAGE_SIZE_Y_AMD :: GLenum+gl_VIRTUAL_PAGE_SIZE_Y_AMD = 0x9196+gl_OP_MUL_EXT :: GLenum+gl_OP_MUL_EXT = 0x8786+gl_NORMAL_MAP :: GLenum+gl_NORMAL_MAP = 0x8511+gl_ALPHA16_EXT :: GLenum+gl_ALPHA16_EXT = 0x803E+gl_POINT_SIZE :: GLenum+gl_POINT_SIZE = 0x0B11+gl_INTERNALFORMAT_SUPPORTED :: GLenum+gl_INTERNALFORMAT_SUPPORTED = 0x826F+gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7+gl_DEBUG_SEVERITY_HIGH_ARB :: GLenum+gl_DEBUG_SEVERITY_HIGH_ARB = 0x9146+gl_TEXTURE_MAX_LEVEL_SGIS :: GLenum+gl_TEXTURE_MAX_LEVEL_SGIS = 0x813D+gl_SHADING_LANGUAGE_VERSION_ARB :: GLenum+gl_SHADING_LANGUAGE_VERSION_ARB = 0x8B8C+gl_STANDARD_FONT_FORMAT_NV :: GLenum+gl_STANDARD_FONT_FORMAT_NV = 0x936C+gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT :: GLenum+gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D+gl_IR_INSTRUMENT1_SGIX :: GLenum+gl_IR_INSTRUMENT1_SGIX = 0x817F+gl_SIGNED_HILO8_NV :: GLenum+gl_SIGNED_HILO8_NV = 0x885F+gl_RENDERBUFFER_GREEN_SIZE_OES :: GLenum+gl_RENDERBUFFER_GREEN_SIZE_OES = 0x8D51+gl_REG_1_ATI :: GLenum+gl_REG_1_ATI = 0x8922+gl_CLAMP_TO_EDGE :: GLenum+gl_CLAMP_TO_EDGE = 0x812F+gl_GEOMETRY_SHADER_BIT :: GLenum+gl_GEOMETRY_SHADER_BIT = 0x00000004+gl_MODELVIEW7_ARB :: GLenum+gl_MODELVIEW7_ARB = 0x8727+gl_BUFFER_MAPPED_ARB :: GLenum+gl_BUFFER_MAPPED_ARB = 0x88BC+gl_DRAW_BUFFER12_EXT :: GLenum+gl_DRAW_BUFFER12_EXT = 0x8831+gl_RGB565_OES :: GLenum+gl_RGB565_OES = 0x8D62+gl_SHORT :: GLenum+gl_SHORT = 0x1402+gl_STENCIL_BACK_FAIL_ATI :: GLenum+gl_STENCIL_BACK_FAIL_ATI = 0x8801+gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 0x9065+gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV :: GLenum+gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0x0D38+gl_CON_31_ATI :: GLenum+gl_CON_31_ATI = 0x8960+gl_RGB5 :: GLenum+gl_RGB5 = 0x8050+gl_SAMPLER_2D_RECT :: GLenum+gl_SAMPLER_2D_RECT = 0x8B63+gl_COMPRESSED_RGBA_ASTC_5x4x4_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_5x4x4_OES = 0x93C4+gl_PASS_THROUGH_TOKEN :: GLenum+gl_PASS_THROUGH_TOKEN = 0x0700+gl_RGBA_FLOAT32_ATI :: GLenum+gl_RGBA_FLOAT32_ATI = 0x8814+gl_TEXTURE_COLOR_WRITEMASK_SGIS :: GLenum+gl_TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF+gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F+gl_OUTPUT_TEXTURE_COORD23_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD23_EXT = 0x87B4+gl_YCBYCR8_422_NV :: GLenum+gl_YCBYCR8_422_NV = 0x9031+gl_SRC_NV :: GLenum+gl_SRC_NV = 0x9286+gl_MAX_EXT :: GLenum+gl_MAX_EXT = 0x8008+gl_UNPACK_COMPRESSED_BLOCK_DEPTH :: GLenum+gl_UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129+gl_UNSIGNED_SHORT_5_5_5_1_EXT :: GLenum+gl_UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034+gl_IMAGE_3D :: GLenum+gl_IMAGE_3D = 0x904E+gl_DEPTH_BUFFER_BIT0_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT0_QCOM = 0x00000100+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A+gl_DECR_WRAP_OES :: GLenum+gl_DECR_WRAP_OES = 0x8508+gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV :: GLenum+gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 0x903A+gl_SPARSE_STORAGE_BIT_ARB :: GLenum+gl_SPARSE_STORAGE_BIT_ARB = 0x0400+gl_LAST_VIDEO_CAPTURE_STATUS_NV :: GLenum+gl_LAST_VIDEO_CAPTURE_STATUS_NV = 0x9027+gl_LAST_VERTEX_CONVENTION :: GLenum+gl_LAST_VERTEX_CONVENTION = 0x8E4E+gl_IDENTITY_NV :: GLenum+gl_IDENTITY_NV = 0x862A+gl_RETAINED_APPLE :: GLenum+gl_RETAINED_APPLE = 0x8A1B+gl_FLOAT_RGB32_NV :: GLenum+gl_FLOAT_RGB32_NV = 0x8889+gl_DRAW_BUFFER15_ARB :: GLenum+gl_DRAW_BUFFER15_ARB = 0x8834+gl_COLOR_EXT :: GLenum+gl_COLOR_EXT = 0x1800+gl_WEIGHT_ARRAY_TYPE_OES :: GLenum+gl_WEIGHT_ARRAY_TYPE_OES = 0x86A9+gl_DETAIL_TEXTURE_2D_BINDING_SGIS :: GLenum+gl_DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096+gl_BGRA8_EXT :: GLenum+gl_BGRA8_EXT = 0x93A1+gl_T2F_IUI_V3F_EXT :: GLenum+gl_T2F_IUI_V3F_EXT = 0x81B2+gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD+gl_VERTEX_ARRAY_LIST_IBM :: GLenum+gl_VERTEX_ARRAY_LIST_IBM = 103070+gl_INDEX_ARRAY_STRIDE_EXT :: GLenum+gl_INDEX_ARRAY_STRIDE_EXT = 0x8086+gl_SCALE_BY_ONE_HALF_NV :: GLenum+gl_SCALE_BY_ONE_HALF_NV = 0x8540+gl_PROXY_TEXTURE_4D_SGIS :: GLenum+gl_PROXY_TEXTURE_4D_SGIS = 0x8135+gl_HALF_FLOAT :: GLenum+gl_HALF_FLOAT = 0x140B+gl_FIELD_UPPER_NV :: GLenum+gl_FIELD_UPPER_NV = 0x9022+gl_OCCLUSION_QUERY_EVENT_MASK_AMD :: GLenum+gl_OCCLUSION_QUERY_EVENT_MASK_AMD = 0x874F+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV :: GLenum+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5B+gl_VERTEX_ATTRIB_ARRAY4_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY4_NV = 0x8654+gl_CONVOLUTION_BORDER_COLOR_HP :: GLenum+gl_CONVOLUTION_BORDER_COLOR_HP = 0x8154+gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT :: GLenum+gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52+gl_MODULATE :: GLenum+gl_MODULATE = 0x2100+gl_NO_RESET_NOTIFICATION_KHR :: GLenum+gl_NO_RESET_NOTIFICATION_KHR = 0x8261+gl_CURRENT_INDEX :: GLenum+gl_CURRENT_INDEX = 0x0B01+gl_RED_MAX_CLAMP_INGR :: GLenum+gl_RED_MAX_CLAMP_INGR = 0x8564+gl_SAMPLE_ALPHA_TO_MASK_EXT :: GLenum+gl_SAMPLE_ALPHA_TO_MASK_EXT = 0x809E+gl_DEBUG_CATEGORY_DEPRECATION_AMD :: GLenum+gl_DEBUG_CATEGORY_DEPRECATION_AMD = 0x914B+gl_EXP2 :: GLenum+gl_EXP2 = 0x0801+gl_HISTOGRAM :: GLenum+gl_HISTOGRAM = 0x8024+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB+gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT :: GLenum+gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510+gl_READ_FRAMEBUFFER_BINDING_APPLE :: GLenum+gl_READ_FRAMEBUFFER_BINDING_APPLE = 0x8CAA+gl_COLOR_ATTACHMENT9 :: GLenum+gl_COLOR_ATTACHMENT9 = 0x8CE9+gl_PROXY_TEXTURE_CUBE_MAP_ARB :: GLenum+gl_PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B+gl_SIGNED_RGB8_NV :: GLenum+gl_SIGNED_RGB8_NV = 0x86FF+gl_TEXTURE_INTENSITY_SIZE :: GLenum+gl_TEXTURE_INTENSITY_SIZE = 0x8061+gl_TEXTURE_MAX_CLAMP_S_SGIX :: GLenum+gl_TEXTURE_MAX_CLAMP_S_SGIX = 0x8369+gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV :: GLenum+gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4+gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV :: GLenum+gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C+gl_TEXTURE_MAX_LOD_SGIS :: GLenum+gl_TEXTURE_MAX_LOD_SGIS = 0x813B+gl_LUMINANCE :: GLenum+gl_LUMINANCE = 0x1909+gl_FOG_COORD_ARRAY_BUFFER_BINDING :: GLenum+gl_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D+gl_OFFSET_TEXTURE_2D_BIAS_NV :: GLenum+gl_OFFSET_TEXTURE_2D_BIAS_NV = 0x86E3+gl_FEEDBACK :: GLenum+gl_FEEDBACK = 0x1C01+gl_MAGNITUDE_BIAS_NV :: GLenum+gl_MAGNITUDE_BIAS_NV = 0x8718+gl_POST_CONVOLUTION_ALPHA_SCALE :: GLenum+gl_POST_CONVOLUTION_ALPHA_SCALE = 0x801F+gl_PATH_TERMINAL_END_CAP_NV :: GLenum+gl_PATH_TERMINAL_END_CAP_NV = 0x9078+gl_GLYPH_HEIGHT_BIT_NV :: GLenum+gl_GLYPH_HEIGHT_BIT_NV = 0x02+gl_TEXTURE_STORAGE_HINT_APPLE :: GLenum+gl_TEXTURE_STORAGE_HINT_APPLE = 0x85BC+gl_MATRIX2_NV :: GLenum+gl_MATRIX2_NV = 0x8632+gl_RGB16I :: GLenum+gl_RGB16I = 0x8D89+gl_NUM_SHADER_BINARY_FORMATS :: GLenum+gl_NUM_SHADER_BINARY_FORMATS = 0x8DF9+gl_MULTISAMPLE_BUFFER_BIT7_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT7_QCOM = 0x80000000+gl_SAMPLE_ALPHA_TO_ONE :: GLenum+gl_SAMPLE_ALPHA_TO_ONE = 0x809F+gl_CON_11_ATI :: GLenum+gl_CON_11_ATI = 0x894C+gl_MAP2_TEXTURE_COORD_1 :: GLenum+gl_MAP2_TEXTURE_COORD_1 = 0x0DB3+gl_DRAW_BUFFER14_ARB :: GLenum+gl_DRAW_BUFFER14_ARB = 0x8833+gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS :: GLenum+gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0+gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7+gl_FLOAT_RGBA_MODE_NV :: GLenum+gl_FLOAT_RGBA_MODE_NV = 0x888E+gl_VERTEX_ATTRIB_ARRAY9_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY9_NV = 0x8659+gl_ALPHA4 :: GLenum+gl_ALPHA4 = 0x803B+gl_EVAL_VERTEX_ATTRIB9_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB9_NV = 0x86CF+gl_VARIANT_ARRAY_POINTER_EXT :: GLenum+gl_VARIANT_ARRAY_POINTER_EXT = 0x87E9+gl_INDEX_TEST_EXT :: GLenum+gl_INDEX_TEST_EXT = 0x81B5+gl_MAX_RENDERBUFFER_SIZE_EXT :: GLenum+gl_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8+gl_MAP1_GRID_SEGMENTS :: GLenum+gl_MAP1_GRID_SEGMENTS = 0x0DD1+gl_DETAIL_TEXTURE_MODE_SGIS :: GLenum+gl_DETAIL_TEXTURE_MODE_SGIS = 0x809B+gl_LINEARBURN_NV :: GLenum+gl_LINEARBURN_NV = 0x92A5+gl_SOURCE2_ALPHA :: GLenum+gl_SOURCE2_ALPHA = 0x858A+gl_COLOR_ATTACHMENT9_EXT :: GLenum+gl_COLOR_ATTACHMENT9_EXT = 0x8CE9+gl_RENDERBUFFER_OES :: GLenum+gl_RENDERBUFFER_OES = 0x8D41+gl_RGBA8UI :: GLenum+gl_RGBA8UI = 0x8D7C+gl_MIPMAP :: GLenum+gl_MIPMAP = 0x8293+gl_SMOOTH_LINE_WIDTH_RANGE :: GLenum+gl_SMOOTH_LINE_WIDTH_RANGE = 0x0B22+gl_COMBINER7_NV :: GLenum+gl_COMBINER7_NV = 0x8557+gl_VIEW_CLASS_64_BITS :: GLenum+gl_VIEW_CLASS_64_BITS = 0x82C6+gl_SAMPLE_MASK_VALUE_SGIS :: GLenum+gl_SAMPLE_MASK_VALUE_SGIS = 0x80AA+gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS :: GLenum+gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD+gl_ALPHA32UI_EXT :: GLenum+gl_ALPHA32UI_EXT = 0x8D72+gl_NONE :: GLenum+gl_NONE = 0+gl_MATRIX25_ARB :: GLenum+gl_MATRIX25_ARB = 0x88D9+gl_DUAL_LUMINANCE_ALPHA4_SGIS :: GLenum+gl_DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C+gl_PATCH_VERTICES :: GLenum+gl_PATCH_VERTICES = 0x8E72+gl_COLOR_MATERIAL_PARAMETER :: GLenum+gl_COLOR_MATERIAL_PARAMETER = 0x0B56+gl_NUM_PROGRAM_BINARY_FORMATS :: GLenum+gl_NUM_PROGRAM_BINARY_FORMATS = 0x87FE+gl_PACK_ROW_LENGTH :: GLenum+gl_PACK_ROW_LENGTH = 0x0D02+gl_RENDERBUFFER_BINDING_EXT :: GLenum+gl_RENDERBUFFER_BINDING_EXT = 0x8CA7+gl_FORMAT_SUBSAMPLE_24_24_OML :: GLenum+gl_FORMAT_SUBSAMPLE_24_24_OML = 0x8982+gl_RELATIVE_ROUNDED_RECT4_NV :: GLenum+gl_RELATIVE_ROUNDED_RECT4_NV = 0xED+gl_TEXTURE3 :: GLenum+gl_TEXTURE3 = 0x84C3+gl_DEPTH_COMPONENT16_SGIX :: GLenum+gl_DEPTH_COMPONENT16_SGIX = 0x81A5+gl_SAMPLER_2D_SHADOW_EXT :: GLenum+gl_SAMPLER_2D_SHADOW_EXT = 0x8B62+gl_MIN_MAP_BUFFER_ALIGNMENT :: GLenum+gl_MIN_MAP_BUFFER_ALIGNMENT = 0x90BC+gl_PROXY_TEXTURE_2D_ARRAY_EXT :: GLenum+gl_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B+gl_WEIGHT_ARRAY_TYPE_ARB :: GLenum+gl_WEIGHT_ARRAY_TYPE_ARB = 0x86A9+gl_LOW_INT :: GLenum+gl_LOW_INT = 0x8DF3+gl_DRAW_BUFFER11_ATI :: GLenum+gl_DRAW_BUFFER11_ATI = 0x8830+gl_MAX_ELEMENTS_VERTICES_EXT :: GLenum+gl_MAX_ELEMENTS_VERTICES_EXT = 0x80E8+gl_COMPRESSED_RED_RGTC1_EXT :: GLenum+gl_COMPRESSED_RED_RGTC1_EXT = 0x8DBB+gl_RGBA :: GLenum+gl_RGBA = 0x1908+gl_DRAW_BUFFER0_ARB :: GLenum+gl_DRAW_BUFFER0_ARB = 0x8825+gl_TEXTURE_RED_TYPE :: GLenum+gl_TEXTURE_RED_TYPE = 0x8C10+gl_FENCE_APPLE :: GLenum+gl_FENCE_APPLE = 0x8A0B+gl_MAX_CONVOLUTION_WIDTH_EXT :: GLenum+gl_MAX_CONVOLUTION_WIDTH_EXT = 0x801A+gl_UNSIGNED_INVERT_NV :: GLenum+gl_UNSIGNED_INVERT_NV = 0x8537+gl_LIGHT6 :: GLenum+gl_LIGHT6 = 0x4006+gl_STREAM_COPY :: GLenum+gl_STREAM_COPY = 0x88E2+gl_INSTRUMENT_BUFFER_POINTER_SGIX :: GLenum+gl_INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180+gl_MODELVIEW :: GLenum+gl_MODELVIEW = 0x1700+gl_RGB32F :: GLenum+gl_RGB32F = 0x8815+gl_MAP_COLOR :: GLenum+gl_MAP_COLOR = 0x0D10+gl_COLOR_TABLE_INTENSITY_SIZE_SGI :: GLenum+gl_COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF+gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV :: GLenum+gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV = 0x90D0+gl_LAYER_PROVOKING_VERTEX_EXT :: GLenum+gl_LAYER_PROVOKING_VERTEX_EXT = 0x825E+gl_COMPRESSED_RGBA_ASTC_6x5x5_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_6x5x5_OES = 0x93C7+gl_FOG_BIT :: GLenum+gl_FOG_BIT = 0x00000080+gl_NATIVE_GRAPHICS_HANDLE_PGI :: GLenum+gl_NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 0x8C8B+gl_MAX_COMPUTE_SHARED_MEMORY_SIZE :: GLenum+gl_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262+gl_STENCIL_INDEX1_EXT :: GLenum+gl_STENCIL_INDEX1_EXT = 0x8D46+gl_COLOR_ATTACHMENT2_NV :: GLenum+gl_COLOR_ATTACHMENT2_NV = 0x8CE2+gl_DRAW_BUFFER5_ARB :: GLenum+gl_DRAW_BUFFER5_ARB = 0x882A+gl_TEXTURE_OBJECT_VALID_QCOM :: GLenum+gl_TEXTURE_OBJECT_VALID_QCOM = 0x8BDB+gl_PHONG_HINT_WIN :: GLenum+gl_PHONG_HINT_WIN = 0x80EB+gl_MAP1_VERTEX_ATTRIB0_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB0_4_NV = 0x8660+gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX :: GLenum+gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047+gl_COLOR_TABLE_WIDTH :: GLenum+gl_COLOR_TABLE_WIDTH = 0x80D9+gl_INT_IMAGE_1D_ARRAY :: GLenum+gl_INT_IMAGE_1D_ARRAY = 0x905D+gl_BUFFER_MAPPED :: GLenum+gl_BUFFER_MAPPED = 0x88BC+gl_TEXTURE_SWIZZLE_R :: GLenum+gl_TEXTURE_SWIZZLE_R = 0x8E42+gl_COLOR_ATTACHMENT9_NV :: GLenum+gl_COLOR_ATTACHMENT9_NV = 0x8CE9+gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0+gl_LUMINANCE16_ALPHA16 :: GLenum+gl_LUMINANCE16_ALPHA16 = 0x8048+gl_PERFQUERY_GLOBAL_CONTEXT_INTEL :: GLenum+gl_PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x00000001+gl_POINT_FADE_THRESHOLD_SIZE_EXT :: GLenum+gl_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128+gl_BLEND_EQUATION_OES :: GLenum+gl_BLEND_EQUATION_OES = 0x8009+gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum+gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898E+gl_TEXTURE_BINDING_2D_ARRAY_EXT :: GLenum+gl_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D+gl_CON_7_ATI :: GLenum+gl_CON_7_ATI = 0x8948+gl_DUAL_LUMINANCE16_SGIS :: GLenum+gl_DUAL_LUMINANCE16_SGIS = 0x8117+gl_RASTER_POSITION_UNCLIPPED_IBM :: GLenum+gl_RASTER_POSITION_UNCLIPPED_IBM = 0x19262+gl_ALLOW_DRAW_FRG_HINT_PGI :: GLenum+gl_ALLOW_DRAW_FRG_HINT_PGI = 0x1A210+gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT :: GLenum+gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 0x8F39+gl_TEXTURE_COORD_ARRAY :: GLenum+gl_TEXTURE_COORD_ARRAY = 0x8078+gl_MAX_DEBUG_LOGGED_MESSAGES_KHR :: GLenum+gl_MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144+gl_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_ARRAY_BUFFER_BINDING_ARB = 0x8894+gl_PIXEL_TEXTURE_SGIS :: GLenum+gl_PIXEL_TEXTURE_SGIS = 0x8353+gl_STENCIL_INDEX8 :: GLenum+gl_STENCIL_INDEX8 = 0x8D48+gl_IMAGE_CLASS_10_10_10_2 :: GLenum+gl_IMAGE_CLASS_10_10_10_2 = 0x82C3+gl_DRAW_INDIRECT_LENGTH_NV :: GLenum+gl_DRAW_INDIRECT_LENGTH_NV = 0x8F42+gl_DEBUG_CALLBACK_FUNCTION_ARB :: GLenum+gl_DEBUG_CALLBACK_FUNCTION_ARB = 0x8244+gl_INT_SAMPLER_2D_ARRAY :: GLenum+gl_INT_SAMPLER_2D_ARRAY = 0x8DCF+gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3+gl_GENERIC_ATTRIB_NV :: GLenum+gl_GENERIC_ATTRIB_NV = 0x8C7D+gl_TEXTURE_RED_TYPE_ARB :: GLenum+gl_TEXTURE_RED_TYPE_ARB = 0x8C10+gl_MAX_VERTEX_UNITS_ARB :: GLenum+gl_MAX_VERTEX_UNITS_ARB = 0x86A4+gl_DEPTH_BIAS :: GLenum+gl_DEPTH_BIAS = 0x0D1F+gl_SRGB :: GLenum+gl_SRGB = 0x8C40+gl_TEXTURE_COORD_ARRAY_TYPE :: GLenum+gl_TEXTURE_COORD_ARRAY_TYPE = 0x8089+gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 0x8C84+gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV :: GLenum+gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = 0x8F44+gl_CURRENT_TIME_NV :: GLenum+gl_CURRENT_TIME_NV = 0x8E28+gl_TEXTURE_DEPTH_SIZE :: GLenum+gl_TEXTURE_DEPTH_SIZE = 0x884A+gl_INDEX_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_INDEX_ARRAY_LIST_STRIDE_IBM = 103083+gl_CLIP_PLANE1_IMG :: GLenum+gl_CLIP_PLANE1_IMG = 0x3001+gl_CULL_VERTEX_EYE_POSITION_EXT :: GLenum+gl_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB+gl_COPY_READ_BUFFER_NV :: GLenum+gl_COPY_READ_BUFFER_NV = 0x8F36+gl_CONTEXT_CORE_PROFILE_BIT :: GLenum+gl_CONTEXT_CORE_PROFILE_BIT = 0x00000001+gl_ARC_TO_NV :: GLenum+gl_ARC_TO_NV = 0xFE+gl_PACK_COMPRESSED_BLOCK_SIZE :: GLenum+gl_PACK_COMPRESSED_BLOCK_SIZE = 0x912E+gl_TRACE_NAME_MESA :: GLenum+gl_TRACE_NAME_MESA = 0x8756+gl_TEXTURE_CROP_RECT_OES :: GLenum+gl_TEXTURE_CROP_RECT_OES = 0x8B9D+gl_MAP2_VERTEX_ATTRIB15_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB15_4_NV = 0x867F+gl_DRAW_INDIRECT_UNIFIED_NV :: GLenum+gl_DRAW_INDIRECT_UNIFIED_NV = 0x8F40+gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS :: GLenum+gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC+gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D+gl_CULL_FACE_MODE :: GLenum+gl_CULL_FACE_MODE = 0x0B45+gl_LUMINANCE_ALPHA_INTEGER_EXT :: GLenum+gl_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D+gl_SURFACE_MAPPED_NV :: GLenum+gl_SURFACE_MAPPED_NV = 0x8700+gl_FOG_COORD_ARRAY_LENGTH_NV :: GLenum+gl_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32+gl_R :: GLenum+gl_R = 0x2002+gl_NUM_VIDEO_CAPTURE_STREAMS_NV :: GLenum+gl_NUM_VIDEO_CAPTURE_STREAMS_NV = 0x9024+gl_VERTEX_PROGRAM_POINT_SIZE_NV :: GLenum+gl_VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642+gl_CONSTANT_NV :: GLenum+gl_CONSTANT_NV = 0x8576+gl_RGB10_A2 :: GLenum+gl_RGB10_A2 = 0x8059+gl_INTENSITY16_EXT :: GLenum+gl_INTENSITY16_EXT = 0x804D+gl_TEXTURE28 :: GLenum+gl_TEXTURE28 = 0x84DC+gl_COMPRESSED_RGBA_ASTC_4x4_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0+gl_SRGB_READ :: GLenum+gl_SRGB_READ = 0x8297+gl_LUMINANCE16_ALPHA16_SNORM :: GLenum+gl_LUMINANCE16_ALPHA16_SNORM = 0x901A+gl_UNSIGNED_INT_IMAGE_1D_ARRAY :: GLenum+gl_UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068+gl_ELEMENT_ARRAY_TYPE_ATI :: GLenum+gl_ELEMENT_ARRAY_TYPE_ATI = 0x8769+gl_PATCH_DEFAULT_OUTER_LEVEL :: GLenum+gl_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74+gl_LINE_STRIP_ADJACENCY_ARB :: GLenum+gl_LINE_STRIP_ADJACENCY_ARB = 0x000B+gl_POLYGON_OFFSET_POINT :: GLenum+gl_POLYGON_OFFSET_POINT = 0x2A01+gl_UNSIGNED_SHORT_8_8_APPLE :: GLenum+gl_UNSIGNED_SHORT_8_8_APPLE = 0x85BA+gl_DYNAMIC_ATI :: GLenum+gl_DYNAMIC_ATI = 0x8761+gl_UNSIGNED_INT16_NV :: GLenum+gl_UNSIGNED_INT16_NV = 0x8FF0+gl_TEXTURE_BINDING_BUFFER_EXT :: GLenum+gl_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A+gl_MAP2_VERTEX_ATTRIB14_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB14_4_NV = 0x867E+gl_COMPRESSED_RGB :: GLenum+gl_COMPRESSED_RGB = 0x84ED+gl_VERTEX_ATTRIB_ARRAY0_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY0_NV = 0x8650+gl_MIN :: GLenum+gl_MIN = 0x8007+gl_COLOR_SUM :: GLenum+gl_COLOR_SUM = 0x8458+gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD :: GLenum+gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD = 0x87EE+gl_RECIP_ADD_SIGNED_ALPHA_IMG :: GLenum+gl_RECIP_ADD_SIGNED_ALPHA_IMG = 0x8C05+gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV :: GLenum+gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x01000000+gl_SPRITE_AXIAL_SGIX :: GLenum+gl_SPRITE_AXIAL_SGIX = 0x814C+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES = 0x8CD3+gl_TEXTURE_ENV_BIAS_SGIX :: GLenum+gl_TEXTURE_ENV_BIAS_SGIX = 0x80BE+gl_PROGRAM_FORMAT_ASCII_ARB :: GLenum+gl_PROGRAM_FORMAT_ASCII_ARB = 0x8875+gl_OUTPUT_COLOR1_EXT :: GLenum+gl_OUTPUT_COLOR1_EXT = 0x879C+gl_SELECTION_BUFFER_SIZE :: GLenum+gl_SELECTION_BUFFER_SIZE = 0x0DF4+gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE = 0x8A08+gl_INTENSITY_FLOAT16_ATI :: GLenum+gl_INTENSITY_FLOAT16_ATI = 0x881D+gl_TEXTURE30_ARB :: GLenum+gl_TEXTURE30_ARB = 0x84DE+gl_TEXTURE_1D_STACK_MESAX :: GLenum+gl_TEXTURE_1D_STACK_MESAX = 0x8759+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A+gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087+gl_SIGNED_HILO_NV :: GLenum+gl_SIGNED_HILO_NV = 0x86F9+gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT :: GLenum+gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004+gl_ACTIVE_ATTRIBUTE_MAX_LENGTH :: GLenum+gl_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A+gl_IMAGE_2D_RECT_EXT :: GLenum+gl_IMAGE_2D_RECT_EXT = 0x904F+gl_TESS_GEN_MODE :: GLenum+gl_TESS_GEN_MODE = 0x8E76+gl_TEXTURE_MIN_FILTER :: GLenum+gl_TEXTURE_MIN_FILTER = 0x2801+gl_FLOAT_VEC4 :: GLenum+gl_FLOAT_VEC4 = 0x8B52+gl_LIGHT2 :: GLenum+gl_LIGHT2 = 0x4002+gl_MODELVIEW24_ARB :: GLenum+gl_MODELVIEW24_ARB = 0x8738+gl_TESS_EVALUATION_SHADER :: GLenum+gl_TESS_EVALUATION_SHADER = 0x8E87+gl_PROXY_COLOR_TABLE_SGI :: GLenum+gl_PROXY_COLOR_TABLE_SGI = 0x80D3+gl_INDEX_ARRAY_EXT :: GLenum+gl_INDEX_ARRAY_EXT = 0x8077+gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F+gl_FRAGMENT_INPUT_NV :: GLenum+gl_FRAGMENT_INPUT_NV = 0x936D+gl_CON_13_ATI :: GLenum+gl_CON_13_ATI = 0x894E+gl_IMAGE_ROTATE_ORIGIN_Y_HP :: GLenum+gl_IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B+gl_VERTEX_ARRAY_COUNT_EXT :: GLenum+gl_VERTEX_ARRAY_COUNT_EXT = 0x807D+gl_STENCIL_INDEX1_OES :: GLenum+gl_STENCIL_INDEX1_OES = 0x8D46+gl_BUFFER_DATA_SIZE :: GLenum+gl_BUFFER_DATA_SIZE = 0x9303+gl_MAX_NAME_STACK_DEPTH :: GLenum+gl_MAX_NAME_STACK_DEPTH = 0x0D37+gl_SAMPLES_PASSED_ARB :: GLenum+gl_SAMPLES_PASSED_ARB = 0x8914+gl_TEXTURE_PRE_SPECULAR_HP :: GLenum+gl_TEXTURE_PRE_SPECULAR_HP = 0x8169+gl_RESCALE_NORMAL_EXT :: GLenum+gl_RESCALE_NORMAL_EXT = 0x803A+gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :: GLenum+gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A+gl_TRANSLATE_2D_NV :: GLenum+gl_TRANSLATE_2D_NV = 0x9090+gl_QUAD_INTENSITY8_SGIS :: GLenum+gl_QUAD_INTENSITY8_SGIS = 0x8123+gl_LOCATION_INDEX :: GLenum+gl_LOCATION_INDEX = 0x930F+gl_MODELVIEW9_ARB :: GLenum+gl_MODELVIEW9_ARB = 0x8729+gl_CONTEXT_RELEASE_BEHAVIOR_KHR :: GLenum+gl_CONTEXT_RELEASE_BEHAVIOR_KHR = 0x82FB+gl_EDGE_FLAG_ARRAY_BUFFER_BINDING :: GLenum+gl_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B+gl_DEBUG_TYPE_PERFORMANCE_KHR :: GLenum+gl_DEBUG_TYPE_PERFORMANCE_KHR = 0x8250+gl_POINT_DISTANCE_ATTENUATION :: GLenum+gl_POINT_DISTANCE_ATTENUATION = 0x8129+gl_PIXEL_TILE_GRID_HEIGHT_SGIX :: GLenum+gl_PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143+gl_COLOR_ATTACHMENT3 :: GLenum+gl_COLOR_ATTACHMENT3 = 0x8CE3+gl_COUNT_UP_NV :: GLenum+gl_COUNT_UP_NV = 0x9088+gl_STENCIL_BACK_VALUE_MASK :: GLenum+gl_STENCIL_BACK_VALUE_MASK = 0x8CA4+gl_PERFQUERY_DONOT_FLUSH_INTEL :: GLenum+gl_PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9+gl_VARIABLE_F_NV :: GLenum+gl_VARIABLE_F_NV = 0x8528+gl_STENCIL_BACK_PASS_DEPTH_FAIL :: GLenum+gl_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802+gl_IMAGE_CUBIC_WEIGHT_HP :: GLenum+gl_IMAGE_CUBIC_WEIGHT_HP = 0x815E+gl_STENCIL :: GLenum+gl_STENCIL = 0x1802+gl_DRAW_BUFFER6_ARB :: GLenum+gl_DRAW_BUFFER6_ARB = 0x882B+gl_MAX_COMBINED_IMAGE_UNIFORMS :: GLenum+gl_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF+gl_PROGRAM_STRING_NV :: GLenum+gl_PROGRAM_STRING_NV = 0x8628+gl_STREAM_DRAW :: GLenum+gl_STREAM_DRAW = 0x88E0+gl_BGR_INTEGER_EXT :: GLenum+gl_BGR_INTEGER_EXT = 0x8D9A+gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9E+gl_LAYER_PROVOKING_VERTEX :: GLenum+gl_LAYER_PROVOKING_VERTEX = 0x825E+gl_TEXTURE_ALPHA_SIZE_EXT :: GLenum+gl_TEXTURE_ALPHA_SIZE_EXT = 0x805F+gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD :: GLenum+gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD = 0x00000001+gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174+gl_VIEW_CLASS_48_BITS :: GLenum+gl_VIEW_CLASS_48_BITS = 0x82C7+gl_DRAW_BUFFER15_NV :: GLenum+gl_DRAW_BUFFER15_NV = 0x8834+gl_MAX_LABEL_LENGTH_KHR :: GLenum+gl_MAX_LABEL_LENGTH_KHR = 0x82E8+gl_DEBUG_TYPE_PERFORMANCE :: GLenum+gl_DEBUG_TYPE_PERFORMANCE = 0x8250+gl_DEPENDENT_RGB_TEXTURE_3D_NV :: GLenum+gl_DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859+gl_MAX_GEOMETRY_ATOMIC_COUNTERS :: GLenum+gl_MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5+gl_DRAW_BUFFER10_ARB :: GLenum+gl_DRAW_BUFFER10_ARB = 0x882F+gl_FONT_UNDERLINE_THICKNESS_BIT_NV :: GLenum+gl_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x08000000+gl_DRAW_BUFFER7 :: GLenum+gl_DRAW_BUFFER7 = 0x882C+gl_TEXTURE_GREEN_TYPE_ARB :: GLenum+gl_TEXTURE_GREEN_TYPE_ARB = 0x8C11+gl_TEXTURE_MIN_LOD_SGIS :: GLenum+gl_TEXTURE_MIN_LOD_SGIS = 0x813A+gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8+gl_ELEMENT_ARRAY_BARRIER_BIT_EXT :: GLenum+gl_ELEMENT_ARRAY_BARRIER_BIT_EXT = 0x00000002+gl_SAMPLE_COVERAGE_VALUE :: GLenum+gl_SAMPLE_COVERAGE_VALUE = 0x80AA+gl_VERTEX_ATTRIB_RELATIVE_OFFSET :: GLenum+gl_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5+gl_COLOR_TABLE_RED_SIZE :: GLenum+gl_COLOR_TABLE_RED_SIZE = 0x80DA+gl_TRANSFORM_FEEDBACK_BUFFER_START_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84+gl_NAME_STACK_DEPTH :: GLenum+gl_NAME_STACK_DEPTH = 0x0D70+gl_UNSIGNED_INT_5_9_9_9_REV :: GLenum+gl_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E+gl_FUNC_SUBTRACT_EXT :: GLenum+gl_FUNC_SUBTRACT_EXT = 0x800A+gl_STENCIL_INDEX4_EXT :: GLenum+gl_STENCIL_INDEX4_EXT = 0x8D47+gl_TEXTURE_COMPRESSION_HINT :: GLenum+gl_TEXTURE_COMPRESSION_HINT = 0x84EF+gl_DEPTH_CLAMP :: GLenum+gl_DEPTH_CLAMP = 0x864F+gl_SAMPLE_COVERAGE_INVERT :: GLenum+gl_SAMPLE_COVERAGE_INVERT = 0x80AB+gl_DRAW_BUFFER0_EXT :: GLenum+gl_DRAW_BUFFER0_EXT = 0x8825+gl_DRAW_BUFFER4 :: GLenum+gl_DRAW_BUFFER4 = 0x8829+gl_ALPHA_FLOAT16_ATI :: GLenum+gl_ALPHA_FLOAT16_ATI = 0x881C+gl_AFFINE_2D_NV :: GLenum+gl_AFFINE_2D_NV = 0x9092+gl_MAX_TRACK_MATRICES_NV :: GLenum+gl_MAX_TRACK_MATRICES_NV = 0x862F+gl_BINORMAL_ARRAY_STRIDE_EXT :: GLenum+gl_BINORMAL_ARRAY_STRIDE_EXT = 0x8441+gl_UNSIGNED_SHORT_1_5_5_5_REV :: GLenum+gl_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366+gl_ROUNDED_RECT4_NV :: GLenum+gl_ROUNDED_RECT4_NV = 0xEC+gl_COMMAND_BARRIER_BIT_EXT :: GLenum+gl_COMMAND_BARRIER_BIT_EXT = 0x00000040+gl_TEXTURE_ENV_COLOR :: GLenum+gl_TEXTURE_ENV_COLOR = 0x2201+gl_READ_WRITE_ARB :: GLenum+gl_READ_WRITE_ARB = 0x88BA+gl_RGBA8_EXT :: GLenum+gl_RGBA8_EXT = 0x8058+gl_EVAL_VERTEX_ATTRIB10_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB10_NV = 0x86D0+gl_POST_CONVOLUTION_RED_BIAS :: GLenum+gl_POST_CONVOLUTION_RED_BIAS = 0x8020+gl_INT16_VEC4_NV :: GLenum+gl_INT16_VEC4_NV = 0x8FE7+gl_COLOR_SUM_ARB :: GLenum+gl_COLOR_SUM_ARB = 0x8458+gl_OUTPUT_TEXTURE_COORD5_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD5_EXT = 0x87A2+gl_COMPRESSED_RGBA_ASTC_12x10_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC+gl_MAX_ELEMENTS_INDICES :: GLenum+gl_MAX_ELEMENTS_INDICES = 0x80E9+gl_REFERENCED_BY_FRAGMENT_SHADER :: GLenum+gl_REFERENCED_BY_FRAGMENT_SHADER = 0x930A+gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB :: GLenum+gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344+gl_WEIGHT_ARRAY_ARB :: GLenum+gl_WEIGHT_ARRAY_ARB = 0x86AD+gl_TIME_ELAPSED_EXT :: GLenum+gl_TIME_ELAPSED_EXT = 0x88BF+gl_BACK_SECONDARY_COLOR_NV :: GLenum+gl_BACK_SECONDARY_COLOR_NV = 0x8C78+gl_COMPARE_REF_TO_TEXTURE_EXT :: GLenum+gl_COMPARE_REF_TO_TEXTURE_EXT = 0x884E+gl_IS_PER_PATCH_EXT :: GLenum+gl_IS_PER_PATCH_EXT = 0x92E7+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE = 0x8D56+gl_TEXTURE_LUMINANCE_SIZE_EXT :: GLenum+gl_TEXTURE_LUMINANCE_SIZE_EXT = 0x8060+gl_COVERAGE_BUFFERS_NV :: GLenum+gl_COVERAGE_BUFFERS_NV = 0x8ED3+gl_MATRIX5_ARB :: GLenum+gl_MATRIX5_ARB = 0x88C5+gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT = 0x8A56+gl_COMPRESSED_RGBA_ASTC_5x5x4_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_5x5x4_OES = 0x93C5+gl_CONVOLUTION_FILTER_BIAS :: GLenum+gl_CONVOLUTION_FILTER_BIAS = 0x8015+gl_TRACE_PRIMITIVES_BIT_MESA :: GLenum+gl_TRACE_PRIMITIVES_BIT_MESA = 0x0002+gl_POINT_SPRITE :: GLenum+gl_POINT_SPRITE = 0x8861+gl_POLYGON_STIPPLE_BIT :: GLenum+gl_POLYGON_STIPPLE_BIT = 0x00000010+gl_DEBUG_SEVERITY_HIGH :: GLenum+gl_DEBUG_SEVERITY_HIGH = 0x9146+gl_RENDERBUFFER_STENCIL_SIZE_EXT :: GLenum+gl_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55+gl_RED :: GLenum+gl_RED = 0x1903+gl_DRAW_BUFFER12_NV :: GLenum+gl_DRAW_BUFFER12_NV = 0x8831+gl_COMPRESSED_RGBA_ASTC_10x10_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB+gl_ACTIVE_TEXTURE :: GLenum+gl_ACTIVE_TEXTURE = 0x84E0+gl_Q :: GLenum+gl_Q = 0x2003+gl_STRICT_LIGHTING_HINT_PGI :: GLenum+gl_STRICT_LIGHTING_HINT_PGI = 0x1A217+gl_INT8_VEC2_NV :: GLenum+gl_INT8_VEC2_NV = 0x8FE1+gl_MAP2_VERTEX_ATTRIB0_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB0_4_NV = 0x8670+gl_SHADER_SOURCE_LENGTH :: GLenum+gl_SHADER_SOURCE_LENGTH = 0x8B88+gl_FLOAT_MAT4 :: GLenum+gl_FLOAT_MAT4 = 0x8B5C+gl_COLOR_MATRIX_SGI :: GLenum+gl_COLOR_MATRIX_SGI = 0x80B1+gl_SAMPLER_2D_ARRAY_EXT :: GLenum+gl_SAMPLER_2D_ARRAY_EXT = 0x8DC1+gl_MODULATE_SUBTRACT_ATI :: GLenum+gl_MODULATE_SUBTRACT_ATI = 0x8746+gl_TRIANGLES_ADJACENCY_ARB :: GLenum+gl_TRIANGLES_ADJACENCY_ARB = 0x000C+gl_PROGRAM_TARGET_NV :: GLenum+gl_PROGRAM_TARGET_NV = 0x8646+gl_GEOMETRY_SHADER_ARB :: GLenum+gl_GEOMETRY_SHADER_ARB = 0x8DD9+gl_TEXTURE_BASE_LEVEL_SGIS :: GLenum+gl_TEXTURE_BASE_LEVEL_SGIS = 0x813C+gl_1PASS_SGIS :: GLenum+gl_1PASS_SGIS = 0x80A1+gl_TEXTURE_HEIGHT_QCOM :: GLenum+gl_TEXTURE_HEIGHT_QCOM = 0x8BD3+gl_LUMINANCE12_ALPHA4_EXT :: GLenum+gl_LUMINANCE12_ALPHA4_EXT = 0x8046+gl_PIXEL_TILE_HEIGHT_SGIX :: GLenum+gl_PIXEL_TILE_HEIGHT_SGIX = 0x8141+gl_UNSIGNED_INT_S8_S8_8_8_NV :: GLenum+gl_UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA+gl_SOURCE0_RGB :: GLenum+gl_SOURCE0_RGB = 0x8580+gl_DRAW_BUFFER6_EXT :: GLenum+gl_DRAW_BUFFER6_EXT = 0x882B+gl_PATH_FILL_BOUNDING_BOX_NV :: GLenum+gl_PATH_FILL_BOUNDING_BOX_NV = 0x90A1+gl_RENDER_MODE :: GLenum+gl_RENDER_MODE = 0x0C40+gl_X_EXT :: GLenum+gl_X_EXT = 0x87D5+gl_CON_14_ATI :: GLenum+gl_CON_14_ATI = 0x894F+gl_TRIANGLE_STRIP_ADJACENCY :: GLenum+gl_TRIANGLE_STRIP_ADJACENCY = 0x000D+gl_ROUNDED_RECT_NV :: GLenum+gl_ROUNDED_RECT_NV = 0xE8+gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB :: GLenum+gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87+gl_DSDT_MAG_INTENSITY_NV :: GLenum+gl_DSDT_MAG_INTENSITY_NV = 0x86DC+gl_MODELVIEW13_ARB :: GLenum+gl_MODELVIEW13_ARB = 0x872D+gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES :: GLenum+gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA+gl_CLIP_ORIGIN :: GLenum+gl_CLIP_ORIGIN = 0x935C+gl_PATH_CLIENT_LENGTH_NV :: GLenum+gl_PATH_CLIENT_LENGTH_NV = 0x907F+gl_SAMPLE_ALPHA_TO_ONE_ARB :: GLenum+gl_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F+gl_RENDERBUFFER_INTERNAL_FORMAT_OES :: GLenum+gl_RENDERBUFFER_INTERNAL_FORMAT_OES = 0x8D44+gl_POINT_SPRITE_ARB :: GLenum+gl_POINT_SPRITE_ARB = 0x8861+gl_FLOAT_MAT3_ARB :: GLenum+gl_FLOAT_MAT3_ARB = 0x8B5B+gl_IMAGE_CLASS_4_X_8 :: GLenum+gl_IMAGE_CLASS_4_X_8 = 0x82BF+gl_PIXEL_SUBSAMPLE_4242_SGIX :: GLenum+gl_PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D+gl_ROUNDED_RECT8_NV :: GLenum+gl_ROUNDED_RECT8_NV = 0xEE+gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING :: GLenum+gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D+gl_DST_NV :: GLenum+gl_DST_NV = 0x9287+gl_MAX_TRANSFORM_FEEDBACK_BUFFERS :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70+gl_FUNC_ADD_OES :: GLenum+gl_FUNC_ADD_OES = 0x8006+gl_VERTEX_STREAM7_ATI :: GLenum+gl_VERTEX_STREAM7_ATI = 0x8773+gl_RG_EXT :: GLenum+gl_RG_EXT = 0x8227+gl_STENCIL_BACK_PASS_DEPTH_PASS :: GLenum+gl_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803+gl_FRAMEBUFFER_RENDERABLE_LAYERED :: GLenum+gl_FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A+gl_MAP2_VERTEX_ATTRIB1_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB1_4_NV = 0x8671+gl_DRAW_BUFFER2_ATI :: GLenum+gl_DRAW_BUFFER2_ATI = 0x8827+gl_RGBA_FLOAT16_ATI :: GLenum+gl_RGBA_FLOAT16_ATI = 0x881A+gl_EVAL_VERTEX_ATTRIB13_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB13_NV = 0x86D3+gl_DRAW_BUFFER15_ATI :: GLenum+gl_DRAW_BUFFER15_ATI = 0x8834+gl_MAP_WRITE_BIT :: GLenum+gl_MAP_WRITE_BIT = 0x0002+gl_DOT3_RGBA :: GLenum+gl_DOT3_RGBA = 0x86AF+gl_MAT_SHININESS_BIT_PGI :: GLenum+gl_MAT_SHININESS_BIT_PGI = 0x02000000+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: GLenum+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88+gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV :: GLenum+gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E+gl_MATRIX30_ARB :: GLenum+gl_MATRIX30_ARB = 0x88DE+gl_STENCIL_TEST :: GLenum+gl_STENCIL_TEST = 0x0B90+gl_MAX_INTEGER_SAMPLES :: GLenum+gl_MAX_INTEGER_SAMPLES = 0x9110+gl_COPY_READ_BUFFER_BINDING :: GLenum+gl_COPY_READ_BUFFER_BINDING = 0x8F36+gl_TRANSFORM_FEEDBACK_BUFFER :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E+gl_LUMINANCE_FLOAT16_APPLE :: GLenum+gl_LUMINANCE_FLOAT16_APPLE = 0x881E+gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS :: GLenum+gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89+gl_MAX_VERTEX_UNIFORM_VECTORS :: GLenum+gl_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB+gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV :: GLenum+gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A+gl_SAMPLER_RENDERBUFFER_NV :: GLenum+gl_SAMPLER_RENDERBUFFER_NV = 0x8E56+gl_DRAW_BUFFER13_NV :: GLenum+gl_DRAW_BUFFER13_NV = 0x8832+gl_RGB32F_ARB :: GLenum+gl_RGB32F_ARB = 0x8815+gl_FRAGMENT_LIGHT5_SGIX :: GLenum+gl_FRAGMENT_LIGHT5_SGIX = 0x8411+gl_MAX_GENERAL_COMBINERS_NV :: GLenum+gl_MAX_GENERAL_COMBINERS_NV = 0x854D+gl_TRANSPOSE_TEXTURE_MATRIX_ARB :: GLenum+gl_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5+gl_OPERAND1_ALPHA_ARB :: GLenum+gl_OPERAND1_ALPHA_ARB = 0x8599+gl_COLOR_ATTACHMENT12 :: GLenum+gl_COLOR_ATTACHMENT12 = 0x8CEC+gl_GREEN_MAX_CLAMP_INGR :: GLenum+gl_GREEN_MAX_CLAMP_INGR = 0x8565+gl_PATH_PROJECTION_STACK_DEPTH_NV :: GLenum+gl_PATH_PROJECTION_STACK_DEPTH_NV = 0x0BA4+gl_MAP2_COLOR_4 :: GLenum+gl_MAP2_COLOR_4 = 0x0DB0+gl_COLOR_SUM_EXT :: GLenum+gl_COLOR_SUM_EXT = 0x8458+gl_CLAMP_FRAGMENT_COLOR_ARB :: GLenum+gl_CLAMP_FRAGMENT_COLOR_ARB = 0x891B+gl_INDEX_BITS :: GLenum+gl_INDEX_BITS = 0x0D51+gl_CON_15_ATI :: GLenum+gl_CON_15_ATI = 0x8950+gl_BLEND_OVERLAP_NV :: GLenum+gl_BLEND_OVERLAP_NV = 0x9281+gl_DS_SCALE_NV :: GLenum+gl_DS_SCALE_NV = 0x8710+gl_CURRENT_PALETTE_MATRIX_ARB :: GLenum+gl_CURRENT_PALETTE_MATRIX_ARB = 0x8843+gl_IMAGE_BINDING_LAYER_EXT :: GLenum+gl_IMAGE_BINDING_LAYER_EXT = 0x8F3D+gl_WEIGHT_SUM_UNITY_ARB :: GLenum+gl_WEIGHT_SUM_UNITY_ARB = 0x86A6+gl_ALPHA32I_EXT :: GLenum+gl_ALPHA32I_EXT = 0x8D84+gl_SHADER_STORAGE_BUFFER_SIZE :: GLenum+gl_SHADER_STORAGE_BUFFER_SIZE = 0x90D5+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED+gl_MAX_UNIFORM_LOCATIONS :: GLenum+gl_MAX_UNIFORM_LOCATIONS = 0x826E+gl_DEBUG_SOURCE_OTHER_KHR :: GLenum+gl_DEBUG_SOURCE_OTHER_KHR = 0x824B+gl_FRACTIONAL_EVEN :: GLenum+gl_FRACTIONAL_EVEN = 0x8E7C+gl_MIN_PROGRAM_TEXEL_OFFSET :: GLenum+gl_MIN_PROGRAM_TEXEL_OFFSET = 0x8904+gl_WEIGHT_ARRAY_OES :: GLenum+gl_WEIGHT_ARRAY_OES = 0x86AD+gl_RESET_NOTIFICATION_STRATEGY_KHR :: GLenum+gl_RESET_NOTIFICATION_STRATEGY_KHR = 0x8256+gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4+gl_RGB2_EXT :: GLenum+gl_RGB2_EXT = 0x804E+gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT :: GLenum+gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001+gl_ELEMENT_ARRAY_BUFFER :: GLenum+gl_ELEMENT_ARRAY_BUFFER = 0x8893+gl_MEDIUM_FLOAT :: GLenum+gl_MEDIUM_FLOAT = 0x8DF1+gl_SAMPLER_1D_SHADOW_ARB :: GLenum+gl_SAMPLER_1D_SHADOW_ARB = 0x8B61+gl_DRAW_BUFFER5 :: GLenum+gl_DRAW_BUFFER5 = 0x882A+gl_PARALLEL_ARRAYS_INTEL :: GLenum+gl_PARALLEL_ARRAYS_INTEL = 0x83F4+gl_REG_24_ATI :: GLenum+gl_REG_24_ATI = 0x8939+gl_DEPTH_STENCIL_TO_BGRA_NV :: GLenum+gl_DEPTH_STENCIL_TO_BGRA_NV = 0x886F+gl_MAX_FRAMEBUFFER_WIDTH :: GLenum+gl_MAX_FRAMEBUFFER_WIDTH = 0x9315+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES = 0x93E3+gl_POLYGON_OFFSET_FILL :: GLenum+gl_POLYGON_OFFSET_FILL = 0x8037+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES = 0x8518+gl_TEXTURE_GEN_T :: GLenum+gl_TEXTURE_GEN_T = 0x0C61+gl_TEXTURE_POST_SPECULAR_HP :: GLenum+gl_TEXTURE_POST_SPECULAR_HP = 0x8168+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES = 0x8516+gl_MAGNITUDE_SCALE_NV :: GLenum+gl_MAGNITUDE_SCALE_NV = 0x8712+gl_VERTEX_SHADER_LOCALS_EXT :: GLenum+gl_VERTEX_SHADER_LOCALS_EXT = 0x87D3+gl_INT_2_10_10_10_REV :: GLenum+gl_INT_2_10_10_10_REV = 0x8D9F+gl_DOUBLE_MAT3x2_EXT :: GLenum+gl_DOUBLE_MAT3x2_EXT = 0x8F4B+gl_DISCARD_NV :: GLenum+gl_DISCARD_NV = 0x8530+gl_MATRIX13_ARB :: GLenum+gl_MATRIX13_ARB = 0x88CD+gl_GENERATE_MIPMAP_HINT :: GLenum+gl_GENERATE_MIPMAP_HINT = 0x8192+gl_MAX_PIXEL_MAP_TABLE :: GLenum+gl_MAX_PIXEL_MAP_TABLE = 0x0D34+gl_SHADER_STORAGE_BUFFER :: GLenum+gl_SHADER_STORAGE_BUFFER = 0x90D2+gl_BUFFER_UPDATE_BARRIER_BIT :: GLenum+gl_BUFFER_UPDATE_BARRIER_BIT = 0x00000200+gl_FRAMEBUFFER_BINDING_OES :: GLenum+gl_FRAMEBUFFER_BINDING_OES = 0x8CA6+gl_CONTEXT_PROFILE_MASK :: GLenum+gl_CONTEXT_PROFILE_MASK = 0x9126+gl_MAX_VIEWPORTS :: GLenum+gl_MAX_VIEWPORTS = 0x825B+gl_DRAW_BUFFER4_ARB :: GLenum+gl_DRAW_BUFFER4_ARB = 0x8829+gl_RESAMPLE_DECIMATE_SGIX :: GLenum+gl_RESAMPLE_DECIMATE_SGIX = 0x8430+gl_SHADER_OBJECT_ARB :: GLenum+gl_SHADER_OBJECT_ARB = 0x8B48+gl_SYNC_FLAGS_APPLE :: GLenum+gl_SYNC_FLAGS_APPLE = 0x9115+gl_Z4Y12Z4CB12Z4CR12_444_NV :: GLenum+gl_Z4Y12Z4CB12Z4CR12_444_NV = 0x9037+gl_VERTEX_ARRAY_LENGTH_NV :: GLenum+gl_VERTEX_ARRAY_LENGTH_NV = 0x8F2B+gl_FOG_COORDINATE_ARRAY_LIST_IBM :: GLenum+gl_FOG_COORDINATE_ARRAY_LIST_IBM = 103076+gl_FRAMEBUFFER_DEFAULT_SAMPLES :: GLenum+gl_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313+gl_FLAT :: GLenum+gl_FLAT = 0x1D00+gl_REG_2_ATI :: GLenum+gl_REG_2_ATI = 0x8923+gl_VIEWPORT_BIT :: GLenum+gl_VIEWPORT_BIT = 0x00000800+gl_TEXTURE_VIEW_MIN_LEVEL_EXT :: GLenum+gl_TEXTURE_VIEW_MIN_LEVEL_EXT = 0x82DB+gl_FRACTIONAL_ODD_EXT :: GLenum+gl_FRACTIONAL_ODD_EXT = 0x8E7B+gl_VIRTUAL_PAGE_SIZE_X_ARB :: GLenum+gl_VIRTUAL_PAGE_SIZE_X_ARB = 0x9195+gl_GLOBAL_ALPHA_SUN :: GLenum+gl_GLOBAL_ALPHA_SUN = 0x81D9+gl_TEXTURE_BORDER :: GLenum+gl_TEXTURE_BORDER = 0x1005+gl_MAP2_VERTEX_ATTRIB7_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB7_4_NV = 0x8677+gl_BUFFER_ACCESS :: GLenum+gl_BUFFER_ACCESS = 0x88BB+gl_COLOR_ATTACHMENT15_EXT :: GLenum+gl_COLOR_ATTACHMENT15_EXT = 0x8CEF+gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum+gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CF+gl_PRIMITIVE_RESTART_FIXED_INDEX :: GLenum+gl_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69+gl_MAX_COMBINED_DIMENSIONS :: GLenum+gl_MAX_COMBINED_DIMENSIONS = 0x8282+gl_MINUS_NV :: GLenum+gl_MINUS_NV = 0x929F+gl_NORMAL_MAP_ARB :: GLenum+gl_NORMAL_MAP_ARB = 0x8511+gl_MAT_AMBIENT_BIT_PGI :: GLenum+gl_MAT_AMBIENT_BIT_PGI = 0x00100000+gl_REG_14_ATI :: GLenum+gl_REG_14_ATI = 0x892F+gl_SECONDARY_INTERPOLATOR_ATI :: GLenum+gl_SECONDARY_INTERPOLATOR_ATI = 0x896D+gl_FRAGMENT_SHADER_BIT_EXT :: GLenum+gl_FRAGMENT_SHADER_BIT_EXT = 0x00000002+gl_CON_20_ATI :: GLenum+gl_CON_20_ATI = 0x8955+gl_DYNAMIC_DRAW :: GLenum+gl_DYNAMIC_DRAW = 0x88E8+gl_STENCIL_INDEX1 :: GLenum+gl_STENCIL_INDEX1 = 0x8D46+gl_DEPTH_COMPONENTS :: GLenum+gl_DEPTH_COMPONENTS = 0x8284+gl_SEPARATE_SPECULAR_COLOR_EXT :: GLenum+gl_SEPARATE_SPECULAR_COLOR_EXT = 0x81FA+gl_CONSTANT_COLOR0_NV :: GLenum+gl_CONSTANT_COLOR0_NV = 0x852A+gl_LUMINANCE16I_EXT :: GLenum+gl_LUMINANCE16I_EXT = 0x8D8C+gl_TEXTURE_COORD_ARRAY_SIZE_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088+gl_BLEND_DST_RGB :: GLenum+gl_BLEND_DST_RGB = 0x80C8+gl_VARIABLE_C_NV :: GLenum+gl_VARIABLE_C_NV = 0x8525+gl_INT_VEC2_ARB :: GLenum+gl_INT_VEC2_ARB = 0x8B53+gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX :: GLenum+gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178+gl_PIXEL_MAP_G_TO_G_SIZE :: GLenum+gl_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7+gl_BLUE_MIN_CLAMP_INGR :: GLenum+gl_BLUE_MIN_CLAMP_INGR = 0x8562+gl_RETURN :: GLenum+gl_RETURN = 0x0102+gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD :: GLenum+gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 0x9160+gl_DOUBLE :: GLenum+gl_DOUBLE = 0x140A+gl_COMBINE4_NV :: GLenum+gl_COMBINE4_NV = 0x8503+gl_IMAGE_ROTATE_ORIGIN_X_HP :: GLenum+gl_IMAGE_ROTATE_ORIGIN_X_HP = 0x815A+gl_COMBINER5_NV :: GLenum+gl_COMBINER5_NV = 0x8555+gl_SYNC_CONDITION :: GLenum+gl_SYNC_CONDITION = 0x9113+gl_DEBUG_LOGGED_MESSAGES_ARB :: GLenum+gl_DEBUG_LOGGED_MESSAGES_ARB = 0x9145+gl_REG_15_ATI :: GLenum+gl_REG_15_ATI = 0x8930+gl_BUFFER_MAP_POINTER_OES :: GLenum+gl_BUFFER_MAP_POINTER_OES = 0x88BD+gl_SM_COUNT_NV :: GLenum+gl_SM_COUNT_NV = 0x933B+gl_MAX_FRAMEBUFFER_HEIGHT :: GLenum+gl_MAX_FRAMEBUFFER_HEIGHT = 0x9316+gl_INCR_WRAP_OES :: GLenum+gl_INCR_WRAP_OES = 0x8507+gl_GCCSO_SHADER_BINARY_FJ :: GLenum+gl_GCCSO_SHADER_BINARY_FJ = 0x9260+gl_DRAW_BUFFER4_NV :: GLenum+gl_DRAW_BUFFER4_NV = 0x8829+gl_RGB565 :: GLenum+gl_RGB565 = 0x8D62+gl_WRITE_PIXEL_DATA_RANGE_NV :: GLenum+gl_WRITE_PIXEL_DATA_RANGE_NV = 0x8878+gl_UNIFORM_OFFSET :: GLenum+gl_UNIFORM_OFFSET = 0x8A3B+gl_UNSIGNED_INT64_ARB :: GLenum+gl_UNSIGNED_INT64_ARB = 0x140F+gl_STENCIL_RENDERABLE :: GLenum+gl_STENCIL_RENDERABLE = 0x8288+gl_COMPRESSED_RGBA_BPTC_UNORM :: GLenum+gl_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C+gl_FLOAT_R32_NV :: GLenum+gl_FLOAT_R32_NV = 0x8885+gl_TEXTURE_CLIPMAP_OFFSET_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173+gl_TEXTURE_IMAGE_VALID_QCOM :: GLenum+gl_TEXTURE_IMAGE_VALID_QCOM = 0x8BD8+gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279+gl_IMAGE_PIXEL_TYPE :: GLenum+gl_IMAGE_PIXEL_TYPE = 0x82AA+gl_EDGE_FLAG_ARRAY_STRIDE :: GLenum+gl_EDGE_FLAG_ARRAY_STRIDE = 0x808C+gl_RED_SCALE :: GLenum+gl_RED_SCALE = 0x0D14+gl_RENDERBUFFER_ALPHA_SIZE_OES :: GLenum+gl_RENDERBUFFER_ALPHA_SIZE_OES = 0x8D53+gl_CLIP_DISTANCE7 :: GLenum+gl_CLIP_DISTANCE7 = 0x3007+gl_INTENSITY32UI_EXT :: GLenum+gl_INTENSITY32UI_EXT = 0x8D73+gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR :: GLenum+gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247+gl_PN_TRIANGLES_ATI :: GLenum+gl_PN_TRIANGLES_ATI = 0x87F0+gl_LIGHT5 :: GLenum+gl_LIGHT5 = 0x4005+gl_QUERY_RESULT_ARB :: GLenum+gl_QUERY_RESULT_ARB = 0x8866+gl_LUMINANCE16 :: GLenum+gl_LUMINANCE16 = 0x8042+gl_ALPHA_TEST_QCOM :: GLenum+gl_ALPHA_TEST_QCOM = 0x0BC0+gl_TEXTURE_BORDER_COLOR_NV :: GLenum+gl_TEXTURE_BORDER_COLOR_NV = 0x1004+gl_CULL_FRAGMENT_NV :: GLenum+gl_CULL_FRAGMENT_NV = 0x86E7+gl_PATH_GEN_MODE_NV :: GLenum+gl_PATH_GEN_MODE_NV = 0x90B0+gl_PROGRAM_POINT_SIZE_ARB :: GLenum+gl_PROGRAM_POINT_SIZE_ARB = 0x8642+gl_INTERNALFORMAT_DEPTH_TYPE :: GLenum+gl_INTERNALFORMAT_DEPTH_TYPE = 0x827C+gl_UNPACK_SKIP_ROWS :: GLenum+gl_UNPACK_SKIP_ROWS = 0x0CF3+gl_DEBUG_SEVERITY_NOTIFICATION :: GLenum+gl_DEBUG_SEVERITY_NOTIFICATION = 0x826B+gl_MAX_FRAGMENT_LIGHTS_SGIX :: GLenum+gl_MAX_FRAGMENT_LIGHTS_SGIX = 0x8404+gl_COUNTER_TYPE_AMD :: GLenum+gl_COUNTER_TYPE_AMD = 0x8BC0+gl_TEXTURE_FETCH_BARRIER_BIT_EXT :: GLenum+gl_TEXTURE_FETCH_BARRIER_BIT_EXT = 0x00000008+gl_CURRENT_NORMAL :: GLenum+gl_CURRENT_NORMAL = 0x0B02+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES = 0x93E5+gl_MULTIVIEW_EXT :: GLenum+gl_MULTIVIEW_EXT = 0x90F1+gl_TESS_GEN_VERTEX_ORDER_EXT :: GLenum+gl_TESS_GEN_VERTEX_ORDER_EXT = 0x8E78+gl_IMAGE_SCALE_X_HP :: GLenum+gl_IMAGE_SCALE_X_HP = 0x8155+gl_TEXTURE_COLOR_TABLE_SGI :: GLenum+gl_TEXTURE_COLOR_TABLE_SGI = 0x80BC+gl_DSDT_MAG_NV :: GLenum+gl_DSDT_MAG_NV = 0x86F6+gl_Z400_BINARY_AMD :: GLenum+gl_Z400_BINARY_AMD = 0x8740+gl_COLOR_INDEX8_EXT :: GLenum+gl_COLOR_INDEX8_EXT = 0x80E5+gl_SRGB8_NV :: GLenum+gl_SRGB8_NV = 0x8C41+gl_UNSIGNED_IDENTITY_NV :: GLenum+gl_UNSIGNED_IDENTITY_NV = 0x8536+gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES :: GLenum+gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES = 0x9105+gl_ALPHA_SNORM :: GLenum+gl_ALPHA_SNORM = 0x9010+gl_MAX_TEXTURE_UNITS :: GLenum+gl_MAX_TEXTURE_UNITS = 0x84E2+gl_DEBUG_SEVERITY_MEDIUM_KHR :: GLenum+gl_DEBUG_SEVERITY_MEDIUM_KHR = 0x9147+gl_TEXTURE_RECTANGLE :: GLenum+gl_TEXTURE_RECTANGLE = 0x84F5+gl_CONTRAST_NV :: GLenum+gl_CONTRAST_NV = 0x92A1+gl_FILL :: GLenum+gl_FILL = 0x1B02+gl_BLEND_COLOR :: GLenum+gl_BLEND_COLOR = 0x8005+gl_POINT_SMOOTH_HINT :: GLenum+gl_POINT_SMOOTH_HINT = 0x0C51+gl_CONTEXT_ROBUST_ACCESS :: GLenum+gl_CONTEXT_ROBUST_ACCESS = 0x90F3+gl_FRAGMENT_PROGRAM_NV :: GLenum+gl_FRAGMENT_PROGRAM_NV = 0x8870+gl_OP_MULTIPLY_MATRIX_EXT :: GLenum+gl_OP_MULTIPLY_MATRIX_EXT = 0x8798+gl_DEPENDENT_GB_TEXTURE_2D_NV :: GLenum+gl_DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA+gl_DOUBLE_EXT :: GLenum+gl_DOUBLE_EXT = 0x140A+gl_VERTEX_PROGRAM_NV :: GLenum+gl_VERTEX_PROGRAM_NV = 0x8620+gl_PATH_END_CAPS_NV :: GLenum+gl_PATH_END_CAPS_NV = 0x9076+gl_PATH_STROKE_MASK_NV :: GLenum+gl_PATH_STROKE_MASK_NV = 0x9084+gl_SAMPLER_CUBE_SHADOW_EXT :: GLenum+gl_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5+gl_COLOR_SAMPLES_NV :: GLenum+gl_COLOR_SAMPLES_NV = 0x8E20+gl_DUAL_INTENSITY16_SGIS :: GLenum+gl_DUAL_INTENSITY16_SGIS = 0x811B+gl_IMPLEMENTATION_COLOR_READ_TYPE_OES :: GLenum+gl_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A+gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR :: GLenum+gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C+gl_SCISSOR_TEST :: GLenum+gl_SCISSOR_TEST = 0x0C11+gl_ADJACENT_PAIRS_NV :: GLenum+gl_ADJACENT_PAIRS_NV = 0x90AE+gl_MAX_VERTEX_ATTRIB_BINDINGS :: GLenum+gl_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA+gl_TEXTURE_GATHER :: GLenum+gl_TEXTURE_GATHER = 0x82A2+gl_LUMINANCE_ALPHA8UI_EXT :: GLenum+gl_LUMINANCE_ALPHA8UI_EXT = 0x8D81+gl_RELATIVE_ARC_TO_NV :: GLenum+gl_RELATIVE_ARC_TO_NV = 0xFF+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA+gl_TEXTURE_BINDING_CUBE_MAP_EXT :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514+gl_FRAGMENT_ALPHA_MODULATE_IMG :: GLenum+gl_FRAGMENT_ALPHA_MODULATE_IMG = 0x8C08+gl_CURRENT_VERTEX_EXT :: GLenum+gl_CURRENT_VERTEX_EXT = 0x87E2+gl_MAP1_VERTEX_ATTRIB11_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB11_4_NV = 0x866B+gl_MATRIX_INDEX_ARRAY_SIZE_ARB :: GLenum+gl_MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846+gl_TRANSFORM_FEEDBACK_BUFFER_MODE :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F+gl_PIXEL_TILE_CACHE_SIZE_SGIX :: GLenum+gl_PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145+gl_MODELVIEW0_EXT :: GLenum+gl_MODELVIEW0_EXT = 0x1700+gl_FONT_DESCENDER_BIT_NV :: GLenum+gl_FONT_DESCENDER_BIT_NV = 0x00400000+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE+gl_RASTERIZER_DISCARD :: GLenum+gl_RASTERIZER_DISCARD = 0x8C89+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85+gl_MAX_DEBUG_MESSAGE_LENGTH_ARB :: GLenum+gl_MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143+gl_EXTENSIONS :: GLenum+gl_EXTENSIONS = 0x1F03+gl_RESAMPLE_AVERAGE_OML :: GLenum+gl_RESAMPLE_AVERAGE_OML = 0x8988+gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV :: GLenum+gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 0x9033+gl_RELATIVE_SMALL_CCW_ARC_TO_NV :: GLenum+gl_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13+gl_FRONT :: GLenum+gl_FRONT = 0x0404+gl_BLEND_COLOR_EXT :: GLenum+gl_BLEND_COLOR_EXT = 0x8005+gl_BUFFER_ACCESS_OES :: GLenum+gl_BUFFER_ACCESS_OES = 0x88BB+gl_MATRIX29_ARB :: GLenum+gl_MATRIX29_ARB = 0x88DD+gl_GEOMETRY_LINKED_INPUT_TYPE_EXT :: GLenum+gl_GEOMETRY_LINKED_INPUT_TYPE_EXT = 0x8917+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES = 0x8CD0+gl_COLOR_ATTACHMENT12_EXT :: GLenum+gl_COLOR_ATTACHMENT12_EXT = 0x8CEC+gl_DRAW_BUFFER1 :: GLenum+gl_DRAW_BUFFER1 = 0x8826+gl_FLOAT_32_UNSIGNED_INT_24_8_REV :: GLenum+gl_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD+gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5+gl_UNSIGNED_INT_SAMPLER_CUBE :: GLenum+gl_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4+gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI :: GLenum+gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4+gl_MAX_CULL_DISTANCES :: GLenum+gl_MAX_CULL_DISTANCES = 0x82F9+gl_TEXTURE_LOD_BIAS_S_SGIX :: GLenum+gl_TEXTURE_LOD_BIAS_S_SGIX = 0x818E+gl_SPRITE_SGIX :: GLenum+gl_SPRITE_SGIX = 0x8148+gl_VERTEX_ATTRIB_ARRAY3_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY3_NV = 0x8653+gl_QUAD_INTENSITY4_SGIS :: GLenum+gl_QUAD_INTENSITY4_SGIS = 0x8122+gl_DIFFERENCE_KHR :: GLenum+gl_DIFFERENCE_KHR = 0x929E+gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT = 0x90D9+gl_VOLATILE_APPLE :: GLenum+gl_VOLATILE_APPLE = 0x8A1A+gl_MAT_EMISSION_BIT_PGI :: GLenum+gl_MAT_EMISSION_BIT_PGI = 0x00800000+gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = 0x8C75+gl_DRAW_FRAMEBUFFER_BINDING :: GLenum+gl_DRAW_FRAMEBUFFER_BINDING = 0x8CA6+gl_TEXTURE8 :: GLenum+gl_TEXTURE8 = 0x84C8+gl_MUL_ATI :: GLenum+gl_MUL_ATI = 0x8964+gl_PROGRAM_OBJECT_EXT :: GLenum+gl_PROGRAM_OBJECT_EXT = 0x8B40+gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810+gl_MATRIX_INDEX_ARRAY_TYPE_ARB :: GLenum+gl_MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847+gl_PIXEL_MAG_FILTER_EXT :: GLenum+gl_PIXEL_MAG_FILTER_EXT = 0x8331+gl_LESS :: GLenum+gl_LESS = 0x0201+gl_SOURCE2_RGB_ARB :: GLenum+gl_SOURCE2_RGB_ARB = 0x8582+gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: GLenum+gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35+gl_PATH_STENCIL_VALUE_MASK_NV :: GLenum+gl_PATH_STENCIL_VALUE_MASK_NV = 0x90B9+gl_IMPLEMENTATION_COLOR_READ_TYPE :: GLenum+gl_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A+gl_TEXTURE_CLIPMAP_CENTER_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171+gl_BUFFER :: GLenum+gl_BUFFER = 0x82E0+gl_DEBUG_CALLBACK_USER_PARAM_ARB :: GLenum+gl_DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245+gl_FIXED_OES :: GLenum+gl_FIXED_OES = 0x140C+gl_INT_VEC2 :: GLenum+gl_INT_VEC2 = 0x8B53+gl_VARIANT_VALUE_EXT :: GLenum+gl_VARIANT_VALUE_EXT = 0x87E4+gl_QUAD_STRIP :: GLenum+gl_QUAD_STRIP = 0x0008+gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT :: GLenum+gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E+gl_ZERO_TO_ONE :: GLenum+gl_ZERO_TO_ONE = 0x935F+gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB :: GLenum+gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A+gl_CND_ATI :: GLenum+gl_CND_ATI = 0x896A+gl_PROGRAM_POINT_SIZE :: GLenum+gl_PROGRAM_POINT_SIZE = 0x8642+gl_VIEWPORT_BOUNDS_RANGE :: GLenum+gl_VIEWPORT_BOUNDS_RANGE = 0x825D+gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum+gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6+gl_R1UI_T2F_N3F_V3F_SUN :: GLenum+gl_R1UI_T2F_N3F_V3F_SUN = 0x85CA+gl_DEPTH_STENCIL_EXT :: GLenum+gl_DEPTH_STENCIL_EXT = 0x84F9+gl_RESCALE_NORMAL :: GLenum+gl_RESCALE_NORMAL = 0x803A+gl_INDEX_CLEAR_VALUE :: GLenum+gl_INDEX_CLEAR_VALUE = 0x0C20+gl_VERTEX_STREAM5_ATI :: GLenum+gl_VERTEX_STREAM5_ATI = 0x8771+gl_CON_4_ATI :: GLenum+gl_CON_4_ATI = 0x8945+gl_LAYOUT_DEFAULT_INTEL :: GLenum+gl_LAYOUT_DEFAULT_INTEL = 0+gl_RGBA8I_EXT :: GLenum+gl_RGBA8I_EXT = 0x8D8E+gl_IMAGE_CLASS_4_X_16 :: GLenum+gl_IMAGE_CLASS_4_X_16 = 0x82BC+gl_RGB8_EXT :: GLenum+gl_RGB8_EXT = 0x8051+gl_TEXTURE_DS_SIZE_NV :: GLenum+gl_TEXTURE_DS_SIZE_NV = 0x871D+gl_CLAMP_VERTEX_COLOR :: GLenum+gl_CLAMP_VERTEX_COLOR = 0x891A+gl_DEPTH_CLEAR_VALUE :: GLenum+gl_DEPTH_CLEAR_VALUE = 0x0B73+gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623+gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8+gl_RGB_FLOAT16_APPLE :: GLenum+gl_RGB_FLOAT16_APPLE = 0x881B+gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV :: GLenum+gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2+gl_COLOR_ATTACHMENT1 :: GLenum+gl_COLOR_ATTACHMENT1 = 0x8CE1+gl_MAX_TESS_GEN_LEVEL_EXT :: GLenum+gl_MAX_TESS_GEN_LEVEL_EXT = 0x8E7E+gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45+gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM :: GLenum+gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM = 0x8F66+gl_MATRIX3_ARB :: GLenum+gl_MATRIX3_ARB = 0x88C3+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB :: GLenum+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF+gl_FRAGMENT_PROGRAM_BINDING_NV :: GLenum+gl_FRAGMENT_PROGRAM_BINDING_NV = 0x8873+gl_DOT2_ADD_ATI :: GLenum+gl_DOT2_ADD_ATI = 0x896C+gl_CON_2_ATI :: GLenum+gl_CON_2_ATI = 0x8943+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES = 0x8CD9+gl_UNIFORM_ARRAY_STRIDE :: GLenum+gl_UNIFORM_ARRAY_STRIDE = 0x8A3C+gl_RECLAIM_MEMORY_HINT_PGI :: GLenum+gl_RECLAIM_MEMORY_HINT_PGI = 0x1A1FE+gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS :: GLenum+gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80+gl_DRAW_BUFFER11_ARB :: GLenum+gl_DRAW_BUFFER11_ARB = 0x8830+gl_NORMAL_ARRAY :: GLenum+gl_NORMAL_ARRAY = 0x8075+gl_PATH_GEN_COMPONENTS_NV :: GLenum+gl_PATH_GEN_COMPONENTS_NV = 0x90B3+gl_COLOR_FLOAT_APPLE :: GLenum+gl_COLOR_FLOAT_APPLE = 0x8A0F+gl_WAIT_FAILED :: GLenum+gl_WAIT_FAILED = 0x911D+gl_SAMPLER_1D_ARRAY_SHADOW :: GLenum+gl_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3+gl_PIXEL_TEX_GEN_Q_CEILING_SGIX :: GLenum+gl_PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184+gl_ALWAYS_FAST_HINT_PGI :: GLenum+gl_ALWAYS_FAST_HINT_PGI = 0x1A20C+gl_GEOMETRY_OUTPUT_TYPE_EXT :: GLenum+gl_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC+gl_MAX_PROGRAM_PATCH_ATTRIBS_NV :: GLenum+gl_MAX_PROGRAM_PATCH_ATTRIBS_NV = 0x86D8+gl_TEXTURE_1D_ARRAY :: GLenum+gl_TEXTURE_1D_ARRAY = 0x8C18+gl_LIST_MODE :: GLenum+gl_LIST_MODE = 0x0B30+gl_COLOR_ARRAY_TYPE :: GLenum+gl_COLOR_ARRAY_TYPE = 0x8082+gl_SAMPLE_MASK_VALUE_EXT :: GLenum+gl_SAMPLE_MASK_VALUE_EXT = 0x80AA+gl_PIXEL_BUFFER_BARRIER_BIT :: GLenum+gl_PIXEL_BUFFER_BARRIER_BIT = 0x00000080+gl_SCISSOR_BOX :: GLenum+gl_SCISSOR_BOX = 0x0C10+gl_UNSIGNED_INT_SAMPLER_3D_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3+gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE :: GLenum+gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8+gl_CLIENT_ALL_ATTRIB_BITS :: GLenum+gl_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF+gl_TRANSPOSE_MODELVIEW_MATRIX_ARB :: GLenum+gl_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3+gl_TEXTURE_BINDING_RECTANGLE_NV :: GLenum+gl_TEXTURE_BINDING_RECTANGLE_NV = 0x84F6+gl_ALPHA_FLOAT32_ATI :: GLenum+gl_ALPHA_FLOAT32_ATI = 0x8816+gl_MAP1_TEXTURE_COORD_4 :: GLenum+gl_MAP1_TEXTURE_COORD_4 = 0x0D96+gl_CONSTANT_ALPHA :: GLenum+gl_CONSTANT_ALPHA = 0x8003+gl_PREVIOUS_EXT :: GLenum+gl_PREVIOUS_EXT = 0x8578+gl_PACK_COMPRESSED_SIZE_SGIX :: GLenum+gl_PACK_COMPRESSED_SIZE_SGIX = 0x831C+gl_IMAGE_2D_ARRAY_EXT :: GLenum+gl_IMAGE_2D_ARRAY_EXT = 0x9053+gl_ASYNC_TEX_IMAGE_SGIX :: GLenum+gl_ASYNC_TEX_IMAGE_SGIX = 0x835C+gl_QUERY_RESULT :: GLenum+gl_QUERY_RESULT = 0x8866+gl_MATRIX0_ARB :: GLenum+gl_MATRIX0_ARB = 0x88C0+gl_UNPACK_CMYK_HINT_EXT :: GLenum+gl_UNPACK_CMYK_HINT_EXT = 0x800F+gl_MAP1_TEXTURE_COORD_1 :: GLenum+gl_MAP1_TEXTURE_COORD_1 = 0x0D93+gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH :: GLenum+gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC+gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI :: GLenum+gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5+gl_TEXTURE_BLUE_SIZE_EXT :: GLenum+gl_TEXTURE_BLUE_SIZE_EXT = 0x805E+gl_VARIANT_EXT :: GLenum+gl_VARIANT_EXT = 0x87C1+gl_UNPACK_ROW_LENGTH :: GLenum+gl_UNPACK_ROW_LENGTH = 0x0CF2+gl_VARIANT_DATATYPE_EXT :: GLenum+gl_VARIANT_DATATYPE_EXT = 0x87E5+gl_LINEAR_MIPMAP_LINEAR :: GLenum+gl_LINEAR_MIPMAP_LINEAR = 0x2703+gl_ALPHA8I_EXT :: GLenum+gl_ALPHA8I_EXT = 0x8D90+gl_OUTPUT_TEXTURE_COORD20_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD20_EXT = 0x87B1+gl_EYE_LINEAR :: GLenum+gl_EYE_LINEAR = 0x2400+gl_VIEWPORT :: GLenum+gl_VIEWPORT = 0x0BA2+gl_SHADER_BINARY_DMP :: GLenum+gl_SHADER_BINARY_DMP = 0x9250+gl_TEXTURE25_ARB :: GLenum+gl_TEXTURE25_ARB = 0x84D9+gl_UNSIGNED_SHORT_4_4_4_4_EXT :: GLenum+gl_UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033+gl_PROXY_HISTOGRAM_EXT :: GLenum+gl_PROXY_HISTOGRAM_EXT = 0x8025+gl_SCALEBIAS_HINT_SGIX :: GLenum+gl_SCALEBIAS_HINT_SGIX = 0x8322+gl_MAP_INVALIDATE_RANGE_BIT_EXT :: GLenum+gl_MAP_INVALIDATE_RANGE_BIT_EXT = 0x0004+gl_FRAGMENT_PROGRAM_CALLBACK_MESA :: GLenum+gl_FRAGMENT_PROGRAM_CALLBACK_MESA = 0x8BB1+gl_TRANSLATE_3D_NV :: GLenum+gl_TRANSLATE_3D_NV = 0x9091+gl_PATH_COORD_COUNT_NV :: GLenum+gl_PATH_COORD_COUNT_NV = 0x909E+gl_MAX_ACTIVE_LIGHTS_SGIX :: GLenum+gl_MAX_ACTIVE_LIGHTS_SGIX = 0x8405+gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB :: GLenum+gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC+gl_REFERENCE_PLANE_EQUATION_SGIX :: GLenum+gl_REFERENCE_PLANE_EQUATION_SGIX = 0x817E+gl_PATH_TERMINAL_DASH_CAP_NV :: GLenum+gl_PATH_TERMINAL_DASH_CAP_NV = 0x907D+gl_INDEX_ARRAY :: GLenum+gl_INDEX_ARRAY = 0x8077+gl_INNOCENT_CONTEXT_RESET_ARB :: GLenum+gl_INNOCENT_CONTEXT_RESET_ARB = 0x8254+gl_TEXTURE_BINDING_1D :: GLenum+gl_TEXTURE_BINDING_1D = 0x8068+gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C+gl_QUERY_OBJECT_EXT :: GLenum+gl_QUERY_OBJECT_EXT = 0x9153+gl_UNIFORM_BLOCK :: GLenum+gl_UNIFORM_BLOCK = 0x92E2+gl_CONVOLUTION_HEIGHT :: GLenum+gl_CONVOLUTION_HEIGHT = 0x8019+gl_STENCIL_FAIL :: GLenum+gl_STENCIL_FAIL = 0x0B94+gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX :: GLenum+gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B+gl_TEXTURE_SAMPLES_IMG :: GLenum+gl_TEXTURE_SAMPLES_IMG = 0x9136+gl_REFLECTION_MAP_NV :: GLenum+gl_REFLECTION_MAP_NV = 0x8512+gl_GREEN_SCALE :: GLenum+gl_GREEN_SCALE = 0x0D18+gl_TRANSFORM_FEEDBACK_BUFFER_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_EXT = 0x8C8E+gl_LIGHTEN_NV :: GLenum+gl_LIGHTEN_NV = 0x9298+gl_HISTOGRAM_ALPHA_SIZE_EXT :: GLenum+gl_HISTOGRAM_ALPHA_SIZE_EXT = 0x802B+gl_UNSIGNED_INT64_NV :: GLenum+gl_UNSIGNED_INT64_NV = 0x140F+gl_LINE_STIPPLE_REPEAT :: GLenum+gl_LINE_STIPPLE_REPEAT = 0x0B26+gl_YCBCR_MESA :: GLenum+gl_YCBCR_MESA = 0x8757+gl_LEQUAL :: GLenum+gl_LEQUAL = 0x0203+gl_BUFFER_USAGE_ARB :: GLenum+gl_BUFFER_USAGE_ARB = 0x8765+gl_MAP1_VERTEX_ATTRIB6_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB6_4_NV = 0x8666+gl_SAMPLER_BUFFER_AMD :: GLenum+gl_SAMPLER_BUFFER_AMD = 0x9001+gl_OBJECT_DISTANCE_TO_LINE_SGIS :: GLenum+gl_OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3+gl_PIXEL_COUNT_NV :: GLenum+gl_PIXEL_COUNT_NV = 0x8866+gl_VERTEX_PROGRAM_POSITION_MESA :: GLenum+gl_VERTEX_PROGRAM_POSITION_MESA = 0x8BB4+gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI :: GLenum+gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7+gl_POST_COLOR_MATRIX_BLUE_BIAS :: GLenum+gl_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA+gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX :: GLenum+gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B+gl_VERTEX_ATTRIB_MAP2_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP2_APPLE = 0x8A01+gl_PLUS_DARKER_NV :: GLenum+gl_PLUS_DARKER_NV = 0x9292+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x906B+gl_FRAGMENT_SHADER_INVOCATIONS_ARB :: GLenum+gl_FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4+gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 0x9069+gl_PROXY_TEXTURE_CUBE_MAP_ARRAY :: GLenum+gl_PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B+gl_UNSIGNED_INT_IMAGE_CUBE_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_CUBE_EXT = 0x9066+gl_DYNAMIC_DRAW_ARB :: GLenum+gl_DYNAMIC_DRAW_ARB = 0x88E8+gl_RGBA_SNORM :: GLenum+gl_RGBA_SNORM = 0x8F93+gl_MAX_UNIFORM_BLOCK_SIZE :: GLenum+gl_MAX_UNIFORM_BLOCK_SIZE = 0x8A30+gl_FUNC_REVERSE_SUBTRACT_EXT :: GLenum+gl_FUNC_REVERSE_SUBTRACT_EXT = 0x800B+gl_STENCIL_BUFFER_BIT1_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT1_QCOM = 0x00020000+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB+gl_TEXTURE_1D_BINDING_EXT :: GLenum+gl_TEXTURE_1D_BINDING_EXT = 0x8068+gl_RGBA4_EXT :: GLenum+gl_RGBA4_EXT = 0x8056+gl_PREFER_DOUBLEBUFFER_HINT_PGI :: GLenum+gl_PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8+gl_UNKNOWN_CONTEXT_RESET_KHR :: GLenum+gl_UNKNOWN_CONTEXT_RESET_KHR = 0x8255+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES :: GLenum+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5C+gl_REFERENCED_BY_COMPUTE_SHADER :: GLenum+gl_REFERENCED_BY_COMPUTE_SHADER = 0x930B+gl_REG_17_ATI :: GLenum+gl_REG_17_ATI = 0x8932+gl_BUFFER_FLUSHING_UNMAP_APPLE :: GLenum+gl_BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13+gl_UNIFORM :: GLenum+gl_UNIFORM = 0x92E1+gl_TEXCOORD4_BIT_PGI :: GLenum+gl_TEXCOORD4_BIT_PGI = 0x80000000+gl_BIAS_BY_NEGATIVE_ONE_HALF_NV :: GLenum+gl_BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541+gl_OP_FLOOR_EXT :: GLenum+gl_OP_FLOOR_EXT = 0x878F+gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV :: GLenum+gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9+gl_CURRENT_QUERY :: GLenum+gl_CURRENT_QUERY = 0x8865+gl_UNIFORM_BUFFER_START :: GLenum+gl_UNIFORM_BUFFER_START = 0x8A29+gl_DEBUG_SEVERITY_HIGH_KHR :: GLenum+gl_DEBUG_SEVERITY_HIGH_KHR = 0x9146+gl_T2F_C4UB_V3F :: GLenum+gl_T2F_C4UB_V3F = 0x2A29+gl_FONT_GLYPHS_AVAILABLE_NV :: GLenum+gl_FONT_GLYPHS_AVAILABLE_NV = 0x9368+gl_MAX_CONVOLUTION_HEIGHT_EXT :: GLenum+gl_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B+gl_STENCIL_BUFFER_BIT3_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT3_QCOM = 0x00080000+gl_MAP1_VERTEX_ATTRIB3_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB3_4_NV = 0x8663+gl_BLEND_EQUATION_ALPHA_EXT :: GLenum+gl_BLEND_EQUATION_ALPHA_EXT = 0x883D+gl_RGB_FLOAT32_APPLE :: GLenum+gl_RGB_FLOAT32_APPLE = 0x8815+gl_CONSTANT_BORDER :: GLenum+gl_CONSTANT_BORDER = 0x8151+gl_CON_0_ATI :: GLenum+gl_CON_0_ATI = 0x8941+gl_VERTEX_ARRAY_RANGE_POINTER_NV :: GLenum+gl_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521+gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV :: GLenum+gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852+gl_INTERLACE_SGIX :: GLenum+gl_INTERLACE_SGIX = 0x8094+gl_UNPACK_CONSTANT_DATA_SUNX :: GLenum+gl_UNPACK_CONSTANT_DATA_SUNX = 0x81D5+gl_VERTEX_BINDING_STRIDE :: GLenum+gl_VERTEX_BINDING_STRIDE = 0x82D8+gl_IS_PER_PATCH :: GLenum+gl_IS_PER_PATCH = 0x92E7+gl_AVERAGE_HP :: GLenum+gl_AVERAGE_HP = 0x8160+gl_MAX_VERTEX_ATTRIBS :: GLenum+gl_MAX_VERTEX_ATTRIBS = 0x8869+gl_MAX_SAMPLES_ANGLE :: GLenum+gl_MAX_SAMPLES_ANGLE = 0x8D57+gl_RED_EXT :: GLenum+gl_RED_EXT = 0x1903+gl_MAP1_NORMAL :: GLenum+gl_MAP1_NORMAL = 0x0D92+gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT :: GLenum+gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2+gl_MIN_SAMPLE_SHADING_VALUE_ARB :: GLenum+gl_MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37+gl_COMPRESSED_SLUMINANCE_EXT :: GLenum+gl_COMPRESSED_SLUMINANCE_EXT = 0x8C4A+gl_RGBA4 :: GLenum+gl_RGBA4 = 0x8056+gl_TEXTURE_VIEW_MIN_LAYER :: GLenum+gl_TEXTURE_VIEW_MIN_LAYER = 0x82DD+gl_ONE_EXT :: GLenum+gl_ONE_EXT = 0x87DE+gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES :: GLenum+gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9277+gl_MODELVIEW31_ARB :: GLenum+gl_MODELVIEW31_ARB = 0x873F+gl_MAX_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_TEXTURE_IMAGE_UNITS = 0x8872+gl_COLOR_ATTACHMENT3_NV :: GLenum+gl_COLOR_ATTACHMENT3_NV = 0x8CE3+gl_LUMINANCE6_ALPHA2 :: GLenum+gl_LUMINANCE6_ALPHA2 = 0x8044+gl_POINT_SPRITE_R_MODE_NV :: GLenum+gl_POINT_SPRITE_R_MODE_NV = 0x8863+gl_COMPARE_REF_TO_TEXTURE :: GLenum+gl_COMPARE_REF_TO_TEXTURE = 0x884E+gl_MAX_PROJECTION_STACK_DEPTH :: GLenum+gl_MAX_PROJECTION_STACK_DEPTH = 0x0D38+gl_BLEND_DST_ALPHA :: GLenum+gl_BLEND_DST_ALPHA = 0x80CA+gl_TEXTURE_1D_STACK_BINDING_MESAX :: GLenum+gl_TEXTURE_1D_STACK_BINDING_MESAX = 0x875D+gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A+gl_PROGRAM_PARAMETER_NV :: GLenum+gl_PROGRAM_PARAMETER_NV = 0x8644+gl_VIDEO_CAPTURE_FRAME_WIDTH_NV :: GLenum+gl_VIDEO_CAPTURE_FRAME_WIDTH_NV = 0x9038+gl_MATRIX21_ARB :: GLenum+gl_MATRIX21_ARB = 0x88D5+gl_LIST_BASE :: GLenum+gl_LIST_BASE = 0x0B32+gl_COLOR_ATTACHMENT5 :: GLenum+gl_COLOR_ATTACHMENT5 = 0x8CE5+gl_VERTEX_ARRAY_BINDING_APPLE :: GLenum+gl_VERTEX_ARRAY_BINDING_APPLE = 0x85B5+gl_RELATIVE_LARGE_CW_ARC_TO_NV :: GLenum+gl_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19+gl_MAX_DEFORMATION_ORDER_SGIX :: GLenum+gl_MAX_DEFORMATION_ORDER_SGIX = 0x8197+gl_COVERAGE_AUTOMATIC_NV :: GLenum+gl_COVERAGE_AUTOMATIC_NV = 0x8ED7+gl_FOG_FUNC_SGIS :: GLenum+gl_FOG_FUNC_SGIS = 0x812A+gl_SAMPLER_BUFFER_EXT :: GLenum+gl_SAMPLER_BUFFER_EXT = 0x8DC2+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2+gl_RGB8 :: GLenum+gl_RGB8 = 0x8051+gl_PRIMARY_COLOR_NV :: GLenum+gl_PRIMARY_COLOR_NV = 0x852C+gl_DEPTH_TEXTURE_MODE_ARB :: GLenum+gl_DEPTH_TEXTURE_MODE_ARB = 0x884B+gl_LUMINANCE12_ALPHA4 :: GLenum+gl_LUMINANCE12_ALPHA4 = 0x8046+gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9+gl_TEXTURE_BUFFER_EXT :: GLenum+gl_TEXTURE_BUFFER_EXT = 0x8C2A+gl_LINK_STATUS :: GLenum+gl_LINK_STATUS = 0x8B82+gl_VERTEX_SHADER_EXT :: GLenum+gl_VERTEX_SHADER_EXT = 0x8780+gl_VERTEX_ARRAY_POINTER :: GLenum+gl_VERTEX_ARRAY_POINTER = 0x808E+gl_ONE_MINUS_SRC1_ALPHA :: GLenum+gl_ONE_MINUS_SRC1_ALPHA = 0x88FB+gl_TEXTURE_BUFFER_SIZE_EXT :: GLenum+gl_TEXTURE_BUFFER_SIZE_EXT = 0x919E+gl_DEBUG_SEVERITY_MEDIUM :: GLenum+gl_DEBUG_SEVERITY_MEDIUM = 0x9147+gl_ASYNC_READ_PIXELS_SGIX :: GLenum+gl_ASYNC_READ_PIXELS_SGIX = 0x835E+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1+gl_REPLACE_EXT :: GLenum+gl_REPLACE_EXT = 0x8062+gl_DEBUG_SOURCE_APPLICATION_ARB :: GLenum+gl_DEBUG_SOURCE_APPLICATION_ARB = 0x824A+gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB :: GLenum+gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES = 0x93E1+gl_BROWSER_DEFAULT_WEBGL :: GLenum+gl_BROWSER_DEFAULT_WEBGL = 0x9244+gl_MULTISAMPLE_BUFFER_BIT0_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT0_QCOM = 0x01000000+gl_DUAL_ALPHA8_SGIS :: GLenum+gl_DUAL_ALPHA8_SGIS = 0x8111+gl_COMPRESSED_RGB_FXT1_3DFX :: GLenum+gl_COMPRESSED_RGB_FXT1_3DFX = 0x86B0+gl_BLEND_SRC_RGB_OES :: GLenum+gl_BLEND_SRC_RGB_OES = 0x80C9+gl_T2F_IUI_V2F_EXT :: GLenum+gl_T2F_IUI_V2F_EXT = 0x81B1+gl_DRAW_BUFFER13_ARB :: GLenum+gl_DRAW_BUFFER13_ARB = 0x8832+gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV :: GLenum+gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3+gl_TEXTURE_INTENSITY_TYPE_ARB :: GLenum+gl_TEXTURE_INTENSITY_TYPE_ARB = 0x8C15+gl_DU8DV8_ATI :: GLenum+gl_DU8DV8_ATI = 0x877A+gl_MAP1_VERTEX_ATTRIB14_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB14_4_NV = 0x866E+gl_VARIANT_ARRAY_STRIDE_EXT :: GLenum+gl_VARIANT_ARRAY_STRIDE_EXT = 0x87E6+gl_RGB_S3TC :: GLenum+gl_RGB_S3TC = 0x83A0+gl_NORMAL_ARRAY_POINTER :: GLenum+gl_NORMAL_ARRAY_POINTER = 0x808F+gl_CONSTANT_ALPHA_EXT :: GLenum+gl_CONSTANT_ALPHA_EXT = 0x8003+gl_COLOR_ATTACHMENT8_NV :: GLenum+gl_COLOR_ATTACHMENT8_NV = 0x8CE8+gl_MAX_LIST_NESTING :: GLenum+gl_MAX_LIST_NESTING = 0x0B31+gl_FRAMEBUFFER_UNDEFINED :: GLenum+gl_FRAMEBUFFER_UNDEFINED = 0x8219+gl_ACTIVE_STENCIL_FACE_EXT :: GLenum+gl_ACTIVE_STENCIL_FACE_EXT = 0x8911+gl_DEPTH_SCALE :: GLenum+gl_DEPTH_SCALE = 0x0D1E+gl_READ_PIXELS_FORMAT :: GLenum+gl_READ_PIXELS_FORMAT = 0x828D+gl_QUADS_EXT :: GLenum+gl_QUADS_EXT = 0x0007+gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC+gl_OUTPUT_VERTEX_EXT :: GLenum+gl_OUTPUT_VERTEX_EXT = 0x879A+gl_PROGRAM_ATTRIBS_ARB :: GLenum+gl_PROGRAM_ATTRIBS_ARB = 0x88AC+gl_MAP1_VERTEX_ATTRIB8_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB8_4_NV = 0x8668+gl_INVALID_ENUM :: GLenum+gl_INVALID_ENUM = 0x0500+gl_1PASS_EXT :: GLenum+gl_1PASS_EXT = 0x80A1+gl_FUNC_ADD_EXT :: GLenum+gl_FUNC_ADD_EXT = 0x8006+gl_DISTANCE_ATTENUATION_SGIS :: GLenum+gl_DISTANCE_ATTENUATION_SGIS = 0x8129+gl_REG_3_ATI :: GLenum+gl_REG_3_ATI = 0x8924+gl_INTERPOLATE :: GLenum+gl_INTERPOLATE = 0x8575+gl_MITER_TRUNCATE_NV :: GLenum+gl_MITER_TRUNCATE_NV = 0x90A8+gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF+gl_CONTEXT_COMPATIBILITY_PROFILE_BIT :: GLenum+gl_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002+gl_MATRIX_STRIDE :: GLenum+gl_MATRIX_STRIDE = 0x92FF+gl_FONT_Y_MIN_BOUNDS_BIT_NV :: GLenum+gl_FONT_Y_MIN_BOUNDS_BIT_NV = 0x00020000+gl_COMBINER_BIAS_NV :: GLenum+gl_COMBINER_BIAS_NV = 0x8549+gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515+gl_CIRCULAR_CW_ARC_TO_NV :: GLenum+gl_CIRCULAR_CW_ARC_TO_NV = 0xFA+gl_UNSIGNED_INT_IMAGE_1D_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_1D_EXT = 0x9062+gl_BLUE_SCALE :: GLenum+gl_BLUE_SCALE = 0x0D1A+gl_OFFSET_TEXTURE_SCALE_NV :: GLenum+gl_OFFSET_TEXTURE_SCALE_NV = 0x86E2+gl_OFFSET_TEXTURE_2D_NV :: GLenum+gl_OFFSET_TEXTURE_2D_NV = 0x86E8+gl_INTERNALFORMAT_DEPTH_SIZE :: GLenum+gl_INTERNALFORMAT_DEPTH_SIZE = 0x8275+gl_TIMEOUT_IGNORED :: GLenum+gl_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF+gl_BGRA_EXT :: GLenum+gl_BGRA_EXT = 0x80E1+gl_GEQUAL :: GLenum+gl_GEQUAL = 0x0206+gl_EXCLUSION_KHR :: GLenum+gl_EXCLUSION_KHR = 0x92A0+gl_LINES_ADJACENCY_ARB :: GLenum+gl_LINES_ADJACENCY_ARB = 0x000A+gl_MAX_COMPUTE_WORK_GROUP_COUNT :: GLenum+gl_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE+gl_RENDERBUFFER_EXT :: GLenum+gl_RENDERBUFFER_EXT = 0x8D41+gl_GENERATE_MIPMAP :: GLenum+gl_GENERATE_MIPMAP = 0x8191+gl_SOURCE1_ALPHA_EXT :: GLenum+gl_SOURCE1_ALPHA_EXT = 0x8589+gl_VERTEX_TEXTURE :: GLenum+gl_VERTEX_TEXTURE = 0x829B+gl_LIGHT1 :: GLenum+gl_LIGHT1 = 0x4001+gl_STATIC_READ_ARB :: GLenum+gl_STATIC_READ_ARB = 0x88E5+gl_INTERLACE_READ_INGR :: GLenum+gl_INTERLACE_READ_INGR = 0x8568+gl_COMPRESSED_R11_EAC_OES :: GLenum+gl_COMPRESSED_R11_EAC_OES = 0x9270+gl_FRAGMENT_SHADER_ARB :: GLenum+gl_FRAGMENT_SHADER_ARB = 0x8B30+gl_CURRENT_RASTER_POSITION :: GLenum+gl_CURRENT_RASTER_POSITION = 0x0B07+gl_WEIGHT_ARRAY_BUFFER_BINDING_OES :: GLenum+gl_WEIGHT_ARRAY_BUFFER_BINDING_OES = 0x889E+gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT = 0x886C+gl_RGB_FLOAT32_ATI :: GLenum+gl_RGB_FLOAT32_ATI = 0x8815+gl_LUMINANCE16_ALPHA16_EXT :: GLenum+gl_LUMINANCE16_ALPHA16_EXT = 0x8048+gl_RENDERBUFFER_WIDTH_EXT :: GLenum+gl_RENDERBUFFER_WIDTH_EXT = 0x8D42+gl_DEPTH_RANGE :: GLenum+gl_DEPTH_RANGE = 0x0B70+gl_4_BYTES :: GLenum+gl_4_BYTES = 0x1409+gl_VERTEX_WEIGHTING_EXT :: GLenum+gl_VERTEX_WEIGHTING_EXT = 0x8509+gl_TEXTURE_SWIZZLE_B :: GLenum+gl_TEXTURE_SWIZZLE_B = 0x8E44+gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV :: GLenum+gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0+gl_FEEDBACK_BUFFER_POINTER :: GLenum+gl_FEEDBACK_BUFFER_POINTER = 0x0DF0+gl_CULL_VERTEX_IBM :: GLenum+gl_CULL_VERTEX_IBM = 103050+gl_UNPACK_SKIP_VOLUMES_SGIS :: GLenum+gl_UNPACK_SKIP_VOLUMES_SGIS = 0x8132+gl_PIXEL_CUBIC_WEIGHT_EXT :: GLenum+gl_PIXEL_CUBIC_WEIGHT_EXT = 0x8333+gl_DECR_WRAP_EXT :: GLenum+gl_DECR_WRAP_EXT = 0x8508+gl_TEXTURE31 :: GLenum+gl_TEXTURE31 = 0x84DF+gl_MAX_TESS_GEN_LEVEL :: GLenum+gl_MAX_TESS_GEN_LEVEL = 0x8E7E+gl_YCBAYCR8A_4224_NV :: GLenum+gl_YCBAYCR8A_4224_NV = 0x9032+gl_POINT_SPRITE_OES :: GLenum+gl_POINT_SPRITE_OES = 0x8861+gl_SAMPLER_EXTERNAL_OES :: GLenum+gl_SAMPLER_EXTERNAL_OES = 0x8D66+gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT :: GLenum+gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT = 0x8F63+gl_PIXEL_PACK_BUFFER_BINDING_ARB :: GLenum+gl_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED+gl_DEBUG_CATEGORY_API_ERROR_AMD :: GLenum+gl_DEBUG_CATEGORY_API_ERROR_AMD = 0x9149+gl_TEXCOORD3_BIT_PGI :: GLenum+gl_TEXCOORD3_BIT_PGI = 0x40000000+gl_UNIFORM_BUFFER_EXT :: GLenum+gl_UNIFORM_BUFFER_EXT = 0x8DEE+gl_COMPRESSED_RGBA8_ETC2_EAC :: GLenum+gl_COMPRESSED_RGBA8_ETC2_EAC = 0x9278+gl_COLOR_SUM_CLAMP_NV :: GLenum+gl_COLOR_SUM_CLAMP_NV = 0x854F+gl_SAMPLER_CUBE :: GLenum+gl_SAMPLER_CUBE = 0x8B60+gl_FRACTIONAL_ODD :: GLenum+gl_FRACTIONAL_ODD = 0x8E7B+gl_ONE_MINUS_DST_COLOR :: GLenum+gl_ONE_MINUS_DST_COLOR = 0x0307+gl_REG_9_ATI :: GLenum+gl_REG_9_ATI = 0x892A+gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV :: GLenum+gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 0x9035+gl_PIXEL_MAP_I_TO_G :: GLenum+gl_PIXEL_MAP_I_TO_G = 0x0C73+gl_FOG_COORD_ARRAY_STRIDE :: GLenum+gl_FOG_COORD_ARRAY_STRIDE = 0x8455+gl_TRIANGLES_ADJACENCY_EXT :: GLenum+gl_TRIANGLES_ADJACENCY_EXT = 0x000C+gl_DRAW_BUFFER14_EXT :: GLenum+gl_DRAW_BUFFER14_EXT = 0x8833+gl_TEXTURE_COMPARE_MODE_ARB :: GLenum+gl_TEXTURE_COMPARE_MODE_ARB = 0x884C+gl_REFLECTION_MAP_OES :: GLenum+gl_REFLECTION_MAP_OES = 0x8512+gl_WARPS_PER_SM_NV :: GLenum+gl_WARPS_PER_SM_NV = 0x933A+gl_QUERY_WAIT :: GLenum+gl_QUERY_WAIT = 0x8E13+gl_COMPRESSED_SLUMINANCE_ALPHA :: GLenum+gl_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B+gl_MAP2_TEXTURE_COORD_3 :: GLenum+gl_MAP2_TEXTURE_COORD_3 = 0x0DB5+gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV :: GLenum+gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x08+gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV :: GLenum+gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1+gl_INTENSITY_FLOAT32_ATI :: GLenum+gl_INTENSITY_FLOAT32_ATI = 0x8817+gl_CLAMP_TO_BORDER_SGIS :: GLenum+gl_CLAMP_TO_BORDER_SGIS = 0x812D+gl_FIELDS_NV :: GLenum+gl_FIELDS_NV = 0x8E27+gl_MAX_GEOMETRY_OUTPUT_VERTICES :: GLenum+gl_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4+gl_INT_SAMPLER_CUBE_EXT :: GLenum+gl_INT_SAMPLER_CUBE_EXT = 0x8DCC+gl_SOURCE0_RGB_EXT :: GLenum+gl_SOURCE0_RGB_EXT = 0x8580+gl_DRAW_BUFFER10_ATI :: GLenum+gl_DRAW_BUFFER10_ATI = 0x882F+gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT :: GLenum+gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD+gl_COPY_WRITE_BUFFER_NV :: GLenum+gl_COPY_WRITE_BUFFER_NV = 0x8F37+gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV :: GLenum+gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 0x8E54+gl_LUMINANCE8_OES :: GLenum+gl_LUMINANCE8_OES = 0x8040+gl_POST_CONVOLUTION_RED_BIAS_EXT :: GLenum+gl_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020+gl_HSL_COLOR_KHR :: GLenum+gl_HSL_COLOR_KHR = 0x92AF+gl_SAMPLE_MASK_VALUE_NV :: GLenum+gl_SAMPLE_MASK_VALUE_NV = 0x8E52+gl_SLUMINANCE8_NV :: GLenum+gl_SLUMINANCE8_NV = 0x8C47+gl_ASYNC_MARKER_SGIX :: GLenum+gl_ASYNC_MARKER_SGIX = 0x8329+gl_TEXTURE17 :: GLenum+gl_TEXTURE17 = 0x84D1+gl_SYNC_CL_EVENT_COMPLETE_ARB :: GLenum+gl_SYNC_CL_EVENT_COMPLETE_ARB = 0x8241+gl_INVARIANT_VALUE_EXT :: GLenum+gl_INVARIANT_VALUE_EXT = 0x87EA+gl_BUMP_ROT_MATRIX_SIZE_ATI :: GLenum+gl_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776+gl_ACTIVE_VARYING_MAX_LENGTH_NV :: GLenum+gl_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82+gl_DEPTH_COMPONENT16 :: GLenum+gl_DEPTH_COMPONENT16 = 0x81A5+gl_MODELVIEW25_ARB :: GLenum+gl_MODELVIEW25_ARB = 0x8739+gl_SHADER_BINARY_VIV :: GLenum+gl_SHADER_BINARY_VIV = 0x8FC4+gl_VERTEX_ARRAY_STRIDE_EXT :: GLenum+gl_VERTEX_ARRAY_STRIDE_EXT = 0x807C+gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645+gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB :: GLenum+gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004+gl_MAX_PALETTE_MATRICES_ARB :: GLenum+gl_MAX_PALETTE_MATRICES_ARB = 0x8842+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA+gl_DEPTH_COMPONENT32_ARB :: GLenum+gl_DEPTH_COMPONENT32_ARB = 0x81A7+gl_PRESERVE_ATI :: GLenum+gl_PRESERVE_ATI = 0x8762+gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX :: GLenum+gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189+gl_VERTEX_PROGRAM_TWO_SIDE_NV :: GLenum+gl_VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643+gl_MAX_ELEMENTS_INDICES_EXT :: GLenum+gl_MAX_ELEMENTS_INDICES_EXT = 0x80E9+gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33+gl_CONTEXT_LOST :: GLenum+gl_CONTEXT_LOST = 0x0507+gl_VERTEX_SUBROUTINE_UNIFORM :: GLenum+gl_VERTEX_SUBROUTINE_UNIFORM = 0x92EE+gl_COMPRESSED_SRGB_EXT :: GLenum+gl_COMPRESSED_SRGB_EXT = 0x8C48+gl_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum+gl_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B+gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB :: GLenum+gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1+gl_STENCIL_INDEX_OES :: GLenum+gl_STENCIL_INDEX_OES = 0x1901+gl_PATH_INITIAL_END_CAP_NV :: GLenum+gl_PATH_INITIAL_END_CAP_NV = 0x9077+gl_INTENSITY32F_ARB :: GLenum+gl_INTENSITY32F_ARB = 0x8817+gl_SAMPLES_PASSED :: GLenum+gl_SAMPLES_PASSED = 0x8914+gl_INT_IMAGE_2D_RECT_EXT :: GLenum+gl_INT_IMAGE_2D_RECT_EXT = 0x905A+gl_CLIP_PLANE2 :: GLenum+gl_CLIP_PLANE2 = 0x3002+gl_PALETTE8_RGB8_OES :: GLenum+gl_PALETTE8_RGB8_OES = 0x8B95+gl_ALPHA16I_EXT :: GLenum+gl_ALPHA16I_EXT = 0x8D8A+gl_VERTEX_ARRAY :: GLenum+gl_VERTEX_ARRAY = 0x8074+gl_TEXTURE23_ARB :: GLenum+gl_TEXTURE23_ARB = 0x84D7+gl_AMBIENT_AND_DIFFUSE :: GLenum+gl_AMBIENT_AND_DIFFUSE = 0x1602+gl_MULTISAMPLE_BUFFER_BIT2_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT2_QCOM = 0x04000000+gl_LUMINANCE_FLOAT16_ATI :: GLenum+gl_LUMINANCE_FLOAT16_ATI = 0x881E+gl_INDEX_ARRAY_TYPE :: GLenum+gl_INDEX_ARRAY_TYPE = 0x8085+gl_COMPATIBLE_SUBROUTINES :: GLenum+gl_COMPATIBLE_SUBROUTINES = 0x8E4B+gl_VERTEX4_BIT_PGI :: GLenum+gl_VERTEX4_BIT_PGI = 0x00000008+gl_FOG_COORD_SRC :: GLenum+gl_FOG_COORD_SRC = 0x8450+gl_FULL_SUPPORT :: GLenum+gl_FULL_SUPPORT = 0x82B7+gl_STEREO :: GLenum+gl_STEREO = 0x0C33+gl_LUMINANCE_ALPHA16UI_EXT :: GLenum+gl_LUMINANCE_ALPHA16UI_EXT = 0x8D7B+gl_ONE_MINUS_SRC_COLOR :: GLenum+gl_ONE_MINUS_SRC_COLOR = 0x0301+gl_MAX_SHADER_STORAGE_BLOCK_SIZE :: GLenum+gl_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE+gl_REPLICATE_BORDER_HP :: GLenum+gl_REPLICATE_BORDER_HP = 0x8153+gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE = 0x8A04+gl_CPU_OPTIMIZED_QCOM :: GLenum+gl_CPU_OPTIMIZED_QCOM = 0x8FB1+gl_FLOAT16_VEC2_NV :: GLenum+gl_FLOAT16_VEC2_NV = 0x8FF9+gl_SAMPLE_ALPHA_TO_ONE_SGIS :: GLenum+gl_SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F+gl_MAP2_VERTEX_ATTRIB12_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB12_4_NV = 0x867C+gl_COMBINER_MUX_SUM_NV :: GLenum+gl_COMBINER_MUX_SUM_NV = 0x8547+gl_UNSIGNED_SHORT_5_6_5_REV_EXT :: GLenum+gl_UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364+gl_TEXTURE20_ARB :: GLenum+gl_TEXTURE20_ARB = 0x84D4+gl_DOT3_RGB :: GLenum+gl_DOT3_RGB = 0x86AE+gl_STENCIL_BUFFER_BIT0_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT0_QCOM = 0x00010000+gl_LO_SCALE_NV :: GLenum+gl_LO_SCALE_NV = 0x870F+gl_FONT_ASCENDER_BIT_NV :: GLenum+gl_FONT_ASCENDER_BIT_NV = 0x00200000+gl_DRAW_BUFFER9_EXT :: GLenum+gl_DRAW_BUFFER9_EXT = 0x882E+gl_UNSIGNED_INT_2_10_10_10_REV :: GLenum+gl_UNSIGNED_INT_2_10_10_10_REV = 0x8368+gl_BINNING_CONTROL_HINT_QCOM :: GLenum+gl_BINNING_CONTROL_HINT_QCOM = 0x8FB0+gl_PROGRAM_TEMPORARIES_ARB :: GLenum+gl_PROGRAM_TEMPORARIES_ARB = 0x88A4+gl_MODELVIEW27_ARB :: GLenum+gl_MODELVIEW27_ARB = 0x873B+gl_RGBA16F_EXT :: GLenum+gl_RGBA16F_EXT = 0x881A+gl_INDEX_ARRAY_TYPE_EXT :: GLenum+gl_INDEX_ARRAY_TYPE_EXT = 0x8085+gl_MAX_VERTEX_SHADER_LOCALS_EXT :: GLenum+gl_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES = 0x8519+gl_COMP_BIT_ATI :: GLenum+gl_COMP_BIT_ATI = 0x00000002+gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT :: GLenum+gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT = 0x8A2C+gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum+gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061+gl_RGB10_A2_EXT :: GLenum+gl_RGB10_A2_EXT = 0x8059+gl_MAP1_VERTEX_ATTRIB4_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB4_4_NV = 0x8664+gl_FLOAT_VEC3 :: GLenum+gl_FLOAT_VEC3 = 0x8B51+gl_DELETE_STATUS :: GLenum+gl_DELETE_STATUS = 0x8B80+gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI :: GLenum+gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4+gl_UNCORRELATED_NV :: GLenum+gl_UNCORRELATED_NV = 0x9282+gl_RELATIVE_SMALL_CW_ARC_TO_NV :: GLenum+gl_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F+gl_RGB_FLOAT16_ATI :: GLenum+gl_RGB_FLOAT16_ATI = 0x881B+gl_DRAW_BUFFER7_ATI :: GLenum+gl_DRAW_BUFFER7_ATI = 0x882C+gl_COMBINE_ALPHA_ARB :: GLenum+gl_COMBINE_ALPHA_ARB = 0x8572+gl_RESET_NOTIFICATION_STRATEGY_EXT :: GLenum+gl_RESET_NOTIFICATION_STRATEGY_EXT = 0x8256+gl_DRAW_BUFFER10_NV :: GLenum+gl_DRAW_BUFFER10_NV = 0x882F+gl_READ_PIXEL_DATA_RANGE_POINTER_NV :: GLenum+gl_READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D+gl_TRANSFORM_FEEDBACK_ACTIVE :: GLenum+gl_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4+gl_PROGRAM_PIPELINE_BINDING :: GLenum+gl_PROGRAM_PIPELINE_BINDING = 0x825A+gl_SRGB8_ALPHA8 :: GLenum+gl_SRGB8_ALPHA8 = 0x8C43+gl_COLOR_INDEX16_EXT :: GLenum+gl_COLOR_INDEX16_EXT = 0x80E7+gl_PHONG_WIN :: GLenum+gl_PHONG_WIN = 0x80EA+gl_MAX_TEXTURE_IMAGE_UNITS_NV :: GLenum+gl_MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872+gl_DSDT8_MAG8_NV :: GLenum+gl_DSDT8_MAG8_NV = 0x870A+gl_COPY_READ_BUFFER :: GLenum+gl_COPY_READ_BUFFER = 0x8F36+gl_RGBA16F :: GLenum+gl_RGBA16F = 0x881A+gl_UNSIGNED_SHORT_5_6_5 :: GLenum+gl_UNSIGNED_SHORT_5_6_5 = 0x8363+gl_CLIP_DISTANCE5 :: GLenum+gl_CLIP_DISTANCE5 = 0x3005+gl_TEXTURE_BINDING_3D_OES :: GLenum+gl_TEXTURE_BINDING_3D_OES = 0x806A+gl_IUI_V2F_EXT :: GLenum+gl_IUI_V2F_EXT = 0x81AD+gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV :: GLenum+gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855+gl_ONE_MINUS_CONSTANT_ALPHA :: GLenum+gl_ONE_MINUS_CONSTANT_ALPHA = 0x8004+gl_SMALL_CW_ARC_TO_NV :: GLenum+gl_SMALL_CW_ARC_TO_NV = 0x14+gl_IMAGE_BINDING_NAME_EXT :: GLenum+gl_IMAGE_BINDING_NAME_EXT = 0x8F3A+gl_CURRENT_FOG_COORDINATE_EXT :: GLenum+gl_CURRENT_FOG_COORDINATE_EXT = 0x8453+gl_SKIP_COMPONENTS4_NV :: GLenum+gl_SKIP_COMPONENTS4_NV = -3+gl_CLIP_PLANE5_IMG :: GLenum+gl_CLIP_PLANE5_IMG = 0x3005+gl_PATH_MITER_LIMIT_NV :: GLenum+gl_PATH_MITER_LIMIT_NV = 0x907A+gl_TEXTURE_3D :: GLenum+gl_TEXTURE_3D = 0x806F+gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB+gl_COMPRESSED_LUMINANCE_LATC1_EXT :: GLenum+gl_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70+gl_MULTISAMPLE_BUFFER_BIT3_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT3_QCOM = 0x08000000+gl_SECONDARY_COLOR_ARRAY_SIZE :: GLenum+gl_SECONDARY_COLOR_ARRAY_SIZE = 0x845A+gl_RENDERBUFFER_SAMPLES_IMG :: GLenum+gl_RENDERBUFFER_SAMPLES_IMG = 0x9133+gl_R1UI_C4UB_V3F_SUN :: GLenum+gl_R1UI_C4UB_V3F_SUN = 0x85C5+gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX :: GLenum+gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A+gl_TRANSFORM_FEEDBACK_NV :: GLenum+gl_TRANSFORM_FEEDBACK_NV = 0x8E22+gl_FRAMEBUFFER_RENDERABLE :: GLenum+gl_FRAMEBUFFER_RENDERABLE = 0x8289+gl_HARDLIGHT_KHR :: GLenum+gl_HARDLIGHT_KHR = 0x929B+gl_SOURCE0_ALPHA :: GLenum+gl_SOURCE0_ALPHA = 0x8588+gl_COMBINER4_NV :: GLenum+gl_COMBINER4_NV = 0x8554+gl_ELEMENT_ARRAY_BUFFER_BINDING :: GLenum+gl_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895+gl_TEXTURE10_ARB :: GLenum+gl_TEXTURE10_ARB = 0x84CA+gl_CURRENT_BINORMAL_EXT :: GLenum+gl_CURRENT_BINORMAL_EXT = 0x843C+gl_REG_26_ATI :: GLenum+gl_REG_26_ATI = 0x893B+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: GLenum+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1+gl_ACTIVE_VARYINGS_NV :: GLenum+gl_ACTIVE_VARYINGS_NV = 0x8C81+gl_COMBINE_RGB_EXT :: GLenum+gl_COMBINE_RGB_EXT = 0x8571+gl_FRAMEBUFFER_COMPLETE_EXT :: GLenum+gl_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5+gl_MAX_WIDTH :: GLenum+gl_MAX_WIDTH = 0x827E+gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS :: GLenum+gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5+gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum+gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8+gl_COLORDODGE_KHR :: GLenum+gl_COLORDODGE_KHR = 0x9299+gl_PATH_GEN_COEFF_NV :: GLenum+gl_PATH_GEN_COEFF_NV = 0x90B1+gl_FLOAT_MAT4x3_NV :: GLenum+gl_FLOAT_MAT4x3_NV = 0x8B6A+gl_MINMAX_SINK :: GLenum+gl_MINMAX_SINK = 0x8030+gl_FRONT_AND_BACK :: GLenum+gl_FRONT_AND_BACK = 0x0408+gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT :: GLenum+gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x8E5A+gl_MATRIX1_ARB :: GLenum+gl_MATRIX1_ARB = 0x88C1+gl_VIEWPORT_SUBPIXEL_BITS :: GLenum+gl_VIEWPORT_SUBPIXEL_BITS = 0x825C+gl_MAX_DUAL_SOURCE_DRAW_BUFFERS :: GLenum+gl_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC+gl_BOOL_VEC3_ARB :: GLenum+gl_BOOL_VEC3_ARB = 0x8B58+gl_OPERAND2_ALPHA :: GLenum+gl_OPERAND2_ALPHA = 0x859A+gl_MAX_DEBUG_GROUP_STACK_DEPTH :: GLenum+gl_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC+gl_PROGRAM :: GLenum+gl_PROGRAM = 0x82E2+gl_WEIGHT_ARRAY_SIZE_ARB :: GLenum+gl_WEIGHT_ARRAY_SIZE_ARB = 0x86AB+gl_BUFFER_GPU_ADDRESS_NV :: GLenum+gl_BUFFER_GPU_ADDRESS_NV = 0x8F1D+gl_ALPHA8_EXT :: GLenum+gl_ALPHA8_EXT = 0x803C+gl_RGBA_MODE :: GLenum+gl_RGBA_MODE = 0x0C31+gl_DUDV_ATI :: GLenum+gl_DUDV_ATI = 0x8779+gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD+gl_RESAMPLE_DECIMATE_OML :: GLenum+gl_RESAMPLE_DECIMATE_OML = 0x8989+gl_QUERY_BUFFER :: GLenum+gl_QUERY_BUFFER = 0x9192+gl_SINGLE_COLOR :: GLenum+gl_SINGLE_COLOR = 0x81F9+gl_INT_SAMPLER_RENDERBUFFER_NV :: GLenum+gl_INT_SAMPLER_RENDERBUFFER_NV = 0x8E57+gl_MAT_COLOR_INDEXES_BIT_PGI :: GLenum+gl_MAT_COLOR_INDEXES_BIT_PGI = 0x01000000+gl_MODELVIEW3_ARB :: GLenum+gl_MODELVIEW3_ARB = 0x8723+gl_TESS_CONTROL_OUTPUT_VERTICES_EXT :: GLenum+gl_TESS_CONTROL_OUTPUT_VERTICES_EXT = 0x8E75+gl_PIXEL_MAP_B_TO_B :: GLenum+gl_PIXEL_MAP_B_TO_B = 0x0C78+gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE = 0x8A02+gl_DOUBLE_MAT3 :: GLenum+gl_DOUBLE_MAT3 = 0x8F47+gl_MAX_COMBINED_UNIFORM_BLOCKS :: GLenum+gl_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT = 0x900D+gl_MAX_VERTEX_IMAGE_UNIFORMS :: GLenum+gl_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA+gl_QUERY_RESULT_NO_WAIT_AMD :: GLenum+gl_QUERY_RESULT_NO_WAIT_AMD = 0x9194+gl_MODELVIEW26_ARB :: GLenum+gl_MODELVIEW26_ARB = 0x873A+gl_DEPTH_COMPONENT24_OES :: GLenum+gl_DEPTH_COMPONENT24_OES = 0x81A6+gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB :: GLenum+gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E+gl_EVAL_VERTEX_ATTRIB6_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB6_NV = 0x86CC+gl_OUTPUT_TEXTURE_COORD24_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD24_EXT = 0x87B5+gl_COMPUTE_SHADER_BIT :: GLenum+gl_COMPUTE_SHADER_BIT = 0x00000020+gl_MATRIX7_ARB :: GLenum+gl_MATRIX7_ARB = 0x88C7+gl_RENDER :: GLenum+gl_RENDER = 0x1C00+gl_VERTEX_ATTRIB_BINDING :: GLenum+gl_VERTEX_ATTRIB_BINDING = 0x82D4+gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV :: GLenum+gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 0x9026+gl_TEXTURE_COORD_ARRAY_ADDRESS_NV :: GLenum+gl_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25+gl_UNSIGNED_INT_SAMPLER_2D_RECT :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB :: GLenum+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29+gl_GENERATE_MIPMAP_SGIS :: GLenum+gl_GENERATE_MIPMAP_SGIS = 0x8191+gl_SHADER_IMAGE_STORE :: GLenum+gl_SHADER_IMAGE_STORE = 0x82A5+gl_INT_SAMPLER_3D :: GLenum+gl_INT_SAMPLER_3D = 0x8DCB+gl_PROGRAM_BINARY_LENGTH :: GLenum+gl_PROGRAM_BINARY_LENGTH = 0x8741+gl_REFERENCED_BY_GEOMETRY_SHADER :: GLenum+gl_REFERENCED_BY_GEOMETRY_SHADER = 0x9309+gl_SHADER_IMAGE_ACCESS_BARRIER_BIT :: GLenum+gl_SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020+gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS :: GLenum+gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3+gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT :: GLenum+gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F+gl_LINE :: GLenum+gl_LINE = 0x1B01+gl_RENDERBUFFER_ALPHA_SIZE_EXT :: GLenum+gl_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53+gl_INTENSITY :: GLenum+gl_INTENSITY = 0x8049+gl_AFFINE_3D_NV :: GLenum+gl_AFFINE_3D_NV = 0x9094+gl_ADD_SIGNED_ARB :: GLenum+gl_ADD_SIGNED_ARB = 0x8574+gl_OBJECT_COMPILE_STATUS_ARB :: GLenum+gl_OBJECT_COMPILE_STATUS_ARB = 0x8B81+gl_RGB8I_EXT :: GLenum+gl_RGB8I_EXT = 0x8D8F+gl_COMMAND_BARRIER_BIT :: GLenum+gl_COMMAND_BARRIER_BIT = 0x00000040+gl_COMBINE_RGB :: GLenum+gl_COMBINE_RGB = 0x8571+gl_VERTEX_SHADER_BINDING_EXT :: GLenum+gl_VERTEX_SHADER_BINDING_EXT = 0x8781+gl_SECONDARY_COLOR_ARRAY_SIZE_EXT :: GLenum+gl_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A+gl_DEPTH_EXT :: GLenum+gl_DEPTH_EXT = 0x1801+gl_LINE_RESET_TOKEN :: GLenum+gl_LINE_RESET_TOKEN = 0x0707+gl_SMOOTH_POINT_SIZE_GRANULARITY :: GLenum+gl_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13+gl_SAMPLER_2D_MULTISAMPLE :: GLenum+gl_SAMPLER_2D_MULTISAMPLE = 0x9108+gl_PRIMARY_COLOR_ARB :: GLenum+gl_PRIMARY_COLOR_ARB = 0x8577+gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY :: GLenum+gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103+gl_GEOMETRY_TEXTURE :: GLenum+gl_GEOMETRY_TEXTURE = 0x829E+gl_SOURCE1_RGB_ARB :: GLenum+gl_SOURCE1_RGB_ARB = 0x8581+gl_COLOR_ATTACHMENT6_EXT :: GLenum+gl_COLOR_ATTACHMENT6_EXT = 0x8CE6+gl_PIXEL_MAP_I_TO_I :: GLenum+gl_PIXEL_MAP_I_TO_I = 0x0C70+gl_EVAL_VERTEX_ATTRIB7_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB7_NV = 0x86CD+gl_OP_MIN_EXT :: GLenum+gl_OP_MIN_EXT = 0x878B+gl_RGB16F_EXT :: GLenum+gl_RGB16F_EXT = 0x881B+gl_TEXTURE_CUBE_MAP_POSITIVE_Z :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519+gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS :: GLenum+gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39+gl_PACK_RESAMPLE_SGIX :: GLenum+gl_PACK_RESAMPLE_SGIX = 0x842C+gl_GREEN_BIAS :: GLenum+gl_GREEN_BIAS = 0x0D19+gl_DEPTH_STENCIL_NV :: GLenum+gl_DEPTH_STENCIL_NV = 0x84F9+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8+gl_CON_29_ATI :: GLenum+gl_CON_29_ATI = 0x895E+gl_COLOR_ARRAY_STRIDE_EXT :: GLenum+gl_COLOR_ARRAY_STRIDE_EXT = 0x8083+gl_ISOLINES_EXT :: GLenum+gl_ISOLINES_EXT = 0x8E7A+gl_MODELVIEW4_ARB :: GLenum+gl_MODELVIEW4_ARB = 0x8724+gl_LINES_ADJACENCY :: GLenum+gl_LINES_ADJACENCY = 0x000A+gl_PATH_FILL_MASK_NV :: GLenum+gl_PATH_FILL_MASK_NV = 0x9081+gl_HISTOGRAM_LUMINANCE_SIZE :: GLenum+gl_HISTOGRAM_LUMINANCE_SIZE = 0x802C+gl_TEXTURE_BINDING_RENDERBUFFER_NV :: GLenum+gl_TEXTURE_BINDING_RENDERBUFFER_NV = 0x8E53+gl_PIXEL_UNPACK_BUFFER_EXT :: GLenum+gl_PIXEL_UNPACK_BUFFER_EXT = 0x88EC+gl_RENDERBUFFER_GREEN_SIZE :: GLenum+gl_RENDERBUFFER_GREEN_SIZE = 0x8D51+gl_PASS_THROUGH_NV :: GLenum+gl_PASS_THROUGH_NV = 0x86E6+gl_GEOMETRY_VERTICES_OUT_EXT :: GLenum+gl_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA+gl_EVAL_VERTEX_ATTRIB12_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB12_NV = 0x86D2+gl_SMOOTH_QUADRATIC_CURVE_TO_NV :: GLenum+gl_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0E+gl_TEXTURE_BUFFER_SIZE :: GLenum+gl_TEXTURE_BUFFER_SIZE = 0x919E+gl_READ_PIXEL_DATA_RANGE_NV :: GLenum+gl_READ_PIXEL_DATA_RANGE_NV = 0x8879+gl_ALIASED_LINE_WIDTH_RANGE :: GLenum+gl_ALIASED_LINE_WIDTH_RANGE = 0x846E+gl_TRACK_MATRIX_NV :: GLenum+gl_TRACK_MATRIX_NV = 0x8648+gl_COLOR_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_COLOR_ARRAY_LIST_STRIDE_IBM = 103082+gl_WEIGHT_ARRAY_POINTER_ARB :: GLenum+gl_WEIGHT_ARRAY_POINTER_ARB = 0x86AC+gl_SMOOTH_LINE_WIDTH_GRANULARITY :: GLenum+gl_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23+gl_CLIP_DISTANCE6 :: GLenum+gl_CLIP_DISTANCE6 = 0x3006+gl_FRAMEBUFFER_BINDING :: GLenum+gl_FRAMEBUFFER_BINDING = 0x8CA6+gl_EVAL_VERTEX_ATTRIB4_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB4_NV = 0x86CA+gl_CURRENT_SECONDARY_COLOR_EXT :: GLenum+gl_CURRENT_SECONDARY_COLOR_EXT = 0x8459+gl_IMAGE_CLASS_2_X_32 :: GLenum+gl_IMAGE_CLASS_2_X_32 = 0x82BA+gl_PERSPECTIVE_CORRECTION_HINT :: GLenum+gl_PERSPECTIVE_CORRECTION_HINT = 0x0C50+gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI :: GLenum+gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203+gl_SATURATE_BIT_ATI :: GLenum+gl_SATURATE_BIT_ATI = 0x00000040+gl_FONT_UNITS_PER_EM_BIT_NV :: GLenum+gl_FONT_UNITS_PER_EM_BIT_NV = 0x00100000+gl_EVAL_VERTEX_ATTRIB3_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB3_NV = 0x86C9+gl_R16UI :: GLenum+gl_R16UI = 0x8234+gl_OUTPUT_TEXTURE_COORD17_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD17_EXT = 0x87AE+gl_TEXTURE_MULTI_BUFFER_HINT_SGIX :: GLenum+gl_TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E+gl_SKIP_MISSING_GLYPH_NV :: GLenum+gl_SKIP_MISSING_GLYPH_NV = 0x90A9+gl_MIRROR_CLAMP_TO_EDGE_EXT :: GLenum+gl_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743+gl_TEXTURE_TYPE_QCOM :: GLenum+gl_TEXTURE_TYPE_QCOM = 0x8BD7+gl_RGB5_A1 :: GLenum+gl_RGB5_A1 = 0x8057+gl_UNIFORM_BARRIER_BIT_EXT :: GLenum+gl_UNIFORM_BARRIER_BIT_EXT = 0x00000004+gl_MULTISAMPLE :: GLenum+gl_MULTISAMPLE = 0x809D+gl_SAMPLES_ARB :: GLenum+gl_SAMPLES_ARB = 0x80A9+gl_RGBA_INTEGER :: GLenum+gl_RGBA_INTEGER = 0x8D99+gl_STENCIL_COMPONENTS :: GLenum+gl_STENCIL_COMPONENTS = 0x8285+gl_DEBUG_SEVERITY_LOW :: GLenum+gl_DEBUG_SEVERITY_LOW = 0x9148+gl_TEXTURE_COMPARE_SGIX :: GLenum+gl_TEXTURE_COMPARE_SGIX = 0x819A+gl_COLOR_ARRAY_LIST_IBM :: GLenum+gl_COLOR_ARRAY_LIST_IBM = 103072+gl_COMPRESSED_SIGNED_RED_RGTC1 :: GLenum+gl_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC+gl_MATRIX3_NV :: GLenum+gl_MATRIX3_NV = 0x8633+gl_MAX_FRAGMENT_UNIFORM_BLOCKS :: GLenum+gl_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D+gl_INT_SAMPLER_3D_EXT :: GLenum+gl_INT_SAMPLER_3D_EXT = 0x8DCB+gl_MODELVIEW19_ARB :: GLenum+gl_MODELVIEW19_ARB = 0x8733+gl_SWIZZLE_STRQ_DQ_ATI :: GLenum+gl_SWIZZLE_STRQ_DQ_ATI = 0x897B+gl_COMBINE_ARB :: GLenum+gl_COMBINE_ARB = 0x8570+gl_FRAGMENT_COLOR_EXT :: GLenum+gl_FRAGMENT_COLOR_EXT = 0x834C+gl_RENDERBUFFER_WIDTH :: GLenum+gl_RENDERBUFFER_WIDTH = 0x8D42+gl_LUMINANCE4_EXT :: GLenum+gl_LUMINANCE4_EXT = 0x803F+gl_UNSIGNED_INT_SAMPLER_2D_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2+gl_RGB_SCALE_EXT :: GLenum+gl_RGB_SCALE_EXT = 0x8573+gl_PIXEL_MAP_I_TO_R :: GLenum+gl_PIXEL_MAP_I_TO_R = 0x0C72+gl_DOT4_ATI :: GLenum+gl_DOT4_ATI = 0x8967+gl_MAP1_VERTEX_ATTRIB7_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB7_4_NV = 0x8667+gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622+gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C+gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI :: GLenum+gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6+gl_NUM_VIRTUAL_PAGE_SIZES_ARB :: GLenum+gl_NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8+gl_RENDERBUFFER_FREE_MEMORY_ATI :: GLenum+gl_RENDERBUFFER_FREE_MEMORY_ATI = 0x87FD+gl_FRAMEBUFFER_DEFAULT_LAYERS :: GLenum+gl_FRAMEBUFFER_DEFAULT_LAYERS = 0x9312+gl_COMPUTE_SUBROUTINE :: GLenum+gl_COMPUTE_SUBROUTINE = 0x92ED+gl_PROGRAM_TEX_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806+gl_SIGNALED_APPLE :: GLenum+gl_SIGNALED_APPLE = 0x9119+gl_MULTISAMPLE_3DFX :: GLenum+gl_MULTISAMPLE_3DFX = 0x86B2+gl_TEXTURE_INDEX_SIZE_EXT :: GLenum+gl_TEXTURE_INDEX_SIZE_EXT = 0x80ED+gl_LAYOUT_LINEAR_INTEL :: GLenum+gl_LAYOUT_LINEAR_INTEL = 1+gl_LERP_ATI :: GLenum+gl_LERP_ATI = 0x8969+gl_FACTOR_MAX_AMD :: GLenum+gl_FACTOR_MAX_AMD = 0x901D+gl_MATRIX2_ARB :: GLenum+gl_MATRIX2_ARB = 0x88C2+gl_EQUAL :: GLenum+gl_EQUAL = 0x0202+gl_COLOR_ATTACHMENT0_OES :: GLenum+gl_COLOR_ATTACHMENT0_OES = 0x8CE0+gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI :: GLenum+gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3+gl_RGB16 :: GLenum+gl_RGB16 = 0x8054+gl_COLOR_INDEX4_EXT :: GLenum+gl_COLOR_INDEX4_EXT = 0x80E4+gl_PROXY_TEXTURE_CUBE_MAP_EXT :: GLenum+gl_PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B+gl_STENCIL_BACK_FUNC_ATI :: GLenum+gl_STENCIL_BACK_FUNC_ATI = 0x8800+gl_DRAW_BUFFER8_EXT :: GLenum+gl_DRAW_BUFFER8_EXT = 0x882D+gl_DST_ALPHA :: GLenum+gl_DST_ALPHA = 0x0304+gl_DEBUG_SOURCE_SHADER_COMPILER_KHR :: GLenum+gl_DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248+gl_C4UB_V2F :: GLenum+gl_C4UB_V2F = 0x2A22+gl_INTERNALFORMAT_BLUE_TYPE :: GLenum+gl_INTERNALFORMAT_BLUE_TYPE = 0x827A+gl_PIXEL_TILE_GRID_DEPTH_SGIX :: GLenum+gl_PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144+gl_DEPTH_BITS :: GLenum+gl_DEPTH_BITS = 0x0D56+gl_FLOAT16_VEC3_NV :: GLenum+gl_FLOAT16_VEC3_NV = 0x8FFA+gl_ARRAY_OBJECT_OFFSET_ATI :: GLenum+gl_ARRAY_OBJECT_OFFSET_ATI = 0x8767+gl_DOUBLE_MAT2_EXT :: GLenum+gl_DOUBLE_MAT2_EXT = 0x8F46+gl_TEXTURE_COLOR_SAMPLES_NV :: GLenum+gl_TEXTURE_COLOR_SAMPLES_NV = 0x9046+gl_NORMAL_ARRAY_EXT :: GLenum+gl_NORMAL_ARRAY_EXT = 0x8075+gl_MIRROR_CLAMP_TO_EDGE_ATI :: GLenum+gl_MIRROR_CLAMP_TO_EDGE_ATI = 0x8743+gl_EDGE_FLAG_ARRAY_POINTER :: GLenum+gl_EDGE_FLAG_ARRAY_POINTER = 0x8093+gl_UNSIGNED_INT_24_8_MESA :: GLenum+gl_UNSIGNED_INT_24_8_MESA = 0x8751+gl_IMAGE_COMPATIBILITY_CLASS :: GLenum+gl_IMAGE_COMPATIBILITY_CLASS = 0x82A8+gl_BACK_LEFT :: GLenum+gl_BACK_LEFT = 0x0402+gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB :: GLenum+gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2+gl_COLOR_TABLE_BIAS :: GLenum+gl_COLOR_TABLE_BIAS = 0x80D7+gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG :: GLenum+gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG = 0x93F1+gl_DARKEN_KHR :: GLenum+gl_DARKEN_KHR = 0x9297+gl_OCCLUSION_TEST_RESULT_HP :: GLenum+gl_OCCLUSION_TEST_RESULT_HP = 0x8166+gl_DEBUG_TYPE_POP_GROUP_KHR :: GLenum+gl_DEBUG_TYPE_POP_GROUP_KHR = 0x826A+gl_CLAMP_TO_BORDER_ARB :: GLenum+gl_CLAMP_TO_BORDER_ARB = 0x812D+gl_UNSIGNED_BYTE_2_3_3_REV :: GLenum+gl_UNSIGNED_BYTE_2_3_3_REV = 0x8362+gl_SOURCE2_ALPHA_ARB :: GLenum+gl_SOURCE2_ALPHA_ARB = 0x858A+gl_SAMPLE_COVERAGE :: GLenum+gl_SAMPLE_COVERAGE = 0x80A0+gl_INTERLEAVED_ATTRIBS_EXT :: GLenum+gl_INTERLEAVED_ATTRIBS_EXT = 0x8C8C+gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB+gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: GLenum+gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F+gl_VERTEX_SHADER :: GLenum+gl_VERTEX_SHADER = 0x8B31+gl_INDEX_ARRAY_ADDRESS_NV :: GLenum+gl_INDEX_ARRAY_ADDRESS_NV = 0x8F24+gl_QUERY_COUNTER_BITS :: GLenum+gl_QUERY_COUNTER_BITS = 0x8864+gl_COMPRESSED_RGBA_ASTC_8x6_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6+gl_FRAMEBUFFER_BINDING_EXT :: GLenum+gl_FRAMEBUFFER_BINDING_EXT = 0x8CA6+gl_VERTEX_ELEMENT_SWIZZLE_AMD :: GLenum+gl_VERTEX_ELEMENT_SWIZZLE_AMD = 0x91A4+gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD :: GLenum+gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 0x914E+gl_ARRAY_OBJECT_BUFFER_ATI :: GLenum+gl_ARRAY_OBJECT_BUFFER_ATI = 0x8766+gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum+gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910C+gl_RENDERBUFFER_INTERNAL_FORMAT :: GLenum+gl_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44+gl_VIEW_CLASS_8_BITS :: GLenum+gl_VIEW_CLASS_8_BITS = 0x82CB+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES = 0x8517+gl_SHADER_IMAGE_ATOMIC :: GLenum+gl_SHADER_IMAGE_ATOMIC = 0x82A6+gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB :: GLenum+gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0+gl_COVERAGE_ATTACHMENT_NV :: GLenum+gl_COVERAGE_ATTACHMENT_NV = 0x8ED2+gl_NUM_PROGRAM_BINARY_FORMATS_OES :: GLenum+gl_NUM_PROGRAM_BINARY_FORMATS_OES = 0x87FE+gl_CURRENT_RASTER_TEXTURE_COORDS :: GLenum+gl_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06+gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS :: GLenum+gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86+gl_PIXEL_MAP_A_TO_A :: GLenum+gl_PIXEL_MAP_A_TO_A = 0x0C79+gl_TEXTURE_WRAP_T :: GLenum+gl_TEXTURE_WRAP_T = 0x2803+gl_LINE_SMOOTH_HINT :: GLenum+gl_LINE_SMOOTH_HINT = 0x0C52+gl_DRAW_BUFFER11_EXT :: GLenum+gl_DRAW_BUFFER11_EXT = 0x8830+gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV :: GLenum+gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D+gl_LUMINANCE16_SNORM :: GLenum+gl_LUMINANCE16_SNORM = 0x9019+gl_PERFQUERY_FLUSH_INTEL :: GLenum+gl_PERFQUERY_FLUSH_INTEL = 0x83FA+gl_HISTOGRAM_SINK :: GLenum+gl_HISTOGRAM_SINK = 0x802D+gl_MAP1_VERTEX_ATTRIB15_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB15_4_NV = 0x866F+gl_OUTPUT_TEXTURE_COORD7_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD7_EXT = 0x87A4+gl_HISTOGRAM_BLUE_SIZE :: GLenum+gl_HISTOGRAM_BLUE_SIZE = 0x802A+gl_LUMINANCE32F_EXT :: GLenum+gl_LUMINANCE32F_EXT = 0x8818+gl_RG16UI :: GLenum+gl_RG16UI = 0x823A+gl_TEXTURE_ALPHA_MODULATE_IMG :: GLenum+gl_TEXTURE_ALPHA_MODULATE_IMG = 0x8C06+gl_INT_SAMPLER_2D_RECT :: GLenum+gl_INT_SAMPLER_2D_RECT = 0x8DCD+gl_STENCIL_BACK_WRITEMASK :: GLenum+gl_STENCIL_BACK_WRITEMASK = 0x8CA5+gl_PIXEL_TRANSFORM_2D_MATRIX_EXT :: GLenum+gl_PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338+gl_AUX3 :: GLenum+gl_AUX3 = 0x040C+gl_FRAMEBUFFER_UNSUPPORTED :: GLenum+gl_FRAMEBUFFER_UNSUPPORTED = 0x8CDD+gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT :: GLenum+gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF+gl_TEXTURE_DEFORMATION_SGIX :: GLenum+gl_TEXTURE_DEFORMATION_SGIX = 0x8195+gl_CON_23_ATI :: GLenum+gl_CON_23_ATI = 0x8958+gl_CLIP_DISTANCE0 :: GLenum+gl_CLIP_DISTANCE0 = 0x3000+gl_COLOR_ATTACHMENT10 :: GLenum+gl_COLOR_ATTACHMENT10 = 0x8CEA+gl_POINT_SIZE_MAX_EXT :: GLenum+gl_POINT_SIZE_MAX_EXT = 0x8127+gl_TEXTURE5 :: GLenum+gl_TEXTURE5 = 0x84C5+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6+gl_PATH_MODELVIEW_MATRIX_NV :: GLenum+gl_PATH_MODELVIEW_MATRIX_NV = 0x0BA6+gl_LINE_LOOP :: GLenum+gl_LINE_LOOP = 0x0002+gl_MODELVIEW17_ARB :: GLenum+gl_MODELVIEW17_ARB = 0x8731+gl_UNSIGNED_INT16_VEC2_NV :: GLenum+gl_UNSIGNED_INT16_VEC2_NV = 0x8FF1+gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum+gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898F+gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264+gl_DRAW_BUFFER3_EXT :: GLenum+gl_DRAW_BUFFER3_EXT = 0x8828+gl_TEXTURE_SHADOW :: GLenum+gl_TEXTURE_SHADOW = 0x82A1+gl_STENCIL_ATTACHMENT :: GLenum+gl_STENCIL_ATTACHMENT = 0x8D20+gl_MAP_STENCIL :: GLenum+gl_MAP_STENCIL = 0x0D11+gl_PATH_DASH_ARRAY_COUNT_NV :: GLenum+gl_PATH_DASH_ARRAY_COUNT_NV = 0x909F+gl_BLEND :: GLenum+gl_BLEND = 0x0BE2+gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT :: GLenum+gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34+gl_TEXTURE_TARGET_QCOM :: GLenum+gl_TEXTURE_TARGET_QCOM = 0x8BDA+gl_NORMAL_MAP_OES :: GLenum+gl_NORMAL_MAP_OES = 0x8511+gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT :: GLenum+gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365+gl_TEXTURE20 :: GLenum+gl_TEXTURE20 = 0x84D4+gl_EDGE_FLAG_ARRAY_COUNT_EXT :: GLenum+gl_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D+gl_SMOOTH :: GLenum+gl_SMOOTH = 0x1D01+gl_SHADER_INCLUDE_ARB :: GLenum+gl_SHADER_INCLUDE_ARB = 0x8DAE+gl_CLAMP_TO_EDGE_SGIS :: GLenum+gl_CLAMP_TO_EDGE_SGIS = 0x812F+gl_COMPRESSED_ALPHA :: GLenum+gl_COMPRESSED_ALPHA = 0x84E9+gl_TEXTURE_IMAGE_FORMAT :: GLenum+gl_TEXTURE_IMAGE_FORMAT = 0x828F+gl_MAX_FRAMEBUFFER_LAYERS :: GLenum+gl_MAX_FRAMEBUFFER_LAYERS = 0x9317+gl_WRITEONLY_RENDERING_QCOM :: GLenum+gl_WRITEONLY_RENDERING_QCOM = 0x8823+gl_BACK_RIGHT :: GLenum+gl_BACK_RIGHT = 0x0403+gl_INVARIANT_DATATYPE_EXT :: GLenum+gl_INVARIANT_DATATYPE_EXT = 0x87EB+gl_LINE_TO_NV :: GLenum+gl_LINE_TO_NV = 0x04+gl_PIXEL_UNPACK_BUFFER_BINDING_ARB :: GLenum+gl_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF+gl_LIST_BIT :: GLenum+gl_LIST_BIT = 0x00020000+gl_MAX_ATTRIB_STACK_DEPTH :: GLenum+gl_MAX_ATTRIB_STACK_DEPTH = 0x0D35+gl_FRAGMENT_SHADER :: GLenum+gl_FRAGMENT_SHADER = 0x8B30+gl_IMPLEMENTATION_COLOR_READ_FORMAT :: GLenum+gl_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B+gl_COLOR_TABLE_WIDTH_SGI :: GLenum+gl_COLOR_TABLE_WIDTH_SGI = 0x80D9+gl_DEBUG_OBJECT_MESA :: GLenum+gl_DEBUG_OBJECT_MESA = 0x8759+gl_EYE_LINE_SGIS :: GLenum+gl_EYE_LINE_SGIS = 0x81F6+gl_COMPRESSED_ALPHA_ARB :: GLenum+gl_COMPRESSED_ALPHA_ARB = 0x84E9+gl_DEPTH_BUFFER_BIT7_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT7_QCOM = 0x00008000+gl_OPERAND2_RGB_ARB :: GLenum+gl_OPERAND2_RGB_ARB = 0x8592+gl_PROGRAM_BINARY_ANGLE :: GLenum+gl_PROGRAM_BINARY_ANGLE = 0x93A6+gl_MATRIX_EXT :: GLenum+gl_MATRIX_EXT = 0x87C0+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80+gl_RED_NV :: GLenum+gl_RED_NV = 0x1903+gl_LIGHT7 :: GLenum+gl_LIGHT7 = 0x4007+gl_LOW_FLOAT :: GLenum+gl_LOW_FLOAT = 0x8DF0+gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 0x8C7F+gl_CON_18_ATI :: GLenum+gl_CON_18_ATI = 0x8953+gl_UNIFORM_BUFFER_ADDRESS_NV :: GLenum+gl_UNIFORM_BUFFER_ADDRESS_NV = 0x936F+gl_VERTEX_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896+gl_RED_BIT_ATI :: GLenum+gl_RED_BIT_ATI = 0x00000001+gl_TRACE_TEXTURES_BIT_MESA :: GLenum+gl_TRACE_TEXTURES_BIT_MESA = 0x0008+gl_GEOMETRY_SHADER :: GLenum+gl_GEOMETRY_SHADER = 0x8DD9+gl_VERTEX_ARRAY_ADDRESS_NV :: GLenum+gl_VERTEX_ARRAY_ADDRESS_NV = 0x8F21+gl_TIMEOUT_IGNORED_APPLE :: GLenum+gl_TIMEOUT_IGNORED_APPLE = 0xFFFFFFFFFFFFFFFF+gl_RENDERBUFFER_BINDING :: GLenum+gl_RENDERBUFFER_BINDING = 0x8CA7+gl_RGB16F :: GLenum+gl_RGB16F = 0x881B+gl_TEXTURE_COORD_ARRAY_LENGTH_NV :: GLenum+gl_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F+gl_MAX_FRAMEBUFFER_LAYERS_EXT :: GLenum+gl_MAX_FRAMEBUFFER_LAYERS_EXT = 0x9317+gl_MODELVIEW23_ARB :: GLenum+gl_MODELVIEW23_ARB = 0x8737+gl_BGR_EXT :: GLenum+gl_BGR_EXT = 0x80E0+gl_ONE_MINUS_SRC1_COLOR :: GLenum+gl_ONE_MINUS_SRC1_COLOR = 0x88FA+gl_VARIANT_ARRAY_EXT :: GLenum+gl_VARIANT_ARRAY_EXT = 0x87E8+gl_RGB4 :: GLenum+gl_RGB4 = 0x804F+gl_RENDERBUFFER_DEPTH_SIZE_OES :: GLenum+gl_RENDERBUFFER_DEPTH_SIZE_OES = 0x8D54+gl_MAX_VARYING_COMPONENTS_EXT :: GLenum+gl_MAX_VARYING_COMPONENTS_EXT = 0x8B4B+gl_CURRENT_MATRIX_NV :: GLenum+gl_CURRENT_MATRIX_NV = 0x8641+gl_T2F_IUI_N3F_V3F_EXT :: GLenum+gl_T2F_IUI_N3F_V3F_EXT = 0x81B4+gl_SLUMINANCE8 :: GLenum+gl_SLUMINANCE8 = 0x8C47+gl_MODELVIEW1_MATRIX_EXT :: GLenum+gl_MODELVIEW1_MATRIX_EXT = 0x8506+gl_MODELVIEW29_ARB :: GLenum+gl_MODELVIEW29_ARB = 0x873D+gl_COLOR_ATTACHMENT5_EXT :: GLenum+gl_COLOR_ATTACHMENT5_EXT = 0x8CE5+gl_DOUBLE_MAT2 :: GLenum+gl_DOUBLE_MAT2 = 0x8F46+gl_RGBA12_EXT :: GLenum+gl_RGBA12_EXT = 0x805A+gl_ACCUM_BLUE_BITS :: GLenum+gl_ACCUM_BLUE_BITS = 0x0D5A+gl_INVARIANT_EXT :: GLenum+gl_INVARIANT_EXT = 0x87C2+gl_ACTIVE_UNIFORM_MAX_LENGTH :: GLenum+gl_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87+gl_FOG_SPECULAR_TEXTURE_WIN :: GLenum+gl_FOG_SPECULAR_TEXTURE_WIN = 0x80EC+gl_COLOR_TABLE_SCALE_SGI :: GLenum+gl_COLOR_TABLE_SCALE_SGI = 0x80D6+gl_IUI_V3F_EXT :: GLenum+gl_IUI_V3F_EXT = 0x81AE+gl_UNSIGNED_INT_IMAGE_3D_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_3D_EXT = 0x9064+gl_MAX_DEBUG_MESSAGE_LENGTH_KHR :: GLenum+gl_MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143+gl_TEXTURE_CUBE_MAP_POSITIVE_Y :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517+gl_DOUBLE_VEC2 :: GLenum+gl_DOUBLE_VEC2 = 0x8FFC+gl_MAX_SAMPLE_MASK_WORDS :: GLenum+gl_MAX_SAMPLE_MASK_WORDS = 0x8E59+gl_DEBUG_OUTPUT :: GLenum+gl_DEBUG_OUTPUT = 0x92E0+gl_OBJECT_SHADER_SOURCE_LENGTH_ARB :: GLenum+gl_OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88+gl_R32F_EXT :: GLenum+gl_R32F_EXT = 0x822E+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV = 0x8C4E+gl_COPY_WRITE_BUFFER_BINDING :: GLenum+gl_COPY_WRITE_BUFFER_BINDING = 0x8F37+gl_TEXTURE15_ARB :: GLenum+gl_TEXTURE15_ARB = 0x84CF+gl_UNIFORM_BLOCK_NAME_LENGTH :: GLenum+gl_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41+gl_COLOR_ATTACHMENT4_NV :: GLenum+gl_COLOR_ATTACHMENT4_NV = 0x8CE4+gl_DST_OVER_NV :: GLenum+gl_DST_OVER_NV = 0x9289+gl_ATOMIC_COUNTER_BUFFER :: GLenum+gl_ATOMIC_COUNTER_BUFFER = 0x92C0+gl_MAP1_VERTEX_ATTRIB12_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB12_4_NV = 0x866C+gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB :: GLenum+gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C+gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV :: GLenum+gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3+gl_RGB_RAW_422_APPLE :: GLenum+gl_RGB_RAW_422_APPLE = 0x8A51+gl_MAX_RECTANGLE_TEXTURE_SIZE :: GLenum+gl_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8+gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7+gl_FRAGMENT_COLOR_MATERIAL_SGIX :: GLenum+gl_FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401+gl_POST_COLOR_MATRIX_RED_SCALE_SGI :: GLenum+gl_POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4+gl_VIBRANCE_SCALE_NV :: GLenum+gl_VIBRANCE_SCALE_NV = 0x8713+gl_POINT_FADE_THRESHOLD_SIZE :: GLenum+gl_POINT_FADE_THRESHOLD_SIZE = 0x8128+gl_QUERY_NO_WAIT_NV :: GLenum+gl_QUERY_NO_WAIT_NV = 0x8E14+gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES :: GLenum+gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B+gl_RESAMPLE_REPLICATE_OML :: GLenum+gl_RESAMPLE_REPLICATE_OML = 0x8986+gl_RENDERBUFFER_BINDING_ANGLE :: GLenum+gl_RENDERBUFFER_BINDING_ANGLE = 0x8CA7+gl_R1UI_V3F_SUN :: GLenum+gl_R1UI_V3F_SUN = 0x85C4+gl_CONVOLUTION_2D :: GLenum+gl_CONVOLUTION_2D = 0x8011+gl_OBJECT_TYPE :: GLenum+gl_OBJECT_TYPE = 0x9112+gl_MAX_MAP_TESSELLATION_NV :: GLenum+gl_MAX_MAP_TESSELLATION_NV = 0x86D6+gl_DOUBLE_MAT4x3_EXT :: GLenum+gl_DOUBLE_MAT4x3_EXT = 0x8F4E+gl_MULTISAMPLE_BUFFER_BIT4_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT4_QCOM = 0x10000000+gl_UNSIGNED_INT64_AMD :: GLenum+gl_UNSIGNED_INT64_AMD = 0x8BC2+gl_MAX_PATCH_VERTICES :: GLenum+gl_MAX_PATCH_VERTICES = 0x8E7D+gl_TEXTURE_COMPONENTS :: GLenum+gl_TEXTURE_COMPONENTS = 0x1003+gl_ELEMENT_ARRAY_POINTER_APPLE :: GLenum+gl_ELEMENT_ARRAY_POINTER_APPLE = 0x8A0E+gl_COLOR_ATTACHMENT6_NV :: GLenum+gl_COLOR_ATTACHMENT6_NV = 0x8CE6+gl_MODELVIEW_PROJECTION_NV :: GLenum+gl_MODELVIEW_PROJECTION_NV = 0x8629+gl_STATIC_ATI :: GLenum+gl_STATIC_ATI = 0x8760+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A+gl_CONVOLUTION_BORDER_MODE :: GLenum+gl_CONVOLUTION_BORDER_MODE = 0x8013+gl_2PASS_0_SGIS :: GLenum+gl_2PASS_0_SGIS = 0x80A2+gl_GREEN_INTEGER_EXT :: GLenum+gl_GREEN_INTEGER_EXT = 0x8D95+gl_DEBUG_TYPE_OTHER :: GLenum+gl_DEBUG_TYPE_OTHER = 0x8251+gl_FRAMEBUFFER_SRGB_EXT :: GLenum+gl_FRAMEBUFFER_SRGB_EXT = 0x8DB9+gl_COLOR_WRITEMASK :: GLenum+gl_COLOR_WRITEMASK = 0x0C23+gl_TANGENT_ARRAY_EXT :: GLenum+gl_TANGENT_ARRAY_EXT = 0x8439+gl_FONT_TARGET_UNAVAILABLE_NV :: GLenum+gl_FONT_TARGET_UNAVAILABLE_NV = 0x9369+gl_FONT_UNAVAILABLE_NV :: GLenum+gl_FONT_UNAVAILABLE_NV = 0x936A+gl_COMBINER2_NV :: GLenum+gl_COMBINER2_NV = 0x8552+gl_TEXTURE22_ARB :: GLenum+gl_TEXTURE22_ARB = 0x84D6+gl_PATH_INITIAL_DASH_CAP_NV :: GLenum+gl_PATH_INITIAL_DASH_CAP_NV = 0x907C+gl_SWIZZLE_STRQ_ATI :: GLenum+gl_SWIZZLE_STRQ_ATI = 0x897A+gl_OBJECT_LINE_SGIS :: GLenum+gl_OBJECT_LINE_SGIS = 0x81F7+gl_MAX_NUM_ACTIVE_VARIABLES :: GLenum+gl_MAX_NUM_ACTIVE_VARIABLES = 0x92F7+gl_COLOR_ATTACHMENT3_EXT :: GLenum+gl_COLOR_ATTACHMENT3_EXT = 0x8CE3+gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI :: GLenum+gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI = 0x8837+gl_SCREEN_KHR :: GLenum+gl_SCREEN_KHR = 0x9295+gl_ZOOM_X :: GLenum+gl_ZOOM_X = 0x0D16+gl_PROGRAM_MATRIX_EXT :: GLenum+gl_PROGRAM_MATRIX_EXT = 0x8E2D+gl_TEXTURE_VIEW :: GLenum+gl_TEXTURE_VIEW = 0x82B5+gl_NEGATIVE_ONE_TO_ONE :: GLenum+gl_NEGATIVE_ONE_TO_ONE = 0x935E+gl_CONVOLUTION_1D_EXT :: GLenum+gl_CONVOLUTION_1D_EXT = 0x8010+gl_CLAMP_READ_COLOR :: GLenum+gl_CLAMP_READ_COLOR = 0x891C+gl_REFLECTION_MAP :: GLenum+gl_REFLECTION_MAP = 0x8512+gl_PROXY_HISTOGRAM :: GLenum+gl_PROXY_HISTOGRAM = 0x8025+gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS :: GLenum+gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D+gl_HALF_FLOAT_ARB :: GLenum+gl_HALF_FLOAT_ARB = 0x140B+gl_LINE_QUALITY_HINT_SGIX :: GLenum+gl_LINE_QUALITY_HINT_SGIX = 0x835B+gl_MAP_WRITE_BIT_EXT :: GLenum+gl_MAP_WRITE_BIT_EXT = 0x0002+gl_PIXEL_TRANSFORM_2D_EXT :: GLenum+gl_PIXEL_TRANSFORM_2D_EXT = 0x8330+gl_INCR :: GLenum+gl_INCR = 0x1E02+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES = 0x93E0+gl_LUMINANCE_FLOAT32_ATI :: GLenum+gl_LUMINANCE_FLOAT32_ATI = 0x8818+gl_EVAL_VERTEX_ATTRIB11_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB11_NV = 0x86D1+gl_TEXTURE_COORD_ARRAY_SIZE :: GLenum+gl_TEXTURE_COORD_ARRAY_SIZE = 0x8088+gl_IMAGE_BINDING_LEVEL_EXT :: GLenum+gl_IMAGE_BINDING_LEVEL_EXT = 0x8F3B+gl_RGBA16I_EXT :: GLenum+gl_RGBA16I_EXT = 0x8D88+gl_T2F_IUI_N3F_V2F_EXT :: GLenum+gl_T2F_IUI_N3F_V2F_EXT = 0x81B3+gl_MIN_PROGRAM_TEXEL_OFFSET_NV :: GLenum+gl_MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904+gl_EQUIV :: GLenum+gl_EQUIV = 0x1509+gl_TEXTURE_BINDING_CUBE_MAP_ARB :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514+gl_DRAW_BUFFER1_NV :: GLenum+gl_DRAW_BUFFER1_NV = 0x8826+gl_INTERLACE_READ_OML :: GLenum+gl_INTERLACE_READ_OML = 0x8981+gl_TEXTURE15 :: GLenum+gl_TEXTURE15 = 0x84CF+gl_NAND :: GLenum+gl_NAND = 0x150E+gl_VERTEX_ARRAY_RANGE_APPLE :: GLenum+gl_VERTEX_ARRAY_RANGE_APPLE = 0x851D+gl_CONDITION_SATISFIED_APPLE :: GLenum+gl_CONDITION_SATISFIED_APPLE = 0x911C+gl_DISPATCH_INDIRECT_BUFFER_BINDING :: GLenum+gl_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF+gl_RG16I :: GLenum+gl_RG16I = 0x8239+gl_EYE_RADIAL_NV :: GLenum+gl_EYE_RADIAL_NV = 0x855B+gl_SLUMINANCE_ALPHA_EXT :: GLenum+gl_SLUMINANCE_ALPHA_EXT = 0x8C44+gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum+gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT :: GLenum+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT = 0x88FE+gl_RG32F :: GLenum+gl_RG32F = 0x8230+gl_SRC1_ALPHA :: GLenum+gl_SRC1_ALPHA = 0x8589+gl_RGBA2 :: GLenum+gl_RGBA2 = 0x8055+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES = 0x8CD4+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 0x8C88+gl_TEXTURE_COORD_ARRAY_STRIDE_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A+gl_OUTPUT_TEXTURE_COORD10_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD10_EXT = 0x87A7+gl_DEPTH_ATTACHMENT :: GLenum+gl_DEPTH_ATTACHMENT = 0x8D00+gl_NORMAL_ARRAY_POINTER_EXT :: GLenum+gl_NORMAL_ARRAY_POINTER_EXT = 0x808F+gl_OPERAND0_ALPHA_ARB :: GLenum+gl_OPERAND0_ALPHA_ARB = 0x8598+gl_COMPRESSED_LUMINANCE_ARB :: GLenum+gl_COMPRESSED_LUMINANCE_ARB = 0x84EA+gl_LIST_PRIORITY_SGIX :: GLenum+gl_LIST_PRIORITY_SGIX = 0x8182+gl_BOUNDING_BOX_NV :: GLenum+gl_BOUNDING_BOX_NV = 0x908D+gl_PATCH_VERTICES_EXT :: GLenum+gl_PATCH_VERTICES_EXT = 0x8E72+gl_COPY_INVERTED :: GLenum+gl_COPY_INVERTED = 0x150C+gl_FRAMEBUFFER_BARRIER_BIT_EXT :: GLenum+gl_FRAMEBUFFER_BARRIER_BIT_EXT = 0x00000400+gl_OBJECT_ACTIVE_ATTRIBUTES_ARB :: GLenum+gl_OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89+gl_DISCRETE_AMD :: GLenum+gl_DISCRETE_AMD = 0x9006+gl_DOT3_RGBA_ARB :: GLenum+gl_DOT3_RGBA_ARB = 0x86AF+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES = 0x8CD2+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES = 0x8CD1+gl_SET :: GLenum+gl_SET = 0x150F+gl_TEXTURE_MAX_ANISOTROPY_EXT :: GLenum+gl_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE+gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: GLenum+gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276+gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB :: GLenum+gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B+gl_MAP2_GRID_DOMAIN :: GLenum+gl_MAP2_GRID_DOMAIN = 0x0DD2+gl_RENDERBUFFER_SAMPLES :: GLenum+gl_RENDERBUFFER_SAMPLES = 0x8CAB+gl_MAX_TEXTURE_LOD_BIAS :: GLenum+gl_MAX_TEXTURE_LOD_BIAS = 0x84FD+gl_DEPTH_PASS_INSTRUMENT_SGIX :: GLenum+gl_DEPTH_PASS_INSTRUMENT_SGIX = 0x8310+gl_TEXTURE_COORD_NV :: GLenum+gl_TEXTURE_COORD_NV = 0x8C79+gl_PROGRAM_ERROR_POSITION_NV :: GLenum+gl_PROGRAM_ERROR_POSITION_NV = 0x864B+gl_RENDERBUFFER_RED_SIZE_EXT :: GLenum+gl_RENDERBUFFER_RED_SIZE_EXT = 0x8D50+gl_INDEX_OFFSET :: GLenum+gl_INDEX_OFFSET = 0x0D13+gl_CURRENT_FOG_COORD :: GLenum+gl_CURRENT_FOG_COORD = 0x8453+gl_MIRRORED_REPEAT :: GLenum+gl_MIRRORED_REPEAT = 0x8370+gl_MAP_INVALIDATE_BUFFER_BIT :: GLenum+gl_MAP_INVALIDATE_BUFFER_BIT = 0x0008+gl_MATRIX_INDEX_ARRAY_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_OES = 0x8844+gl_DRAW_BUFFER6_ATI :: GLenum+gl_DRAW_BUFFER6_ATI = 0x882B+gl_INTENSITY12 :: GLenum+gl_INTENSITY12 = 0x804C+gl_FLOAT_RGBA_NV :: GLenum+gl_FLOAT_RGBA_NV = 0x8883+gl_SMOOTH_POINT_SIZE_RANGE :: GLenum+gl_SMOOTH_POINT_SIZE_RANGE = 0x0B12+gl_COLOR_BUFFER_BIT1_QCOM :: GLenum+gl_COLOR_BUFFER_BIT1_QCOM = 0x00000002+gl_TEXT_FRAGMENT_SHADER_ATI :: GLenum+gl_TEXT_FRAGMENT_SHADER_ATI = 0x8200+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8+gl_CLIP_PLANE3 :: GLenum+gl_CLIP_PLANE3 = 0x3003+gl_NAMED_STRING_TYPE_ARB :: GLenum+gl_NAMED_STRING_TYPE_ARB = 0x8DEA+gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB :: GLenum+gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB+gl_TEXTURE_VIEW_MIN_LEVEL :: GLenum+gl_TEXTURE_VIEW_MIN_LEVEL = 0x82DB+gl_SWIZZLE_STQ_ATI :: GLenum+gl_SWIZZLE_STQ_ATI = 0x8977+gl_RGBA_FLOAT_MODE_ARB :: GLenum+gl_RGBA_FLOAT_MODE_ARB = 0x8820+gl_RG8UI :: GLenum+gl_RG8UI = 0x8238+gl_FRAGMENT_DEPTH :: GLenum+gl_FRAGMENT_DEPTH = 0x8452+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2+gl_MULTISAMPLE_SGIS :: GLenum+gl_MULTISAMPLE_SGIS = 0x809D+gl_PROXY_TEXTURE_1D :: GLenum+gl_PROXY_TEXTURE_1D = 0x8063+gl_MODELVIEW0_ARB :: GLenum+gl_MODELVIEW0_ARB = 0x1700+gl_LINE_STRIP_ADJACENCY_EXT :: GLenum+gl_LINE_STRIP_ADJACENCY_EXT = 0x000B+gl_RGBA16UI :: GLenum+gl_RGBA16UI = 0x8D76+gl_SRC_ATOP_NV :: GLenum+gl_SRC_ATOP_NV = 0x928E+gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE :: GLenum+gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE+gl_REG_30_ATI :: GLenum+gl_REG_30_ATI = 0x893F+gl_4PASS_3_EXT :: GLenum+gl_4PASS_3_EXT = 0x80A7+gl_INT_IMAGE_3D_EXT :: GLenum+gl_INT_IMAGE_3D_EXT = 0x9059+gl_SYSTEM_FONT_NAME_NV :: GLenum+gl_SYSTEM_FONT_NAME_NV = 0x9073+gl_DRAW_BUFFER6 :: GLenum+gl_DRAW_BUFFER6 = 0x882B+gl_RG32I :: GLenum+gl_RG32I = 0x823B+gl_COLOR_BUFFER_BIT3_QCOM :: GLenum+gl_COLOR_BUFFER_BIT3_QCOM = 0x00000008+gl_CURRENT_OCCLUSION_QUERY_ID_NV :: GLenum+gl_CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865+gl_INTERNALFORMAT_STENCIL_SIZE :: GLenum+gl_INTERNALFORMAT_STENCIL_SIZE = 0x8276+gl_STATIC_DRAW_ARB :: GLenum+gl_STATIC_DRAW_ARB = 0x88E4+gl_COMPRESSED_SRGB_ALPHA_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_EXT = 0x8C49+gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI :: GLenum+gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000+gl_PALETTE8_RGBA4_OES :: GLenum+gl_PALETTE8_RGBA4_OES = 0x8B98+gl_FOG_START :: GLenum+gl_FOG_START = 0x0B63+gl_DEBUG_TYPE_POP_GROUP :: GLenum+gl_DEBUG_TYPE_POP_GROUP = 0x826A+gl_DRAW_BUFFER14_ATI :: GLenum+gl_DRAW_BUFFER14_ATI = 0x8833+gl_IMAGE_1D_ARRAY :: GLenum+gl_IMAGE_1D_ARRAY = 0x9052+gl_RELATIVE_LARGE_CCW_ARC_TO_NV :: GLenum+gl_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17+gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV :: GLenum+gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x02000000+gl_EXCLUSION_NV :: GLenum+gl_EXCLUSION_NV = 0x92A0+gl_FONT_X_MAX_BOUNDS_BIT_NV :: GLenum+gl_FONT_X_MAX_BOUNDS_BIT_NV = 0x00040000+gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX :: GLenum+gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186+gl_DEPTH_BUFFER_BIT2_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT2_QCOM = 0x00000400+gl_UNPACK_FLIP_Y_WEBGL :: GLenum+gl_UNPACK_FLIP_Y_WEBGL = 0x9240+gl_COLOR_ATTACHMENT15_NV :: GLenum+gl_COLOR_ATTACHMENT15_NV = 0x8CEF+gl_RG16F_EXT :: GLenum+gl_RG16F_EXT = 0x822F+gl_PRIMARY_COLOR :: GLenum+gl_PRIMARY_COLOR = 0x8577+gl_UNIFORM_BLOCK_DATA_SIZE :: GLenum+gl_UNIFORM_BLOCK_DATA_SIZE = 0x8A40+gl_INTERNALFORMAT_STENCIL_TYPE :: GLenum+gl_INTERNALFORMAT_STENCIL_TYPE = 0x827D+gl_COLOR_MATRIX_STACK_DEPTH_SGI :: GLenum+gl_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2+gl_AND :: GLenum+gl_AND = 0x1501+gl_GEOMETRY_INPUT_TYPE_ARB :: GLenum+gl_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB+gl_SAMPLER_BUFFER :: GLenum+gl_SAMPLER_BUFFER = 0x8DC2+gl_COLOR_BUFFER_BIT2_QCOM :: GLenum+gl_COLOR_BUFFER_BIT2_QCOM = 0x00000004+gl_MAX_CLIP_DISTANCES :: GLenum+gl_MAX_CLIP_DISTANCES = 0x0D32+gl_OUTPUT_TEXTURE_COORD25_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD25_EXT = 0x87B6+gl_SLIM8U_SGIX :: GLenum+gl_SLIM8U_SGIX = 0x831D+gl_OP_DOT4_EXT :: GLenum+gl_OP_DOT4_EXT = 0x8785+gl_INFO_LOG_LENGTH :: GLenum+gl_INFO_LOG_LENGTH = 0x8B84+gl_REG_25_ATI :: GLenum+gl_REG_25_ATI = 0x893A+gl_MAX_PROGRAM_CALL_DEPTH_NV :: GLenum+gl_MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5+gl_VIRTUAL_PAGE_SIZE_INDEX_ARB :: GLenum+gl_VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7+gl_MAX_PROGRAM_RESULT_COMPONENTS_NV :: GLenum+gl_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909+gl_RELATIVE_CONIC_CURVE_TO_NV :: GLenum+gl_RELATIVE_CONIC_CURVE_TO_NV = 0x1B+gl_CLIP_DISTANCE4 :: GLenum+gl_CLIP_DISTANCE4 = 0x3004+gl_UTF8_NV :: GLenum+gl_UTF8_NV = 0x909A+gl_INVALID_INDEX :: GLenum+gl_INVALID_INDEX = 0xFFFFFFFF+gl_DOT3_RGBA_IMG :: GLenum+gl_DOT3_RGBA_IMG = 0x86AF+gl_FRAGMENT_MATERIAL_EXT :: GLenum+gl_FRAGMENT_MATERIAL_EXT = 0x8349+gl_PACK_CMYK_HINT_EXT :: GLenum+gl_PACK_CMYK_HINT_EXT = 0x800E+gl_LUMINANCE_ALPHA8I_EXT :: GLenum+gl_LUMINANCE_ALPHA8I_EXT = 0x8D93+gl_PIXEL_BUFFER_BARRIER_BIT_EXT :: GLenum+gl_PIXEL_BUFFER_BARRIER_BIT_EXT = 0x00000080+gl_BUFFER_KHR :: GLenum+gl_BUFFER_KHR = 0x82E0+gl_STENCIL_BACK_OP_VALUE_AMD :: GLenum+gl_STENCIL_BACK_OP_VALUE_AMD = 0x874D+gl_DST_COLOR :: GLenum+gl_DST_COLOR = 0x0306+gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 0x00000800+gl_ZERO :: GLenum+gl_ZERO = 0+gl_COORD_REPLACE :: GLenum+gl_COORD_REPLACE = 0x8862+gl_FRAMEBUFFER_SRGB :: GLenum+gl_FRAMEBUFFER_SRGB = 0x8DB9+gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES = 0x9279+gl_CONSTANT :: GLenum+gl_CONSTANT = 0x8576+gl_TEXTURE_CONSTANT_DATA_SUNX :: GLenum+gl_TEXTURE_CONSTANT_DATA_SUNX = 0x81D6+gl_MAX_DEBUG_MESSAGE_LENGTH :: GLenum+gl_MAX_DEBUG_MESSAGE_LENGTH = 0x9143+gl_MAX_VARYING_FLOATS :: GLenum+gl_MAX_VARYING_FLOATS = 0x8B4B+gl_PLUS_NV :: GLenum+gl_PLUS_NV = 0x9291+gl_UNIFORM_NAME_LENGTH :: GLenum+gl_UNIFORM_NAME_LENGTH = 0x8A39+gl_SECONDARY_COLOR_ARRAY_STRIDE :: GLenum+gl_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C+gl_MAP1_VERTEX_ATTRIB13_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB13_4_NV = 0x866D+gl_TRACK_MATRIX_TRANSFORM_NV :: GLenum+gl_TRACK_MATRIX_TRANSFORM_NV = 0x8649+gl_MAX_COMPUTE_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263+gl_DOUBLE_MAT4 :: GLenum+gl_DOUBLE_MAT4 = 0x8F48+gl_TEXTURE_SRGB_DECODE_EXT :: GLenum+gl_TEXTURE_SRGB_DECODE_EXT = 0x8A48+gl_TEXTURE_BORDER_COLOR :: GLenum+gl_TEXTURE_BORDER_COLOR = 0x1004+gl_DISPLAY_LIST :: GLenum+gl_DISPLAY_LIST = 0x82E7+gl_COLOR_ENCODING :: GLenum+gl_COLOR_ENCODING = 0x8296+gl_EXPAND_NEGATE_NV :: GLenum+gl_EXPAND_NEGATE_NV = 0x8539+gl_UNPACK_ROW_LENGTH_EXT :: GLenum+gl_UNPACK_ROW_LENGTH_EXT = 0x0CF2+gl_RGB_SCALE_ARB :: GLenum+gl_RGB_SCALE_ARB = 0x8573+gl_CURRENT_ATTRIB_NV :: GLenum+gl_CURRENT_ATTRIB_NV = 0x8626+gl_TEXTURE25 :: GLenum+gl_TEXTURE25 = 0x84D9+gl_DEPTH :: GLenum+gl_DEPTH = 0x1801+gl_DRAW_BUFFER2_ARB :: GLenum+gl_DRAW_BUFFER2_ARB = 0x8827+gl_FENCE_CONDITION_NV :: GLenum+gl_FENCE_CONDITION_NV = 0x84F4+gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB :: GLenum+gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E+gl_OP_POWER_EXT :: GLenum+gl_OP_POWER_EXT = 0x8793+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB :: GLenum+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E+gl_FRAMEBUFFER_DEFAULT :: GLenum+gl_FRAMEBUFFER_DEFAULT = 0x8218+gl_COLOR_ATTACHMENT13_EXT :: GLenum+gl_COLOR_ATTACHMENT13_EXT = 0x8CED+gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215+gl_CUBIC_HP :: GLenum+gl_CUBIC_HP = 0x815F+gl_GREATER :: GLenum+gl_GREATER = 0x0204+gl_OP_MOV_EXT :: GLenum+gl_OP_MOV_EXT = 0x8799+gl_RED_SNORM :: GLenum+gl_RED_SNORM = 0x8F90+gl_ALPHA_MAX_CLAMP_INGR :: GLenum+gl_ALPHA_MAX_CLAMP_INGR = 0x8567+gl_VERTEX_ATTRIB_ARRAY_LONG :: GLenum+gl_VERTEX_ATTRIB_ARRAY_LONG = 0x874E+gl_DEBUG_SEVERITY_LOW_ARB :: GLenum+gl_DEBUG_SEVERITY_LOW_ARB = 0x9148+gl_PURGEABLE_APPLE :: GLenum+gl_PURGEABLE_APPLE = 0x8A1D+gl_MAX_SHININESS_NV :: GLenum+gl_MAX_SHININESS_NV = 0x8504+gl_VERTEX_SHADER_INVARIANTS_EXT :: GLenum+gl_VERTEX_SHADER_INVARIANTS_EXT = 0x87D1+gl_CLIP_DISTANCE1 :: GLenum+gl_CLIP_DISTANCE1 = 0x3001+gl_PROGRAM_NATIVE_PARAMETERS_ARB :: GLenum+gl_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA+gl_SRC_ALPHA_SATURATE :: GLenum+gl_SRC_ALPHA_SATURATE = 0x0308+gl_COLOR_RENDERABLE :: GLenum+gl_COLOR_RENDERABLE = 0x8286+gl_LINE_STIPPLE :: GLenum+gl_LINE_STIPPLE = 0x0B24+gl_COMPILE_AND_EXECUTE :: GLenum+gl_COMPILE_AND_EXECUTE = 0x1301+gl_FOG_COORDINATE :: GLenum+gl_FOG_COORDINATE = 0x8451+gl_MULTISAMPLE_COVERAGE_MODES_NV :: GLenum+gl_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12+gl_OUTPUT_TEXTURE_COORD16_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD16_EXT = 0x87AD+gl_SCALE_BY_FOUR_NV :: GLenum+gl_SCALE_BY_FOUR_NV = 0x853F+gl_INDEX_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899+gl_MAX_TEXTURE_IMAGE_UNITS_ARB :: GLenum+gl_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872+gl_HALF_BIAS_NEGATE_NV :: GLenum+gl_HALF_BIAS_NEGATE_NV = 0x853B+gl_INT_IMAGE_2D_MULTISAMPLE_EXT :: GLenum+gl_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x9060+gl_CON_30_ATI :: GLenum+gl_CON_30_ATI = 0x895F+gl_SAMPLE_ALPHA_TO_ONE_EXT :: GLenum+gl_SAMPLE_ALPHA_TO_ONE_EXT = 0x809F+gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A+gl_STORAGE_CACHED_APPLE :: GLenum+gl_STORAGE_CACHED_APPLE = 0x85BE+gl_SAMPLER_2D_SHADOW :: GLenum+gl_SAMPLER_2D_SHADOW = 0x8B62+gl_ALPHA_FLOAT16_APPLE :: GLenum+gl_ALPHA_FLOAT16_APPLE = 0x881C+gl_PERFQUERY_COUNTER_EVENT_INTEL :: GLenum+gl_PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0+gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB :: GLenum+gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9+gl_BACK_PRIMARY_COLOR_NV :: GLenum+gl_BACK_PRIMARY_COLOR_NV = 0x8C77+gl_PROGRAM_PARAMETERS_ARB :: GLenum+gl_PROGRAM_PARAMETERS_ARB = 0x88A8+gl_MIN_SPARSE_LEVEL_AMD :: GLenum+gl_MIN_SPARSE_LEVEL_AMD = 0x919B+gl_INT_SAMPLER_1D_ARRAY_EXT :: GLenum+gl_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE+gl_DOUBLEBUFFER :: GLenum+gl_DOUBLEBUFFER = 0x0C32+gl_NEGATIVE_W_EXT :: GLenum+gl_NEGATIVE_W_EXT = 0x87DC+gl_VIEW_CLASS_RGTC1_RED :: GLenum+gl_VIEW_CLASS_RGTC1_RED = 0x82D0+gl_PROGRAM_KHR :: GLenum+gl_PROGRAM_KHR = 0x82E2+gl_LINEARDODGE_NV :: GLenum+gl_LINEARDODGE_NV = 0x92A4+gl_NORMALIZED_RANGE_EXT :: GLenum+gl_NORMALIZED_RANGE_EXT = 0x87E0+gl_BUFFER_SERIALIZED_MODIFY_APPLE :: GLenum+gl_BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12+gl_TEXTURE3_ARB :: GLenum+gl_TEXTURE3_ARB = 0x84C3+gl_INDEX_TEST_FUNC_EXT :: GLenum+gl_INDEX_TEST_FUNC_EXT = 0x81B6+gl_COMPUTE_TEXTURE :: GLenum+gl_COMPUTE_TEXTURE = 0x82A0+gl_UNSIGNED_INT_IMAGE_BUFFER_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067+gl_CON_9_ATI :: GLenum+gl_CON_9_ATI = 0x894A+gl_RELATIVE_LINE_TO_NV :: GLenum+gl_RELATIVE_LINE_TO_NV = 0x05+gl_TEXTURE_RECTANGLE_NV :: GLenum+gl_TEXTURE_RECTANGLE_NV = 0x84F5+gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE :: GLenum+gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE = 0x83F3+gl_COMPRESSED_RGBA_ASTC_6x5_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3+gl_TEXTURE_LUMINANCE_SIZE :: GLenum+gl_TEXTURE_LUMINANCE_SIZE = 0x8060+gl_PROJECTION_MATRIX :: GLenum+gl_PROJECTION_MATRIX = 0x0BA7+gl_VIBRANCE_BIAS_NV :: GLenum+gl_VIBRANCE_BIAS_NV = 0x8719+gl_MAX_VERTEX_ATOMIC_COUNTERS :: GLenum+gl_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2+gl_FOG_COORD_ARRAY_POINTER :: GLenum+gl_FOG_COORD_ARRAY_POINTER = 0x8456+gl_POLYGON_OFFSET_BIAS_EXT :: GLenum+gl_POLYGON_OFFSET_BIAS_EXT = 0x8039+gl_DEBUG_SOURCE_OTHER :: GLenum+gl_DEBUG_SOURCE_OTHER = 0x824B+gl_LINEAR_SHARPEN_ALPHA_SGIS :: GLenum+gl_LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE+gl_AVERAGE_EXT :: GLenum+gl_AVERAGE_EXT = 0x8335+gl_PACK_SKIP_IMAGES_EXT :: GLenum+gl_PACK_SKIP_IMAGES_EXT = 0x806B+gl_BITMAP_TOKEN :: GLenum+gl_BITMAP_TOKEN = 0x0704+gl_TESSELLATION_MODE_AMD :: GLenum+gl_TESSELLATION_MODE_AMD = 0x9004+gl_POST_CONVOLUTION_COLOR_TABLE_SGI :: GLenum+gl_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1+gl_MODELVIEW1_EXT :: GLenum+gl_MODELVIEW1_EXT = 0x850A+gl_OPERAND1_RGB_ARB :: GLenum+gl_OPERAND1_RGB_ARB = 0x8591+gl_4D_COLOR_TEXTURE :: GLenum+gl_4D_COLOR_TEXTURE = 0x0604+gl_ACTIVE_ATTRIBUTES :: GLenum+gl_ACTIVE_ATTRIBUTES = 0x8B89+gl_BUFFER_BINDING :: GLenum+gl_BUFFER_BINDING = 0x9302+gl_VERTEX_STATE_PROGRAM_NV :: GLenum+gl_VERTEX_STATE_PROGRAM_NV = 0x8621+gl_DST_ATOP_NV :: GLenum+gl_DST_ATOP_NV = 0x928F+gl_TEXTURE_DEPTH_EXT :: GLenum+gl_TEXTURE_DEPTH_EXT = 0x8071+gl_UNSIGNED_INT_VEC4 :: GLenum+gl_UNSIGNED_INT_VEC4 = 0x8DC8+gl_GREEN_INTEGER :: GLenum+gl_GREEN_INTEGER = 0x8D95+gl_DOUBLE_MAT4x2_EXT :: GLenum+gl_DOUBLE_MAT4x2_EXT = 0x8F4D+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7+gl_INDEX_ARRAY_LIST_IBM :: GLenum+gl_INDEX_ARRAY_LIST_IBM = 103073+gl_SAMPLER_2D_ARRAY_SHADOW :: GLenum+gl_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4+gl_COMPRESSED_SRGB_S3TC_DXT1_NV :: GLenum+gl_COMPRESSED_SRGB_S3TC_DXT1_NV = 0x8C4C+gl_COMPRESSED_RGBA_ASTC_4x3x3_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_4x3x3_OES = 0x93C1+gl_DRAW_BUFFER3_ATI :: GLenum+gl_DRAW_BUFFER3_ATI = 0x8828+gl_MAX_FRAGMENT_UNIFORM_COMPONENTS :: GLenum+gl_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49+gl_PROXY_TEXTURE_3D_EXT :: GLenum+gl_PROXY_TEXTURE_3D_EXT = 0x8070+gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8E85+gl_PATH_COMPUTED_LENGTH_NV :: GLenum+gl_PATH_COMPUTED_LENGTH_NV = 0x90A0+gl_DEPTH_STENCIL_MESA :: GLenum+gl_DEPTH_STENCIL_MESA = 0x8750+gl_MAT_DIFFUSE_BIT_PGI :: GLenum+gl_MAT_DIFFUSE_BIT_PGI = 0x00400000+gl_TEXTURE_STENCIL_SIZE :: GLenum+gl_TEXTURE_STENCIL_SIZE = 0x88F1+gl_PATH_PROJECTION_NV :: GLenum+gl_PATH_PROJECTION_NV = 0x1701+gl_DUAL_TEXTURE_SELECT_SGIS :: GLenum+gl_DUAL_TEXTURE_SELECT_SGIS = 0x8124+gl_MATRIX14_ARB :: GLenum+gl_MATRIX14_ARB = 0x88CE+gl_PATH_OBJECT_BOUNDING_BOX_NV :: GLenum+gl_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A+gl_READ_PIXELS :: GLenum+gl_READ_PIXELS = 0x828C+gl_TRIANGLE_LIST_SUN :: GLenum+gl_TRIANGLE_LIST_SUN = 0x81D7+gl_COMPARE_R_TO_TEXTURE :: GLenum+gl_COMPARE_R_TO_TEXTURE = 0x884E+gl_INTENSITY8UI_EXT :: GLenum+gl_INTENSITY8UI_EXT = 0x8D7F+gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB :: GLenum+gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242+gl_COLOR_TABLE_GREEN_SIZE :: GLenum+gl_COLOR_TABLE_GREEN_SIZE = 0x80DB+gl_CURRENT_VERTEX_ATTRIB :: GLenum+gl_CURRENT_VERTEX_ATTRIB = 0x8626+gl_POST_COLOR_MATRIX_GREEN_BIAS :: GLenum+gl_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9+gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX :: GLenum+gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A+gl_SUBSAMPLE_DISTANCE_AMD :: GLenum+gl_SUBSAMPLE_DISTANCE_AMD = 0x883F+gl_SRGB8_EXT :: GLenum+gl_SRGB8_EXT = 0x8C41+gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS :: GLenum+gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C+gl_INCR_WRAP_EXT :: GLenum+gl_INCR_WRAP_EXT = 0x8507+gl_UNPACK_COMPRESSED_BLOCK_SIZE :: GLenum+gl_UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A+gl_OBJECT_VALIDATE_STATUS_ARB :: GLenum+gl_OBJECT_VALIDATE_STATUS_ARB = 0x8B83+gl_WEIGHT_ARRAY_STRIDE_ARB :: GLenum+gl_WEIGHT_ARRAY_STRIDE_ARB = 0x86AA+gl_OUTPUT_TEXTURE_COORD3_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD3_EXT = 0x87A0+gl_TEXTURE16_ARB :: GLenum+gl_TEXTURE16_ARB = 0x84D0+gl_VIDEO_COLOR_CONVERSION_MATRIX_NV :: GLenum+gl_VIDEO_COLOR_CONVERSION_MATRIX_NV = 0x9029+gl_EYE_DISTANCE_TO_POINT_SGIS :: GLenum+gl_EYE_DISTANCE_TO_POINT_SGIS = 0x81F0+gl_TEXTURE_COMPARE_FUNC :: GLenum+gl_TEXTURE_COMPARE_FUNC = 0x884D+gl_DEPTH_BUFFER_FLOAT_MODE_NV :: GLenum+gl_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF+gl_TEXTURE_SWIZZLE_G :: GLenum+gl_TEXTURE_SWIZZLE_G = 0x8E43+gl_DEBUG_TYPE_OTHER_ARB :: GLenum+gl_DEBUG_TYPE_OTHER_ARB = 0x8251+gl_TESS_EVALUATION_SHADER_BIT_EXT :: GLenum+gl_TESS_EVALUATION_SHADER_BIT_EXT = 0x00000010+gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA :: GLenum+gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA = 0x8BB7+gl_INT_SAMPLER_BUFFER_EXT :: GLenum+gl_INT_SAMPLER_BUFFER_EXT = 0x8DD0+gl_OP_CLAMP_EXT :: GLenum+gl_OP_CLAMP_EXT = 0x878E+gl_POINT_SIZE_MIN :: GLenum+gl_POINT_SIZE_MIN = 0x8126+gl_UNSIGNED_BYTE_3_3_2_EXT :: GLenum+gl_UNSIGNED_BYTE_3_3_2_EXT = 0x8032+gl_TEXTURE_CLIPMAP_DEPTH_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176+gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT :: GLenum+gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = 0x8D6A+gl_DOUBLE_VEC4_EXT :: GLenum+gl_DOUBLE_VEC4_EXT = 0x8FFE+gl_SYNC_CONDITION_APPLE :: GLenum+gl_SYNC_CONDITION_APPLE = 0x9113+gl_MAX_TEXTURE_COORDS_NV :: GLenum+gl_MAX_TEXTURE_COORDS_NV = 0x8871+gl_RELATIVE_QUADRATIC_CURVE_TO_NV :: GLenum+gl_RELATIVE_QUADRATIC_CURVE_TO_NV = 0x0B+gl_DEBUG_GROUP_STACK_DEPTH_KHR :: GLenum+gl_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D+gl_CONTEXT_LOST_KHR :: GLenum+gl_CONTEXT_LOST_KHR = 0x0507+gl_QUADRATIC_CURVE_TO_NV :: GLenum+gl_QUADRATIC_CURVE_TO_NV = 0x0A+gl_MIN_EXT :: GLenum+gl_MIN_EXT = 0x8007+gl_VERTEX_ATTRIB_ARRAY11_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY11_NV = 0x865B+gl_FACTOR_ALPHA_MODULATE_IMG :: GLenum+gl_FACTOR_ALPHA_MODULATE_IMG = 0x8C07+gl_MAP1_GRID_DOMAIN :: GLenum+gl_MAP1_GRID_DOMAIN = 0x0DD0+gl_COLOR_MATRIX_STACK_DEPTH :: GLenum+gl_COLOR_MATRIX_STACK_DEPTH = 0x80B2+gl_IMAGE_PIXEL_FORMAT :: GLenum+gl_IMAGE_PIXEL_FORMAT = 0x82A9+gl_DRAW_BUFFER1_EXT :: GLenum+gl_DRAW_BUFFER1_EXT = 0x8826+gl_UNSIGNED_INT_VEC2 :: GLenum+gl_UNSIGNED_INT_VEC2 = 0x8DC6+gl_QUAD_LUMINANCE8_SGIS :: GLenum+gl_QUAD_LUMINANCE8_SGIS = 0x8121+gl_ELEMENT_ARRAY_UNIFIED_NV :: GLenum+gl_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F+gl_COLOR_LOGIC_OP :: GLenum+gl_COLOR_LOGIC_OP = 0x0BF2+gl_GREEN_NV :: GLenum+gl_GREEN_NV = 0x1904+gl_DEPTH_COMPONENT :: GLenum+gl_DEPTH_COMPONENT = 0x1902+gl_TEXTURE18 :: GLenum+gl_TEXTURE18 = 0x84D2+gl_COMBINER_SUM_OUTPUT_NV :: GLenum+gl_COMBINER_SUM_OUTPUT_NV = 0x854C+gl_DUAL_LUMINANCE8_SGIS :: GLenum+gl_DUAL_LUMINANCE8_SGIS = 0x8115+gl_PATH_DASH_OFFSET_RESET_NV :: GLenum+gl_PATH_DASH_OFFSET_RESET_NV = 0x90B4+gl_INT_SAMPLER_BUFFER :: GLenum+gl_INT_SAMPLER_BUFFER = 0x8DD0+gl_DEBUG_SEVERITY_MEDIUM_ARB :: GLenum+gl_DEBUG_SEVERITY_MEDIUM_ARB = 0x9147+gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 0x8C76+gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX :: GLenum+gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A+gl_UNSIGNED_SHORT_15_1_MESA :: GLenum+gl_UNSIGNED_SHORT_15_1_MESA = 0x8753+gl_LUMINANCE32F_ARB :: GLenum+gl_LUMINANCE32F_ARB = 0x8818+gl_TRANSPOSE_NV :: GLenum+gl_TRANSPOSE_NV = 0x862C+gl_LUMINANCE8_EXT :: GLenum+gl_LUMINANCE8_EXT = 0x8040+gl_WRITE_DISCARD_NV :: GLenum+gl_WRITE_DISCARD_NV = 0x88BE+gl_STENCIL_BUFFER_BIT5_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT5_QCOM = 0x00200000+gl_FOG_END :: GLenum+gl_FOG_END = 0x0B64+gl_DRAW_BUFFER9_NV :: GLenum+gl_DRAW_BUFFER9_NV = 0x882E+gl_PROVOKING_VERTEX_EXT :: GLenum+gl_PROVOKING_VERTEX_EXT = 0x8E4F+gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF+gl_2PASS_0_EXT :: GLenum+gl_2PASS_0_EXT = 0x80A2+gl_MAP_UNSYNCHRONIZED_BIT :: GLenum+gl_MAP_UNSYNCHRONIZED_BIT = 0x0020+gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI :: GLenum+gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV :: GLenum+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5E+gl_SAMPLER_CUBE_SHADOW :: GLenum+gl_SAMPLER_CUBE_SHADOW = 0x8DC5+gl_V2F :: GLenum+gl_V2F = 0x2A20+gl_IMAGE_2D_EXT :: GLenum+gl_IMAGE_2D_EXT = 0x904D+gl_LUMINANCE32UI_EXT :: GLenum+gl_LUMINANCE32UI_EXT = 0x8D74+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900F+gl_SLUMINANCE8_ALPHA8_NV :: GLenum+gl_SLUMINANCE8_ALPHA8_NV = 0x8C45+gl_MAX_ASYNC_DRAW_PIXELS_SGIX :: GLenum+gl_MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360+gl_POINT_SIZE_ARRAY_TYPE_OES :: GLenum+gl_POINT_SIZE_ARRAY_TYPE_OES = 0x898A+gl_SIGNED_LUMINANCE8_ALPHA8_NV :: GLenum+gl_SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704+gl_UNSIGNED_INT_24_8_EXT :: GLenum+gl_UNSIGNED_INT_24_8_EXT = 0x84FA+gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV :: GLenum+gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE+gl_CONIC_CURVE_TO_NV :: GLenum+gl_CONIC_CURVE_TO_NV = 0x1A+gl_STREAM_DRAW_ARB :: GLenum+gl_STREAM_DRAW_ARB = 0x88E0+gl_ACTIVE_PROGRAM_EXT :: GLenum+gl_ACTIVE_PROGRAM_EXT = 0x8B8D+gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB :: GLenum+gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF+gl_PROGRAM_RESIDENT_NV :: GLenum+gl_PROGRAM_RESIDENT_NV = 0x8647+gl_COLOR_TABLE_ALPHA_SIZE_SGI :: GLenum+gl_COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD+gl_INT_IMAGE_2D_ARRAY_EXT :: GLenum+gl_INT_IMAGE_2D_ARRAY_EXT = 0x905E+gl_OUTPUT_TEXTURE_COORD15_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD15_EXT = 0x87AC+gl_SRC_OUT_NV :: GLenum+gl_SRC_OUT_NV = 0x928C+gl_MAP_FLUSH_EXPLICIT_BIT :: GLenum+gl_MAP_FLUSH_EXPLICIT_BIT = 0x0010+gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB :: GLenum+gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F+gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS :: GLenum+gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85+gl_EVAL_VERTEX_ATTRIB2_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB2_NV = 0x86C8+gl_PIXEL_TILE_WIDTH_SGIX :: GLenum+gl_PIXEL_TILE_WIDTH_SGIX = 0x8140+gl_PROXY_TEXTURE_RECTANGLE :: GLenum+gl_PROXY_TEXTURE_RECTANGLE = 0x84F7+gl_VERTEX_ARRAY_BINDING :: GLenum+gl_VERTEX_ARRAY_BINDING = 0x85B5+gl_CLIP_PLANE4 :: GLenum+gl_CLIP_PLANE4 = 0x3004+gl_EVAL_VERTEX_ATTRIB15_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB15_NV = 0x86D5+gl_POINT_FADE_THRESHOLD_SIZE_ARB :: GLenum+gl_POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128+gl_UNSIGNED_INT_5_9_9_9_REV_EXT :: GLenum+gl_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E+gl_DEBUG_GROUP_STACK_DEPTH :: GLenum+gl_DEBUG_GROUP_STACK_DEPTH = 0x826D+gl_QUERY_WAIT_INVERTED :: GLenum+gl_QUERY_WAIT_INVERTED = 0x8E17+gl_DRAW_PIXEL_TOKEN :: GLenum+gl_DRAW_PIXEL_TOKEN = 0x0705+gl_OPERAND2_ALPHA_ARB :: GLenum+gl_OPERAND2_ALPHA_ARB = 0x859A+gl_STACK_UNDERFLOW :: GLenum+gl_STACK_UNDERFLOW = 0x0504+gl_FLOAT_VEC4_ARB :: GLenum+gl_FLOAT_VEC4_ARB = 0x8B52+gl_OBJECT_INFO_LOG_LENGTH_ARB :: GLenum+gl_OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84+gl_DRAW_BUFFER15_EXT :: GLenum+gl_DRAW_BUFFER15_EXT = 0x8834+gl_PATH_PROJECTION_MATRIX_NV :: GLenum+gl_PATH_PROJECTION_MATRIX_NV = 0x0BA7+gl_ADD_SIGNED :: GLenum+gl_ADD_SIGNED = 0x8574+gl_FRAGMENT_INTERPOLATION_OFFSET_BITS :: GLenum+gl_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D+gl_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum+gl_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF+gl_NEXT_BUFFER_NV :: GLenum+gl_NEXT_BUFFER_NV = -2+gl_TRIANGLE_STRIP_ADJACENCY_ARB :: GLenum+gl_TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D+gl_UNSIGNED_BYTE_2_3_3_REV_EXT :: GLenum+gl_UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362+gl_QUERY_RESULT_NO_WAIT :: GLenum+gl_QUERY_RESULT_NO_WAIT = 0x9194+gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV :: GLenum+gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27+gl_ALPHA16_SNORM :: GLenum+gl_ALPHA16_SNORM = 0x9018+gl_COLOR_ARRAY_LENGTH_NV :: GLenum+gl_COLOR_ARRAY_LENGTH_NV = 0x8F2D+gl_SLUMINANCE_EXT :: GLenum+gl_SLUMINANCE_EXT = 0x8C46+gl_DOT_PRODUCT_TEXTURE_2D_NV :: GLenum+gl_DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES = 0x8CD7+gl_INT_IMAGE_2D_ARRAY :: GLenum+gl_INT_IMAGE_2D_ARRAY = 0x905E+gl_POLYGON_OFFSET_LINE :: GLenum+gl_POLYGON_OFFSET_LINE = 0x2A02+gl_ONE_MINUS_DST_ALPHA :: GLenum+gl_ONE_MINUS_DST_ALPHA = 0x0305+gl_ACCUM_BUFFER_BIT :: GLenum+gl_ACCUM_BUFFER_BIT = 0x00000200+gl_SOURCE1_ALPHA_ARB :: GLenum+gl_SOURCE1_ALPHA_ARB = 0x8589+gl_HISTOGRAM_WIDTH_EXT :: GLenum+gl_HISTOGRAM_WIDTH_EXT = 0x8026+gl_RENDERBUFFER_SAMPLES_EXT :: GLenum+gl_RENDERBUFFER_SAMPLES_EXT = 0x8CAB+gl_FRAGMENT_LIGHTING_SGIX :: GLenum+gl_FRAGMENT_LIGHTING_SGIX = 0x8400+gl_TEXTURE_WIDTH_QCOM :: GLenum+gl_TEXTURE_WIDTH_QCOM = 0x8BD2+gl_TEXTURE_BUFFER_FORMAT_EXT :: GLenum+gl_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E+gl_VERTEX_PROGRAM_TWO_SIDE :: GLenum+gl_VERTEX_PROGRAM_TWO_SIDE = 0x8643+gl_DEBUG_TYPE_OTHER_KHR :: GLenum+gl_DEBUG_TYPE_OTHER_KHR = 0x8251+gl_PRIMARY_COLOR_EXT :: GLenum+gl_PRIMARY_COLOR_EXT = 0x8577+gl_TEXTURE_COMPRESSED_ARB :: GLenum+gl_TEXTURE_COMPRESSED_ARB = 0x86A1+gl_PROXY_TEXTURE_1D_ARRAY_EXT :: GLenum+gl_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19+gl_NORMAL_ARRAY_TYPE :: GLenum+gl_NORMAL_ARRAY_TYPE = 0x807E+gl_POST_COLOR_MATRIX_RED_BIAS_SGI :: GLenum+gl_POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8+gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F+gl_VERTEX_ATTRIB_ARRAY7_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY7_NV = 0x8657+gl_MAX_VERTEX_ATTRIB_STRIDE :: GLenum+gl_MAX_VERTEX_ATTRIB_STRIDE = 0x82E5+gl_COLOR :: GLenum+gl_COLOR = 0x1800+gl_YCBCR_422_APPLE :: GLenum+gl_YCBCR_422_APPLE = 0x85B9+gl_TESS_GEN_SPACING :: GLenum+gl_TESS_GEN_SPACING = 0x8E77+gl_VERTEX_SHADER_INVOCATIONS_ARB :: GLenum+gl_VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0+gl_STENCIL_INDEX4_OES :: GLenum+gl_STENCIL_INDEX4_OES = 0x8D47+gl_COMBINER_CD_DOT_PRODUCT_NV :: GLenum+gl_COMBINER_CD_DOT_PRODUCT_NV = 0x8546+gl_VIRTUAL_PAGE_SIZE_Z_ARB :: GLenum+gl_VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197+gl_RIGHT :: GLenum+gl_RIGHT = 0x0407+gl_ALPHA16F_ARB :: GLenum+gl_ALPHA16F_ARB = 0x881C+gl_TANGENT_ARRAY_TYPE_EXT :: GLenum+gl_TANGENT_ARRAY_TYPE_EXT = 0x843E+gl_READ_FRAMEBUFFER_NV :: GLenum+gl_READ_FRAMEBUFFER_NV = 0x8CA8+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT :: GLenum+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29+gl_PALETTE4_RGB8_OES :: GLenum+gl_PALETTE4_RGB8_OES = 0x8B90+gl_UNSIGNED_INT_IMAGE_3D :: GLenum+gl_UNSIGNED_INT_IMAGE_3D = 0x9064+gl_NORMAL_ARRAY_ADDRESS_NV :: GLenum+gl_NORMAL_ARRAY_ADDRESS_NV = 0x8F22+gl_NO_RESET_NOTIFICATION_EXT :: GLenum+gl_NO_RESET_NOTIFICATION_EXT = 0x8261+gl_RGB4_S3TC :: GLenum+gl_RGB4_S3TC = 0x83A1+gl_AUX1 :: GLenum+gl_AUX1 = 0x040A+gl_MODELVIEW1_ARB :: GLenum+gl_MODELVIEW1_ARB = 0x850A+gl_OP_NEGATE_EXT :: GLenum+gl_OP_NEGATE_EXT = 0x8783+gl_PACK_COMPRESSED_BLOCK_HEIGHT :: GLenum+gl_PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C+gl_RENDERBUFFER_BINDING_OES :: GLenum+gl_RENDERBUFFER_BINDING_OES = 0x8CA7+gl_INT_IMAGE_1D :: GLenum+gl_INT_IMAGE_1D = 0x9057+gl_TEXTURE_GEQUAL_R_SGIX :: GLenum+gl_TEXTURE_GEQUAL_R_SGIX = 0x819D+gl_VERTEX_BINDING_DIVISOR :: GLenum+gl_VERTEX_BINDING_DIVISOR = 0x82D6+gl_BLEND_SRC_ALPHA_OES :: GLenum+gl_BLEND_SRC_ALPHA_OES = 0x80CB+gl_READ_BUFFER_NV :: GLenum+gl_READ_BUFFER_NV = 0x0C02+gl_DEBUG_TYPE_ERROR_KHR :: GLenum+gl_DEBUG_TYPE_ERROR_KHR = 0x824C+gl_INT_IMAGE_CUBE_EXT :: GLenum+gl_INT_IMAGE_CUBE_EXT = 0x905B+gl_COMPRESSED_RGBA_ASTC_6x6x6_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_6x6x6_OES = 0x93C9+gl_IMAGE_MIN_FILTER_HP :: GLenum+gl_IMAGE_MIN_FILTER_HP = 0x815D+gl_QUAD_ALPHA8_SGIS :: GLenum+gl_QUAD_ALPHA8_SGIS = 0x811F+gl_IMAGE_BINDING_LEVEL :: GLenum+gl_IMAGE_BINDING_LEVEL = 0x8F3B+gl_DOT3_RGB_EXT :: GLenum+gl_DOT3_RGB_EXT = 0x8740+gl_SAMPLER_3D_OES :: GLenum+gl_SAMPLER_3D_OES = 0x8B5F+gl_INT_VEC4 :: GLenum+gl_INT_VEC4 = 0x8B55+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC+gl_NO_RESET_NOTIFICATION_ARB :: GLenum+gl_NO_RESET_NOTIFICATION_ARB = 0x8261+gl_IMAGE_MAG_FILTER_HP :: GLenum+gl_IMAGE_MAG_FILTER_HP = 0x815C+gl_COLOR4_BIT_PGI :: GLenum+gl_COLOR4_BIT_PGI = 0x00020000+gl_MAX_CLIPMAP_DEPTH_SGIX :: GLenum+gl_MAX_CLIPMAP_DEPTH_SGIX = 0x8177+gl_DEBUG_CATEGORY_OTHER_AMD :: GLenum+gl_DEBUG_CATEGORY_OTHER_AMD = 0x9150+gl_INT_IMAGE_2D_MULTISAMPLE :: GLenum+gl_INT_IMAGE_2D_MULTISAMPLE = 0x9060+gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA+gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3+gl_BINORMAL_ARRAY_EXT :: GLenum+gl_BINORMAL_ARRAY_EXT = 0x843A+gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211+gl_DRAW_BUFFER9_ARB :: GLenum+gl_DRAW_BUFFER9_ARB = 0x882E+gl_DSDT8_NV :: GLenum+gl_DSDT8_NV = 0x8709+gl_MAP1_VERTEX_ATTRIB9_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB9_4_NV = 0x8669+gl_PROGRAM_OBJECT_ARB :: GLenum+gl_PROGRAM_OBJECT_ARB = 0x8B40+gl_FONT_UNDERLINE_POSITION_BIT_NV :: GLenum+gl_FONT_UNDERLINE_POSITION_BIT_NV = 0x04000000+gl_SHADER_OPERATION_NV :: GLenum+gl_SHADER_OPERATION_NV = 0x86DF+gl_QUERY_RESULT_AVAILABLE_EXT :: GLenum+gl_QUERY_RESULT_AVAILABLE_EXT = 0x8867+gl_VIVIDLIGHT_NV :: GLenum+gl_VIVIDLIGHT_NV = 0x92A6+gl_HSL_HUE_NV :: GLenum+gl_HSL_HUE_NV = 0x92AD+gl_EMBOSS_MAP_NV :: GLenum+gl_EMBOSS_MAP_NV = 0x855F+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB :: GLenum+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D+gl_ALL_BARRIER_BITS :: GLenum+gl_ALL_BARRIER_BITS = 0xFFFFFFFF+gl_TEXTURE11_ARB :: GLenum+gl_TEXTURE11_ARB = 0x84CB+gl_BOLD_BIT_NV :: GLenum+gl_BOLD_BIT_NV = 0x01+gl_SAMPLE_BUFFERS_3DFX :: GLenum+gl_SAMPLE_BUFFERS_3DFX = 0x86B3+gl_INTERNALFORMAT_ALPHA_SIZE :: GLenum+gl_INTERNALFORMAT_ALPHA_SIZE = 0x8274+gl_COMPRESSED_RGBA_ASTC_8x8_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7+gl_VIRTUAL_PAGE_SIZE_Z_AMD :: GLenum+gl_VIRTUAL_PAGE_SIZE_Z_AMD = 0x9197+gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = 0x8A09+gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB :: GLenum+gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3+gl_DRAW_PIXELS_APPLE :: GLenum+gl_DRAW_PIXELS_APPLE = 0x8A0A+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519+gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX :: GLenum+gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402+gl_DRAW_INDIRECT_ADDRESS_NV :: GLenum+gl_DRAW_INDIRECT_ADDRESS_NV = 0x8F41+gl_COVERAGE_BUFFER_BIT_NV :: GLenum+gl_COVERAGE_BUFFER_BIT_NV = 0x00008000+gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT = 0x90CC+gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9+gl_BLUE_NV :: GLenum+gl_BLUE_NV = 0x1905+gl_TEXTURE0_ARB :: GLenum+gl_TEXTURE0_ARB = 0x84C0+gl_DEBUG_SOURCE_THIRD_PARTY_ARB :: GLenum+gl_DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249+gl_TEXTURE_NORMAL_EXT :: GLenum+gl_TEXTURE_NORMAL_EXT = 0x85AF+gl_TEXTURE_BUFFER_FORMAT_ARB :: GLenum+gl_TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E+gl_OPERAND0_ALPHA :: GLenum+gl_OPERAND0_ALPHA = 0x8598+gl_FLOAT_MAT2x3 :: GLenum+gl_FLOAT_MAT2x3 = 0x8B65+gl_TEXTURE_BINDING :: GLenum+gl_TEXTURE_BINDING = 0x82EB+gl_INT_SAMPLER_2D :: GLenum+gl_INT_SAMPLER_2D = 0x8DCA+gl_OR :: GLenum+gl_OR = 0x1507+gl_INT16_VEC2_NV :: GLenum+gl_INT16_VEC2_NV = 0x8FE5+gl_DUAL_ALPHA4_SGIS :: GLenum+gl_DUAL_ALPHA4_SGIS = 0x8110+gl_FRAMEZOOM_FACTOR_SGIX :: GLenum+gl_FRAMEZOOM_FACTOR_SGIX = 0x818C+gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum+gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9056+gl_RGB_INTEGER :: GLenum+gl_RGB_INTEGER = 0x8D98+gl_UNSIGNED_INT64_VEC2_NV :: GLenum+gl_UNSIGNED_INT64_VEC2_NV = 0x8FF5+gl_OUTPUT_TEXTURE_COORD21_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD21_EXT = 0x87B2+gl_ENABLE_BIT :: GLenum+gl_ENABLE_BIT = 0x00002000+gl_POLYGON_OFFSET_EXT :: GLenum+gl_POLYGON_OFFSET_EXT = 0x8037+gl_PIXEL_TEX_GEN_MODE_SGIX :: GLenum+gl_PIXEL_TEX_GEN_MODE_SGIX = 0x832B+gl_LINE_SMOOTH :: GLenum+gl_LINE_SMOOTH = 0x0B20+gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB :: GLenum+gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A+gl_COLOR_TABLE_LUMINANCE_SIZE_SGI :: GLenum+gl_COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE+gl_COLOR_BUFFER_BIT7_QCOM :: GLenum+gl_COLOR_BUFFER_BIT7_QCOM = 0x00000080+gl_PATH_FILL_MODE_NV :: GLenum+gl_PATH_FILL_MODE_NV = 0x9080+gl_IMAGE_CUBE :: GLenum+gl_IMAGE_CUBE = 0x9050+gl_CON_5_ATI :: GLenum+gl_CON_5_ATI = 0x8946+gl_COLOR_ATTACHMENT2_EXT :: GLenum+gl_COLOR_ATTACHMENT2_EXT = 0x8CE2+gl_FAILURE_NV :: GLenum+gl_FAILURE_NV = 0x9030+gl_VERTEX_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080+gl_MAX_SPARSE_TEXTURE_SIZE_ARB :: GLenum+gl_MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198+gl_VERSION_ES_CL_1_1 :: GLenum+gl_VERSION_ES_CL_1_1 = 1+gl_PERFMON_GLOBAL_MODE_QCOM :: GLenum+gl_PERFMON_GLOBAL_MODE_QCOM = 0x8FA0+gl_DEPTH_COMPONENT32F :: GLenum+gl_DEPTH_COMPONENT32F = 0x8CAC+gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT :: GLenum+gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT = 0x9124+gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS :: GLenum+gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F+gl_IMAGE_2D_MULTISAMPLE_EXT :: GLenum+gl_IMAGE_2D_MULTISAMPLE_EXT = 0x9055+gl_FRAMEBUFFER_OES :: GLenum+gl_FRAMEBUFFER_OES = 0x8D40+gl_TRANSPOSE_PROJECTION_MATRIX :: GLenum+gl_TRANSPOSE_PROJECTION_MATRIX = 0x84E4+gl_BUFFER_MAP_POINTER :: GLenum+gl_BUFFER_MAP_POINTER = 0x88BD+gl_INT_10_10_10_2_OES :: GLenum+gl_INT_10_10_10_2_OES = 0x8DF7+gl_PROGRAM_PIPELINE_OBJECT_EXT :: GLenum+gl_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F+gl_GEOMETRY_SHADER_INVOCATIONS_EXT :: GLenum+gl_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x887F+gl_SPRITE_AXIS_SGIX :: GLenum+gl_SPRITE_AXIS_SGIX = 0x814A+gl_RED_INTEGER_EXT :: GLenum+gl_RED_INTEGER_EXT = 0x8D94+gl_COMPRESSED_RGBA_ASTC_10x6_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9+gl_TEXTURE_COORD_ARRAY_COUNT_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B+gl_SIGNED_RGB_NV :: GLenum+gl_SIGNED_RGB_NV = 0x86FE+gl_CW :: GLenum+gl_CW = 0x0900+gl_PACK_SUBSAMPLE_RATE_SGIX :: GLenum+gl_PACK_SUBSAMPLE_RATE_SGIX = 0x85A0+gl_TEXTURE14_ARB :: GLenum+gl_TEXTURE14_ARB = 0x84CE+gl_OUTPUT_TEXTURE_COORD26_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD26_EXT = 0x87B7+gl_DRAW_BUFFER :: GLenum+gl_DRAW_BUFFER = 0x0C01+gl_PACK_ROW_BYTES_APPLE :: GLenum+gl_PACK_ROW_BYTES_APPLE = 0x8A15+gl_BLUE_INTEGER_EXT :: GLenum+gl_BLUE_INTEGER_EXT = 0x8D96+gl_STORAGE_CLIENT_APPLE :: GLenum+gl_STORAGE_CLIENT_APPLE = 0x85B4+gl_ALL_SHADER_BITS :: GLenum+gl_ALL_SHADER_BITS = 0xFFFFFFFF+gl_FOG_COORDINATE_ARRAY_POINTER :: GLenum+gl_FOG_COORDINATE_ARRAY_POINTER = 0x8456+gl_ACTIVE_PROGRAM :: GLenum+gl_ACTIVE_PROGRAM = 0x8259+gl_RGBA32F_ARB :: GLenum+gl_RGBA32F_ARB = 0x8814+gl_VERTEX_ATTRIB_ARRAY_INTEGER :: GLenum+gl_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD+gl_MAP2_VERTEX_ATTRIB13_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB13_4_NV = 0x867D+gl_SAMPLER_2D :: GLenum+gl_SAMPLER_2D = 0x8B5E+gl_QUERY :: GLenum+gl_QUERY = 0x82E3+gl_GEOMETRY_INPUT_TYPE_EXT :: GLenum+gl_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB+gl_RGB5_A1_OES :: GLenum+gl_RGB5_A1_OES = 0x8057+gl_MATRIX15_ARB :: GLenum+gl_MATRIX15_ARB = 0x88CF+gl_INT_IMAGE_CUBE_MAP_ARRAY :: GLenum+gl_INT_IMAGE_CUBE_MAP_ARRAY = 0x905F+gl_STACK_OVERFLOW :: GLenum+gl_STACK_OVERFLOW = 0x0503+gl_NORMAL_ARRAY_LENGTH_NV :: GLenum+gl_NORMAL_ARRAY_LENGTH_NV = 0x8F2C+gl_RENDERBUFFER_BLUE_SIZE_EXT :: GLenum+gl_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52+gl_TEXTURE_INTENSITY_SIZE_EXT :: GLenum+gl_TEXTURE_INTENSITY_SIZE_EXT = 0x8061+gl_POINT_SIZE_MIN_SGIS :: GLenum+gl_POINT_SIZE_MIN_SGIS = 0x8126+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D+gl_BEVEL_NV :: GLenum+gl_BEVEL_NV = 0x90A6+gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX :: GLenum+gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311+gl_SIGNED_RGBA_NV :: GLenum+gl_SIGNED_RGBA_NV = 0x86FB+gl_COLOR_CLEAR_VALUE :: GLenum+gl_COLOR_CLEAR_VALUE = 0x0C22+gl_ARRAY_BUFFER :: GLenum+gl_ARRAY_BUFFER = 0x8892+gl_CLIP_PLANE2_IMG :: GLenum+gl_CLIP_PLANE2_IMG = 0x3002+gl_POLYGON_OFFSET_UNITS :: GLenum+gl_POLYGON_OFFSET_UNITS = 0x2A00+gl_COLOR_ARRAY_POINTER_EXT :: GLenum+gl_COLOR_ARRAY_POINTER_EXT = 0x8090+gl_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum+gl_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2+gl_SHADOW_AMBIENT_SGIX :: GLenum+gl_SHADOW_AMBIENT_SGIX = 0x80BF+gl_SAMPLES :: GLenum+gl_SAMPLES = 0x80A9+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES = 0x93E4+gl_MIRRORED_REPEAT_IBM :: GLenum+gl_MIRRORED_REPEAT_IBM = 0x8370+gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES :: GLenum+gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES = 0x9102+gl_FRAMEBUFFER_DEFAULT_WIDTH :: GLenum+gl_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310+gl_TEXTURE_GEN_MODE_OES :: GLenum+gl_TEXTURE_GEN_MODE_OES = 0x2500+gl_BLEND_SRC_ALPHA_EXT :: GLenum+gl_BLEND_SRC_ALPHA_EXT = 0x80CB+gl_OUTPUT_COLOR0_EXT :: GLenum+gl_OUTPUT_COLOR0_EXT = 0x879B+gl_SLUMINANCE8_ALPHA8 :: GLenum+gl_SLUMINANCE8_ALPHA8 = 0x8C45+gl_SAMPLER_3D_ARB :: GLenum+gl_SAMPLER_3D_ARB = 0x8B5F+gl_UNSIGNED_INT_SAMPLER_3D :: GLenum+gl_UNSIGNED_INT_SAMPLER_3D = 0x8DD3+gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA+gl_PATH_FORMAT_SVG_NV :: GLenum+gl_PATH_FORMAT_SVG_NV = 0x9070+gl_MAP1_BINORMAL_EXT :: GLenum+gl_MAP1_BINORMAL_EXT = 0x8446+gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX :: GLenum+gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188+gl_COLOR_ARRAY_BUFFER_BINDING :: GLenum+gl_COLOR_ARRAY_BUFFER_BINDING = 0x8898+gl_MATRIX_INDEX_ARRAY_TYPE_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_TYPE_OES = 0x8847+gl_PROJECTION_STACK_DEPTH :: GLenum+gl_PROJECTION_STACK_DEPTH = 0x0BA4+gl_AUTO_NORMAL :: GLenum+gl_AUTO_NORMAL = 0x0D80+gl_FRAGMENT_SHADER_ATI :: GLenum+gl_FRAGMENT_SHADER_ATI = 0x8920+gl_SAMPLE_BUFFERS_EXT :: GLenum+gl_SAMPLE_BUFFERS_EXT = 0x80A8+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x906C+gl_UNSIGNED_INT_10_10_10_2 :: GLenum+gl_UNSIGNED_INT_10_10_10_2 = 0x8036+gl_COMPRESSED_RG11_EAC_OES :: GLenum+gl_COMPRESSED_RG11_EAC_OES = 0x9272+gl_LUMINANCE8I_EXT :: GLenum+gl_LUMINANCE8I_EXT = 0x8D92+gl_VERTEX_ATTRIB_ARRAY13_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY13_NV = 0x865D+gl_UNIFORM_BUFFER_SIZE :: GLenum+gl_UNIFORM_BUFFER_SIZE = 0x8A2A+gl_TEXTURE2_ARB :: GLenum+gl_TEXTURE2_ARB = 0x84C2+gl_COMPRESSED_RGBA_BPTC_UNORM_ARB :: GLenum+gl_COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C+gl_POLYGON :: GLenum+gl_POLYGON = 0x0009+gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT :: GLenum+gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000+gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895+gl_SAMPLE_BUFFERS_ARB :: GLenum+gl_SAMPLE_BUFFERS_ARB = 0x80A8+gl_RGBA4_DXT5_S3TC :: GLenum+gl_RGBA4_DXT5_S3TC = 0x83A5+gl_STREAM_READ :: GLenum+gl_STREAM_READ = 0x88E1+gl_STATIC_READ :: GLenum+gl_STATIC_READ = 0x88E5+gl_MAX_FRAGMENT_ATOMIC_COUNTERS :: GLenum+gl_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6+gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT :: GLenum+gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72+gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST :: GLenum+gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD+gl_COUNT_DOWN_NV :: GLenum+gl_COUNT_DOWN_NV = 0x9089+gl_SLUMINANCE :: GLenum+gl_SLUMINANCE = 0x8C46+gl_INNOCENT_CONTEXT_RESET :: GLenum+gl_INNOCENT_CONTEXT_RESET = 0x8254+gl_DRAW_FRAMEBUFFER_BINDING_NV :: GLenum+gl_DRAW_FRAMEBUFFER_BINDING_NV = 0x8CA6+gl_VERTEX_STREAM3_ATI :: GLenum+gl_VERTEX_STREAM3_ATI = 0x876F+gl_TRIANGULAR_NV :: GLenum+gl_TRIANGULAR_NV = 0x90A5+gl_SAMPLER_2D_RECT_ARB :: GLenum+gl_SAMPLER_2D_RECT_ARB = 0x8B63+gl_POST_CONVOLUTION_GREEN_SCALE_EXT :: GLenum+gl_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D+gl_SKIP_COMPONENTS2_NV :: GLenum+gl_SKIP_COMPONENTS2_NV = -5+gl_IMAGE_1D :: GLenum+gl_IMAGE_1D = 0x904C+gl_ATTRIB_ARRAY_TYPE_NV :: GLenum+gl_ATTRIB_ARRAY_TYPE_NV = 0x8625+gl_ORDER :: GLenum+gl_ORDER = 0x0A01+gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E+gl_RGB4_EXT :: GLenum+gl_RGB4_EXT = 0x804F+gl_COMPRESSED_TEXTURE_FORMATS_ARB :: GLenum+gl_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3+gl_STENCIL_INDEX16_EXT :: GLenum+gl_STENCIL_INDEX16_EXT = 0x8D49+gl_OP_RECIP_SQRT_EXT :: GLenum+gl_OP_RECIP_SQRT_EXT = 0x8795+gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1+gl_MAX_PROGRAM_TEXEL_OFFSET :: GLenum+gl_MAX_PROGRAM_TEXEL_OFFSET = 0x8905+gl_POST_TEXTURE_FILTER_BIAS_SGIX :: GLenum+gl_POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179+gl_RGB32F_EXT :: GLenum+gl_RGB32F_EXT = 0x8815+gl_SURFACE_REGISTERED_NV :: GLenum+gl_SURFACE_REGISTERED_NV = 0x86FD+gl_RGBA_FLOAT16_APPLE :: GLenum+gl_RGBA_FLOAT16_APPLE = 0x881A+gl_VIDEO_BUFFER_BINDING_NV :: GLenum+gl_VIDEO_BUFFER_BINDING_NV = 0x9021+gl_PRIMITIVE_RESTART_INDEX :: GLenum+gl_PRIMITIVE_RESTART_INDEX = 0x8F9E+gl_DOT3_RGB_ARB :: GLenum+gl_DOT3_RGB_ARB = 0x86AE+gl_INT64_VEC4_NV :: GLenum+gl_INT64_VEC4_NV = 0x8FEB+gl_DRAW_BUFFER12_ATI :: GLenum+gl_DRAW_BUFFER12_ATI = 0x8831+gl_RESAMPLE_REPLICATE_SGIX :: GLenum+gl_RESAMPLE_REPLICATE_SGIX = 0x842E+gl_ALPHA :: GLenum+gl_ALPHA = 0x1906+gl_MATRIX22_ARB :: GLenum+gl_MATRIX22_ARB = 0x88D6+gl_DEPTH_TEST :: GLenum+gl_DEPTH_TEST = 0x0B71+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5+gl_BLEND_SRC_ALPHA :: GLenum+gl_BLEND_SRC_ALPHA = 0x80CB+gl_MIRROR_CLAMP_ATI :: GLenum+gl_MIRROR_CLAMP_ATI = 0x8742+gl_COMBINER3_NV :: GLenum+gl_COMBINER3_NV = 0x8553+gl_TEXTURE_BINDING_1D_ARRAY_EXT :: GLenum+gl_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C+gl_MIRROR_CLAMP_TO_BORDER_EXT :: GLenum+gl_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912+gl_MAP1_INDEX :: GLenum+gl_MAP1_INDEX = 0x0D91+gl_VIEW_CLASS_BPTC_FLOAT :: GLenum+gl_VIEW_CLASS_BPTC_FLOAT = 0x82D3+gl_TRANSPOSE_AFFINE_2D_NV :: GLenum+gl_TRANSPOSE_AFFINE_2D_NV = 0x9096+gl_IMAGE_CLASS_2_X_8 :: GLenum+gl_IMAGE_CLASS_2_X_8 = 0x82C0+gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808+gl_EYE_POINT_SGIS :: GLenum+gl_EYE_POINT_SGIS = 0x81F4+gl_TEXTURE_DEPTH_SIZE_ARB :: GLenum+gl_TEXTURE_DEPTH_SIZE_ARB = 0x884A+gl_GLYPH_HAS_KERNING_BIT_NV :: GLenum+gl_GLYPH_HAS_KERNING_BIT_NV = 0x100+gl_ACTIVE_SUBROUTINES :: GLenum+gl_ACTIVE_SUBROUTINES = 0x8DE5+gl_MVP_MATRIX_EXT :: GLenum+gl_MVP_MATRIX_EXT = 0x87E3+gl_READ_FRAMEBUFFER_BINDING :: GLenum+gl_READ_FRAMEBUFFER_BINDING = 0x8CAA+gl_GUILTY_CONTEXT_RESET_EXT :: GLenum+gl_GUILTY_CONTEXT_RESET_EXT = 0x8253+gl_ALPHA16UI_EXT :: GLenum+gl_ALPHA16UI_EXT = 0x8D78+gl_TEXTURE_SWIZZLE_B_EXT :: GLenum+gl_TEXTURE_SWIZZLE_B_EXT = 0x8E44+gl_RGB16I_EXT :: GLenum+gl_RGB16I_EXT = 0x8D89+gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B+gl_VERTEX_WEIGHT_ARRAY_EXT :: GLenum+gl_VERTEX_WEIGHT_ARRAY_EXT = 0x850C+gl_SWIZZLE_STR_DR_ATI :: GLenum+gl_SWIZZLE_STR_DR_ATI = 0x8978+gl_READ_FRAMEBUFFER :: GLenum+gl_READ_FRAMEBUFFER = 0x8CA8+gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI :: GLenum+gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5+gl_COORD_REPLACE_NV :: GLenum+gl_COORD_REPLACE_NV = 0x8862+gl_MAX_CLIP_PLANES :: GLenum+gl_MAX_CLIP_PLANES = 0x0D32+gl_DRAW_BUFFER0 :: GLenum+gl_DRAW_BUFFER0 = 0x8825+gl_SPRITE_OBJECT_ALIGNED_SGIX :: GLenum+gl_SPRITE_OBJECT_ALIGNED_SGIX = 0x814D+gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX :: GLenum+gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B+gl_CONSERVE_MEMORY_HINT_PGI :: GLenum+gl_CONSERVE_MEMORY_HINT_PGI = 0x1A1FD+gl_GET_TEXTURE_IMAGE_FORMAT :: GLenum+gl_GET_TEXTURE_IMAGE_FORMAT = 0x8291+gl_MOVE_TO_RESETS_NV :: GLenum+gl_MOVE_TO_RESETS_NV = 0x90B5+gl_SHADER_CONSISTENT_NV :: GLenum+gl_SHADER_CONSISTENT_NV = 0x86DD+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516+gl_PACK_ALIGNMENT :: GLenum+gl_PACK_ALIGNMENT = 0x0D05+gl_HISTOGRAM_ALPHA_SIZE :: GLenum+gl_HISTOGRAM_ALPHA_SIZE = 0x802B+gl_SHARED_TEXTURE_PALETTE_EXT :: GLenum+gl_SHARED_TEXTURE_PALETTE_EXT = 0x81FB+gl_MODELVIEW0_MATRIX_EXT :: GLenum+gl_MODELVIEW0_MATRIX_EXT = 0x0BA6+gl_MAX_NAME_LENGTH :: GLenum+gl_MAX_NAME_LENGTH = 0x92F6+gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY :: GLenum+gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105+gl_IMAGE_2D :: GLenum+gl_IMAGE_2D = 0x904D+gl_QUERY_BUFFER_AMD :: GLenum+gl_QUERY_BUFFER_AMD = 0x9192+gl_BUMP_ENVMAP_ATI :: GLenum+gl_BUMP_ENVMAP_ATI = 0x877B+gl_POINTS :: GLenum+gl_POINTS = 0x0000+gl_ARRAY_SIZE :: GLenum+gl_ARRAY_SIZE = 0x92FB+gl_MAX_CLIP_PLANES_IMG :: GLenum+gl_MAX_CLIP_PLANES_IMG = 0x0D32+gl_TRIANGLE_STRIP_ADJACENCY_EXT :: GLenum+gl_TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D+gl_VERTEX_STREAM6_ATI :: GLenum+gl_VERTEX_STREAM6_ATI = 0x8772+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR :: GLenum+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E+gl_TEXTURE22 :: GLenum+gl_TEXTURE22 = 0x84D6+gl_CURRENT_FOG_COORDINATE :: GLenum+gl_CURRENT_FOG_COORDINATE = 0x8453+gl_CON_27_ATI :: GLenum+gl_CON_27_ATI = 0x895C+gl_MAX_VERTEX_UNITS_OES :: GLenum+gl_MAX_VERTEX_UNITS_OES = 0x86A4+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF+gl_SIGNED_INTENSITY8_NV :: GLenum+gl_SIGNED_INTENSITY8_NV = 0x8708+gl_MAX_EVAL_ORDER :: GLenum+gl_MAX_EVAL_ORDER = 0x0D30+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518+gl_DYNAMIC_READ_ARB :: GLenum+gl_DYNAMIC_READ_ARB = 0x88E9+gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV :: GLenum+gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D+gl_FLOAT16_NV :: GLenum+gl_FLOAT16_NV = 0x8FF8+gl_COMPUTE_SHADER_INVOCATIONS_ARB :: GLenum+gl_COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5+gl_VERTEX_SHADER_OPTIMIZED_EXT :: GLenum+gl_VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4+gl_TEXTURE_LOD_BIAS_EXT :: GLenum+gl_TEXTURE_LOD_BIAS_EXT = 0x8501+gl_INT8_VEC3_NV :: GLenum+gl_INT8_VEC3_NV = 0x8FE2+gl_4PASS_0_SGIS :: GLenum+gl_4PASS_0_SGIS = 0x80A4+gl_HISTOGRAM_EXT :: GLenum+gl_HISTOGRAM_EXT = 0x8024+gl_ALLOW_DRAW_WIN_HINT_PGI :: GLenum+gl_ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F+gl_TEXTURE_GREEN_SIZE_EXT :: GLenum+gl_TEXTURE_GREEN_SIZE_EXT = 0x805D+gl_R32I :: GLenum+gl_R32I = 0x8235+gl_REG_22_ATI :: GLenum+gl_REG_22_ATI = 0x8937+gl_UNSIGNED_INT_ATOMIC_COUNTER :: GLenum+gl_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB+gl_COLOR_ATTACHMENT2 :: GLenum+gl_COLOR_ATTACHMENT2 = 0x8CE2+gl_INTENSITY8 :: GLenum+gl_INTENSITY8 = 0x804B+gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7+gl_FOG_DENSITY :: GLenum+gl_FOG_DENSITY = 0x0B62+gl_RENDERBUFFER_HEIGHT_EXT :: GLenum+gl_RENDERBUFFER_HEIGHT_EXT = 0x8D43+gl_Z_EXT :: GLenum+gl_Z_EXT = 0x87D7+gl_TEXTURE_FETCH_BARRIER_BIT :: GLenum+gl_TEXTURE_FETCH_BARRIER_BIT = 0x00000008+gl_PROGRAM_BINARY_FORMATS :: GLenum+gl_PROGRAM_BINARY_FORMATS = 0x87FF+gl_UNSIGNED_INT_IMAGE_BUFFER :: GLenum+gl_UNSIGNED_INT_IMAGE_BUFFER = 0x9067+gl_OPERAND0_RGB :: GLenum+gl_OPERAND0_RGB = 0x8590+gl_COVERAGE_COMPONENT_NV :: GLenum+gl_COVERAGE_COMPONENT_NV = 0x8ED0+gl_NEGATE_BIT_ATI :: GLenum+gl_NEGATE_BIT_ATI = 0x00000004+gl_DEBUG_TYPE_PUSH_GROUP :: GLenum+gl_DEBUG_TYPE_PUSH_GROUP = 0x8269+gl_SELECT :: GLenum+gl_SELECT = 0x1C02+gl_IMAGE_BINDING_ACCESS_EXT :: GLenum+gl_IMAGE_BINDING_ACCESS_EXT = 0x8F3E+gl_TEXTURE_GEN_STR_OES :: GLenum+gl_TEXTURE_GEN_STR_OES = 0x8D60+gl_OCCLUSION_TEST_HP :: GLenum+gl_OCCLUSION_TEST_HP = 0x8165+gl_BLEND_DST_RGB_OES :: GLenum+gl_BLEND_DST_RGB_OES = 0x80C8+gl_IMAGE_BINDING_NAME :: GLenum+gl_IMAGE_BINDING_NAME = 0x8F3A+gl_DUAL_LUMINANCE_ALPHA8_SGIS :: GLenum+gl_DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D+gl_POLYGON_BIT :: GLenum+gl_POLYGON_BIT = 0x00000008+gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI :: GLenum+gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9+gl_COLOR_ATTACHMENT8_EXT :: GLenum+gl_COLOR_ATTACHMENT8_EXT = 0x8CE8+gl_BLUE_BIAS :: GLenum+gl_BLUE_BIAS = 0x0D1B+gl_EMISSION :: GLenum+gl_EMISSION = 0x1600+gl_DEPTH_ATTACHMENT_OES :: GLenum+gl_DEPTH_ATTACHMENT_OES = 0x8D00+gl_POLYGON_OFFSET_FACTOR_EXT :: GLenum+gl_POLYGON_OFFSET_FACTOR_EXT = 0x8038+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT = 0x92D4+gl_TEXTURE_MATERIAL_FACE_EXT :: GLenum+gl_TEXTURE_MATERIAL_FACE_EXT = 0x8351+gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI :: GLenum+gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6+gl_DRAW_FRAMEBUFFER_ANGLE :: GLenum+gl_DRAW_FRAMEBUFFER_ANGLE = 0x8CA9+gl_DEPTH_BUFFER_BIT3_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT3_QCOM = 0x00000800+gl_DISTANCE_ATTENUATION_EXT :: GLenum+gl_DISTANCE_ATTENUATION_EXT = 0x8129+gl_TRACE_ARRAYS_BIT_MESA :: GLenum+gl_TRACE_ARRAYS_BIT_MESA = 0x0004+gl_MOVE_TO_NV :: GLenum+gl_MOVE_TO_NV = 0x02+gl_2PASS_1_SGIS :: GLenum+gl_2PASS_1_SGIS = 0x80A3+gl_DUAL_LUMINANCE4_SGIS :: GLenum+gl_DUAL_LUMINANCE4_SGIS = 0x8114+gl_PRIMITIVES_SUBMITTED_ARB :: GLenum+gl_PRIMITIVES_SUBMITTED_ARB = 0x82EF+gl_TOP_LEVEL_ARRAY_STRIDE :: GLenum+gl_TOP_LEVEL_ARRAY_STRIDE = 0x930D+gl_NORMAL_ARRAY_STRIDE :: GLenum+gl_NORMAL_ARRAY_STRIDE = 0x807F+gl_TEXTURE_2D_ARRAY_EXT :: GLenum+gl_TEXTURE_2D_ARRAY_EXT = 0x8C1A+gl_UNPACK_COMPRESSED_BLOCK_WIDTH :: GLenum+gl_UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127+gl_TEXTURE_FIXED_SAMPLE_LOCATIONS :: GLenum+gl_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107+gl_YCRCBA_SGIX :: GLenum+gl_YCRCBA_SGIX = 0x8319+gl_LOCATION_COMPONENT :: GLenum+gl_LOCATION_COMPONENT = 0x934A+gl_TEXTURE27 :: GLenum+gl_TEXTURE27 = 0x84DB+gl_CONTEXT_FLAG_DEBUG_BIT_KHR :: GLenum+gl_CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002+gl_FOG_COORDINATE_EXT :: GLenum+gl_FOG_COORDINATE_EXT = 0x8451+gl_DEBUG_CALLBACK_USER_PARAM_KHR :: GLenum+gl_DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245+gl_MIRRORED_REPEAT_OES :: GLenum+gl_MIRRORED_REPEAT_OES = 0x8370+gl_SYNC_GPU_COMMANDS_COMPLETE :: GLenum+gl_SYNC_GPU_COMMANDS_COMPLETE = 0x9117+gl_SLUMINANCE8_ALPHA8_EXT :: GLenum+gl_SLUMINANCE8_ALPHA8_EXT = 0x8C45+gl_TEXTURE_BUFFER_OFFSET :: GLenum+gl_TEXTURE_BUFFER_OFFSET = 0x919D+gl_PROXY_COLOR_TABLE :: GLenum+gl_PROXY_COLOR_TABLE = 0x80D3+gl_FIXED :: GLenum+gl_FIXED = 0x140C+gl_SRGB8 :: GLenum+gl_SRGB8 = 0x8C41+gl_COMPRESSED_RGBA :: GLenum+gl_COMPRESSED_RGBA = 0x84EE+gl_IMAGE_BINDING_FORMAT :: GLenum+gl_IMAGE_BINDING_FORMAT = 0x906E+gl_MAX_RENDERBUFFER_SIZE_OES :: GLenum+gl_MAX_RENDERBUFFER_SIZE_OES = 0x84E8+gl_DEBUG_SOURCE_API :: GLenum+gl_DEBUG_SOURCE_API = 0x8246+gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH :: GLenum+gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49+gl_CLIP_PLANE3_IMG :: GLenum+gl_CLIP_PLANE3_IMG = 0x3003+gl_TEXTURE16 :: GLenum+gl_TEXTURE16 = 0x84D0+gl_FRAGMENTS_INSTRUMENT_SGIX :: GLenum+gl_FRAGMENTS_INSTRUMENT_SGIX = 0x8313+gl_MATRIX8_ARB :: GLenum+gl_MATRIX8_ARB = 0x88C8+gl_DOUBLE_MAT2x4 :: GLenum+gl_DOUBLE_MAT2x4 = 0x8F4A+gl_DRAW_BUFFER9_ATI :: GLenum+gl_DRAW_BUFFER9_ATI = 0x882E+gl_CURRENT_TEXTURE_COORDS :: GLenum+gl_CURRENT_TEXTURE_COORDS = 0x0B03+gl_DOT_PRODUCT_TEXTURE_3D_NV :: GLenum+gl_DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF+gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT :: GLenum+gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C+gl_UNSIGNED_INT_IMAGE_2D_ARRAY :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069+gl_FRAMEBUFFER_BARRIER_BIT :: GLenum+gl_FRAMEBUFFER_BARRIER_BIT = 0x00000400+gl_MAX_SAMPLES_IMG :: GLenum+gl_MAX_SAMPLES_IMG = 0x9135+gl_TESS_CONTROL_SHADER_BIT_EXT :: GLenum+gl_TESS_CONTROL_SHADER_BIT_EXT = 0x00000008+gl_PROGRAM_NATIVE_TEMPORARIES_ARB :: GLenum+gl_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6+gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG :: GLenum+gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00+gl_VERTEX_PROGRAM_ARB :: GLenum+gl_VERTEX_PROGRAM_ARB = 0x8620+gl_MAP2_BINORMAL_EXT :: GLenum+gl_MAP2_BINORMAL_EXT = 0x8447+gl_ETC1_RGB8_OES :: GLenum+gl_ETC1_RGB8_OES = 0x8D64+gl_PROGRAM_MATRIX_STACK_DEPTH_EXT :: GLenum+gl_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F+gl_TEXTURE_USAGE_ANGLE :: GLenum+gl_TEXTURE_USAGE_ANGLE = 0x93A2+gl_TEXTURE_MATRIX :: GLenum+gl_TEXTURE_MATRIX = 0x0BA8+gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum+gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900E+gl_INDEX_ARRAY_STRIDE :: GLenum+gl_INDEX_ARRAY_STRIDE = 0x8086+gl_POST_COLOR_MATRIX_BLUE_SCALE :: GLenum+gl_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6+gl_TESS_CONTROL_OUTPUT_VERTICES :: GLenum+gl_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET :: GLenum+gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E+gl_COMPRESSED_RGBA_ASTC_6x6_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4+gl_INTERNALFORMAT_SHARED_SIZE :: GLenum+gl_INTERNALFORMAT_SHARED_SIZE = 0x8277+gl_SOURCE1_RGB_EXT :: GLenum+gl_SOURCE1_RGB_EXT = 0x8581+gl_STENCIL_PASS_DEPTH_FAIL :: GLenum+gl_STENCIL_PASS_DEPTH_FAIL = 0x0B95+gl_MATRIX_PALETTE_OES :: GLenum+gl_MATRIX_PALETTE_OES = 0x8840+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET :: GLenum+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B+gl_DOT3_RGBA_EXT :: GLenum+gl_DOT3_RGBA_EXT = 0x8741+gl_CLIP_VOLUME_CLIPPING_HINT_EXT :: GLenum+gl_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0+gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV :: GLenum+gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80+gl_FONT_X_MIN_BOUNDS_BIT_NV :: GLenum+gl_FONT_X_MIN_BOUNDS_BIT_NV = 0x00010000+gl_WRAP_BORDER_SUN :: GLenum+gl_WRAP_BORDER_SUN = 0x81D4+gl_MAP_INVALIDATE_RANGE_BIT :: GLenum+gl_MAP_INVALIDATE_RANGE_BIT = 0x0004+gl_PATH_MODELVIEW_NV :: GLenum+gl_PATH_MODELVIEW_NV = 0x1700+gl_TESS_CONTROL_SHADER :: GLenum+gl_TESS_CONTROL_SHADER = 0x8E88+gl_VERTEX_STREAM1_ATI :: GLenum+gl_VERTEX_STREAM1_ATI = 0x876D+gl_R3_G3_B2 :: GLenum+gl_R3_G3_B2 = 0x2A10+gl_LARGE_CW_ARC_TO_NV :: GLenum+gl_LARGE_CW_ARC_TO_NV = 0x18+gl_PRIMITIVE_BOUNDING_BOX_EXT :: GLenum+gl_PRIMITIVE_BOUNDING_BOX_EXT = 0x92BE+gl_ALPHA_BIAS :: GLenum+gl_ALPHA_BIAS = 0x0D1D+gl_DST_IN_NV :: GLenum+gl_DST_IN_NV = 0x928B+gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT :: GLenum+gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT = 0x92D3+gl_NUM_FILL_STREAMS_NV :: GLenum+gl_NUM_FILL_STREAMS_NV = 0x8E29+gl_ATTRIB_ARRAY_POINTER_NV :: GLenum+gl_ATTRIB_ARRAY_POINTER_NV = 0x8645+gl_SOURCE0_RGB_ARB :: GLenum+gl_SOURCE0_RGB_ARB = 0x8580+gl_MAX_PROGRAM_TEXEL_OFFSET_EXT :: GLenum+gl_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905+gl_MATRIX27_ARB :: GLenum+gl_MATRIX27_ARB = 0x88DB+gl_R11F_G11F_B10F :: GLenum+gl_R11F_G11F_B10F = 0x8C3A+gl_ATOMIC_COUNTER_BUFFER_INDEX :: GLenum+gl_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301+gl_TEXTURE_SWIZZLE_R_EXT :: GLenum+gl_TEXTURE_SWIZZLE_R_EXT = 0x8E42+gl_MAX_ASYNC_READ_PIXELS_SGIX :: GLenum+gl_MAX_ASYNC_READ_PIXELS_SGIX = 0x8361+gl_ACTIVE_TEXTURE_ARB :: GLenum+gl_ACTIVE_TEXTURE_ARB = 0x84E0+gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum+gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2+gl_REFERENCE_PLANE_SGIX :: GLenum+gl_REFERENCE_PLANE_SGIX = 0x817D+gl_UNPACK_CLIENT_STORAGE_APPLE :: GLenum+gl_UNPACK_CLIENT_STORAGE_APPLE = 0x85B2+gl_SKIP_DECODE_EXT :: GLenum+gl_SKIP_DECODE_EXT = 0x8A4A+gl_MAP2_VERTEX_ATTRIB10_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB10_4_NV = 0x867A+gl_ALIASED_POINT_SIZE_RANGE :: GLenum+gl_ALIASED_POINT_SIZE_RANGE = 0x846D+gl_MATRIX1_NV :: GLenum+gl_MATRIX1_NV = 0x8631+gl_CCW :: GLenum+gl_CCW = 0x0901+gl_SIGNED_RGB_UNSIGNED_ALPHA_NV :: GLenum+gl_SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C+gl_TEXTURE_BUFFER_BINDING_EXT :: GLenum+gl_TEXTURE_BUFFER_BINDING_EXT = 0x8C2A+gl_LINEAR_ATTENUATION :: GLenum+gl_LINEAR_ATTENUATION = 0x1208+gl_FACTOR_MIN_AMD :: GLenum+gl_FACTOR_MIN_AMD = 0x901C+gl_POINT_SPRITE_NV :: GLenum+gl_POINT_SPRITE_NV = 0x8861+gl_IMAGE_FORMAT_COMPATIBILITY_TYPE :: GLenum+gl_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7+gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD :: GLenum+gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD = 0x00000002+gl_MAP2_VERTEX_ATTRIB4_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB4_4_NV = 0x8674+gl_PATCHES_EXT :: GLenum+gl_PATCHES_EXT = 0x000E+gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS :: GLenum+gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A+gl_OUTPUT_TEXTURE_COORD14_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD14_EXT = 0x87AB+gl_V3F :: GLenum+gl_V3F = 0x2A21+gl_4PASS_2_EXT :: GLenum+gl_4PASS_2_EXT = 0x80A6+gl_SAMPLES_3DFX :: GLenum+gl_SAMPLES_3DFX = 0x86B4+gl_MINOR_VERSION :: GLenum+gl_MINOR_VERSION = 0x821C+gl_MAX_DEBUG_LOGGED_MESSAGES_ARB :: GLenum+gl_MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144+gl_FUNC_REVERSE_SUBTRACT :: GLenum+gl_FUNC_REVERSE_SUBTRACT = 0x800B+gl_LAYOUT_LINEAR_CPU_CACHED_INTEL :: GLenum+gl_LAYOUT_LINEAR_CPU_CACHED_INTEL = 2+gl_MULTISAMPLE_BUFFER_BIT1_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT1_QCOM = 0x02000000+gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV :: GLenum+gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D+gl_PATH_COVER_DEPTH_FUNC_NV :: GLenum+gl_PATH_COVER_DEPTH_FUNC_NV = 0x90BF+gl_MAX_FRAGMENT_IMAGE_UNIFORMS :: GLenum+gl_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE+gl_PROXY_TEXTURE_COLOR_TABLE_SGI :: GLenum+gl_PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD+gl_PIXEL_MAP_I_TO_A_SIZE :: GLenum+gl_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5+gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX :: GLenum+gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0+gl_FRAME_NV :: GLenum+gl_FRAME_NV = 0x8E26+gl_FLOAT_R_NV :: GLenum+gl_FLOAT_R_NV = 0x8880+gl_REFLECTION_MAP_EXT :: GLenum+gl_REFLECTION_MAP_EXT = 0x8512+gl_RG_SNORM :: GLenum+gl_RG_SNORM = 0x8F91+gl_REPLACE_MIDDLE_SUN :: GLenum+gl_REPLACE_MIDDLE_SUN = 0x0002+gl_COMBINER_MAPPING_NV :: GLenum+gl_COMBINER_MAPPING_NV = 0x8543+gl_ELEMENT_ARRAY_BUFFER_ARB :: GLenum+gl_ELEMENT_ARRAY_BUFFER_ARB = 0x8893+gl_SECONDARY_COLOR_ARRAY_LENGTH_NV :: GLenum+gl_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31+gl_INTERPOLATE_ARB :: GLenum+gl_INTERPOLATE_ARB = 0x8575+gl_POSITION :: GLenum+gl_POSITION = 0x1203+gl_PIXEL_MAP_S_TO_S :: GLenum+gl_PIXEL_MAP_S_TO_S = 0x0C71+gl_READ_ONLY_ARB :: GLenum+gl_READ_ONLY_ARB = 0x88B8+gl_INVALID_FRAMEBUFFER_OPERATION_OES :: GLenum+gl_INVALID_FRAMEBUFFER_OPERATION_OES = 0x0506+gl_3DC_X_AMD :: GLenum+gl_3DC_X_AMD = 0x87F9+gl_FRAGMENT_LIGHT2_SGIX :: GLenum+gl_FRAGMENT_LIGHT2_SGIX = 0x840E+gl_IMAGE_SCALE_Y_HP :: GLenum+gl_IMAGE_SCALE_Y_HP = 0x8156+gl_READ_FRAMEBUFFER_APPLE :: GLenum+gl_READ_FRAMEBUFFER_APPLE = 0x8CA8+gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES :: GLenum+gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6+gl_INDEX_MATERIAL_PARAMETER_EXT :: GLenum+gl_INDEX_MATERIAL_PARAMETER_EXT = 0x81B9+gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: GLenum+gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76+gl_CUBIC_CURVE_TO_NV :: GLenum+gl_CUBIC_CURVE_TO_NV = 0x0C+gl_QUAD_ALPHA4_SGIS :: GLenum+gl_QUAD_ALPHA4_SGIS = 0x811E+gl_FORCE_BLUE_TO_ONE_NV :: GLenum+gl_FORCE_BLUE_TO_ONE_NV = 0x8860+gl_DOT_PRODUCT_DEPTH_REPLACE_NV :: GLenum+gl_DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED+gl_MAX_VERTEX_OUTPUT_COMPONENTS :: GLenum+gl_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122+gl_COMPRESSED_RGBA_ASTC_4x4x3_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_4x4x3_OES = 0x93C2+gl_COLOR_INDEX1_EXT :: GLenum+gl_COLOR_INDEX1_EXT = 0x80E2+gl_RELATIVE_CUBIC_CURVE_TO_NV :: GLenum+gl_RELATIVE_CUBIC_CURVE_TO_NV = 0x0D+gl_NOR :: GLenum+gl_NOR = 0x1508+gl_CLIPPING_OUTPUT_PRIMITIVES_ARB :: GLenum+gl_CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7+gl_VERTEX_ATTRIB_ARRAY12_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY12_NV = 0x865C+gl_LINE_BIT :: GLenum+gl_LINE_BIT = 0x00000004+gl_FOG_COORDINATE_ARRAY_STRIDE :: GLenum+gl_FOG_COORDINATE_ARRAY_STRIDE = 0x8455+gl_DUP_FIRST_CUBIC_CURVE_TO_NV :: GLenum+gl_DUP_FIRST_CUBIC_CURVE_TO_NV = 0xF2+gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES = 0x8CDA+gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E+gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV :: GLenum+gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0x0D36+gl_FRAGMENT_LIGHT1_SGIX :: GLenum+gl_FRAGMENT_LIGHT1_SGIX = 0x840D+gl_PALETTE8_R5_G6_B5_OES :: GLenum+gl_PALETTE8_R5_G6_B5_OES = 0x8B97+gl_DUAL_INTENSITY4_SGIS :: GLenum+gl_DUAL_INTENSITY4_SGIS = 0x8118+gl_TEXTURE_RANGE_LENGTH_APPLE :: GLenum+gl_TEXTURE_RANGE_LENGTH_APPLE = 0x85B7+gl_TEXTURE_RECTANGLE_ARB :: GLenum+gl_TEXTURE_RECTANGLE_ARB = 0x84F5+gl_LUMINANCE16F_EXT :: GLenum+gl_LUMINANCE16F_EXT = 0x881E+gl_DEPTH_COMPONENT16_ARB :: GLenum+gl_DEPTH_COMPONENT16_ARB = 0x81A5+gl_BUMP_TARGET_ATI :: GLenum+gl_BUMP_TARGET_ATI = 0x877C+gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB :: GLenum+gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C+gl_DOUBLE_MAT3_EXT :: GLenum+gl_DOUBLE_MAT3_EXT = 0x8F47+gl_QUERY_BY_REGION_NO_WAIT_INVERTED :: GLenum+gl_QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A+gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB :: GLenum+gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D+gl_QUADS :: GLenum+gl_QUADS = 0x0007+gl_ALPHA_INTEGER_EXT :: GLenum+gl_ALPHA_INTEGER_EXT = 0x8D97+gl_VERTEX_SHADER_BIT_EXT :: GLenum+gl_VERTEX_SHADER_BIT_EXT = 0x00000001+gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175+gl_COLOR_MATERIAL_FACE :: GLenum+gl_COLOR_MATERIAL_FACE = 0x0B55+gl_LIGHT_MODEL_TWO_SIDE :: GLenum+gl_LIGHT_MODEL_TWO_SIDE = 0x0B52+gl_INTERLEAVED_ATTRIBS :: GLenum+gl_INTERLEAVED_ATTRIBS = 0x8C8C+gl_RGBA16I :: GLenum+gl_RGBA16I = 0x8D88+gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625+gl_DEBUG_SEVERITY_LOW_AMD :: GLenum+gl_DEBUG_SEVERITY_LOW_AMD = 0x9148+gl_POINT_SPRITE_COORD_ORIGIN :: GLenum+gl_POINT_SPRITE_COORD_ORIGIN = 0x8CA0+gl_DRAW_BUFFER8 :: GLenum+gl_DRAW_BUFFER8 = 0x882D+gl_SPOT_DIRECTION :: GLenum+gl_SPOT_DIRECTION = 0x1204+gl_SAMPLE_COVERAGE_INVERT_ARB :: GLenum+gl_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB+gl_PERFQUERY_COUNTER_RAW_INTEL :: GLenum+gl_PERFQUERY_COUNTER_RAW_INTEL = 0x94F4+gl_STRICT_SCISSOR_HINT_PGI :: GLenum+gl_STRICT_SCISSOR_HINT_PGI = 0x1A218+gl_LUMINANCE16_EXT :: GLenum+gl_LUMINANCE16_EXT = 0x8042+gl_UNPACK_ALIGNMENT :: GLenum+gl_UNPACK_ALIGNMENT = 0x0CF5+gl_BIAS_BIT_ATI :: GLenum+gl_BIAS_BIT_ATI = 0x00000008+gl_LARGE_CCW_ARC_TO_NV :: GLenum+gl_LARGE_CCW_ARC_TO_NV = 0x16+gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB :: GLenum+gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0+gl_FASTEST :: GLenum+gl_FASTEST = 0x1101+gl_LUMINANCE8_ALPHA8 :: GLenum+gl_LUMINANCE8_ALPHA8 = 0x8045+gl_CONVOLUTION_FILTER_BIAS_EXT :: GLenum+gl_CONVOLUTION_FILTER_BIAS_EXT = 0x8015+gl_VIEW_CLASS_S3TC_DXT5_RGBA :: GLenum+gl_VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF+gl_DEPTH32F_STENCIL8_NV :: GLenum+gl_DEPTH32F_STENCIL8_NV = 0x8DAC+gl_TRACE_OPERATIONS_BIT_MESA :: GLenum+gl_TRACE_OPERATIONS_BIT_MESA = 0x0001+gl_QUERY_RESULT_EXT :: GLenum+gl_QUERY_RESULT_EXT = 0x8866+gl_TRANSFORM_FEEDBACK_BINDING_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25+gl_REG_10_ATI :: GLenum+gl_REG_10_ATI = 0x892B+gl_MATRIX16_ARB :: GLenum+gl_MATRIX16_ARB = 0x88D0+gl_FONT_HAS_KERNING_BIT_NV :: GLenum+gl_FONT_HAS_KERNING_BIT_NV = 0x10000000+gl_INNOCENT_CONTEXT_RESET_EXT :: GLenum+gl_INNOCENT_CONTEXT_RESET_EXT = 0x8254+gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV :: GLenum+gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 0x9039+gl_NATIVE_GRAPHICS_END_HINT_PGI :: GLenum+gl_NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204+gl_HISTOGRAM_LUMINANCE_SIZE_EXT :: GLenum+gl_HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C+gl_COMBINER0_NV :: GLenum+gl_COMBINER0_NV = 0x8550+gl_COORD_REPLACE_OES :: GLenum+gl_COORD_REPLACE_OES = 0x8862+gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E80+gl_TIMESTAMP_EXT :: GLenum+gl_TIMESTAMP_EXT = 0x8E28+gl_MAX_IMAGE_UNITS_EXT :: GLenum+gl_MAX_IMAGE_UNITS_EXT = 0x8F38+gl_POINT_SIZE_MAX_ARB :: GLenum+gl_POINT_SIZE_MAX_ARB = 0x8127+gl_DEPTH_WRITEMASK :: GLenum+gl_DEPTH_WRITEMASK = 0x0B72+gl_FOG_COORDINATE_ARRAY_STRIDE_EXT :: GLenum+gl_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455+gl_BUMP_NUM_TEX_UNITS_ATI :: GLenum+gl_BUMP_NUM_TEX_UNITS_ATI = 0x8777+gl_INT_SAMPLER_1D_EXT :: GLenum+gl_INT_SAMPLER_1D_EXT = 0x8DC9+gl_INDEX_MODE :: GLenum+gl_INDEX_MODE = 0x0C30+gl_422_EXT :: GLenum+gl_422_EXT = 0x80CC+gl_ATOMIC_COUNTER_BUFFER_START :: GLenum+gl_ATOMIC_COUNTER_BUFFER_START = 0x92C2+gl_GPU_ADDRESS_NV :: GLenum+gl_GPU_ADDRESS_NV = 0x8F34+gl_REG_19_ATI :: GLenum+gl_REG_19_ATI = 0x8934+gl_IMAGE_BUFFER :: GLenum+gl_IMAGE_BUFFER = 0x9051+gl_HISTOGRAM_GREEN_SIZE :: GLenum+gl_HISTOGRAM_GREEN_SIZE = 0x8029+gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20+gl_INTENSITY8_SNORM :: GLenum+gl_INTENSITY8_SNORM = 0x9017+gl_DEBUG_TYPE_MARKER :: GLenum+gl_DEBUG_TYPE_MARKER = 0x8268+gl_VERTEX_PROGRAM_TWO_SIDE_ARB :: GLenum+gl_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643+gl_INDEX_MATERIAL_FACE_EXT :: GLenum+gl_INDEX_MATERIAL_FACE_EXT = 0x81BA+gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB :: GLenum+gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D+gl_CMYKA_EXT :: GLenum+gl_CMYKA_EXT = 0x800D+gl_MAP_ATTRIB_V_ORDER_NV :: GLenum+gl_MAP_ATTRIB_V_ORDER_NV = 0x86C4+gl_OFFSET_HILO_TEXTURE_2D_NV :: GLenum+gl_OFFSET_HILO_TEXTURE_2D_NV = 0x8854+gl_CALLIGRAPHIC_FRAGMENT_SGIX :: GLenum+gl_CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183+gl_MAX_PROGRAM_PARAMETERS_ARB :: GLenum+gl_MAX_PROGRAM_PARAMETERS_ARB = 0x88A9+gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV :: GLenum+gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0F+gl_MAP_READ_BIT :: GLenum+gl_MAP_READ_BIT = 0x0001+gl_IMAGE_1D_EXT :: GLenum+gl_IMAGE_1D_EXT = 0x904C+gl_READ_BUFFER :: GLenum+gl_READ_BUFFER = 0x0C02+gl_POST_CONVOLUTION_RED_SCALE :: GLenum+gl_POST_CONVOLUTION_RED_SCALE = 0x801C+gl_MATRIX23_ARB :: GLenum+gl_MATRIX23_ARB = 0x88D7+gl_MAX_SAMPLES_NV :: GLenum+gl_MAX_SAMPLES_NV = 0x8D57+gl_RGB8_SNORM :: GLenum+gl_RGB8_SNORM = 0x8F96+gl_MATRIX5_NV :: GLenum+gl_MATRIX5_NV = 0x8635+gl_UNPACK_SWAP_BYTES :: GLenum+gl_UNPACK_SWAP_BYTES = 0x0CF0+gl_TABLE_TOO_LARGE :: GLenum+gl_TABLE_TOO_LARGE = 0x8031+gl_MIN_SAMPLE_SHADING_VALUE_OES :: GLenum+gl_MIN_SAMPLE_SHADING_VALUE_OES = 0x8C37+gl_SWIZZLE_STQ_DQ_ATI :: GLenum+gl_SWIZZLE_STQ_DQ_ATI = 0x8979+gl_BUFFER_IMMUTABLE_STORAGE :: GLenum+gl_BUFFER_IMMUTABLE_STORAGE = 0x821F+gl_ELEMENT_ARRAY_TYPE_APPLE :: GLenum+gl_ELEMENT_ARRAY_TYPE_APPLE = 0x8A0D+gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI :: GLenum+gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA+gl_PARTIAL_SUCCESS_NV :: GLenum+gl_PARTIAL_SUCCESS_NV = 0x902E+gl_LOCAL_CONSTANT_EXT :: GLenum+gl_LOCAL_CONSTANT_EXT = 0x87C3+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517+gl_GEOMETRY_DEFORMATION_SGIX :: GLenum+gl_GEOMETRY_DEFORMATION_SGIX = 0x8194+gl_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900C+gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI :: GLenum+gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803+gl_DISJOINT_NV :: GLenum+gl_DISJOINT_NV = 0x9283+gl_FLOAT_MAT4x3 :: GLenum+gl_FLOAT_MAT4x3 = 0x8B6A+gl_TRANSFORM_FEEDBACK_PAUSED :: GLenum+gl_TRANSFORM_FEEDBACK_PAUSED = 0x8E23+gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: GLenum+gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C+gl_RG8_EXT :: GLenum+gl_RG8_EXT = 0x822B+gl_RECT_NV :: GLenum+gl_RECT_NV = 0xF6+gl_GEOMETRY_OUTPUT_TYPE_ARB :: GLenum+gl_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC+gl_DEBUG_SOURCE_API_ARB :: GLenum+gl_DEBUG_SOURCE_API_ARB = 0x8246+gl_COLOR_ATTACHMENT15 :: GLenum+gl_COLOR_ATTACHMENT15 = 0x8CEF+gl_MAX_VARYING_FLOATS_ARB :: GLenum+gl_MAX_VARYING_FLOATS_ARB = 0x8B4B+gl_MAX_DRAW_BUFFERS_NV :: GLenum+gl_MAX_DRAW_BUFFERS_NV = 0x8824+gl_VERTEX_BLEND_ARB :: GLenum+gl_VERTEX_BLEND_ARB = 0x86A7+gl_DOUBLE_MAT2x3_EXT :: GLenum+gl_DOUBLE_MAT2x3_EXT = 0x8F49+gl_MAX_DEBUG_LOGGED_MESSAGES_AMD :: GLenum+gl_MAX_DEBUG_LOGGED_MESSAGES_AMD = 0x9144+gl_VERTICES_SUBMITTED_ARB :: GLenum+gl_VERTICES_SUBMITTED_ARB = 0x82EE+gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG :: GLenum+gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG = 0x8365+gl_STATE_RESTORE :: GLenum+gl_STATE_RESTORE = 0x8BDC+gl_MAX_COLOR_ATTACHMENTS_EXT :: GLenum+gl_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF+gl_INDEX_LOGIC_OP :: GLenum+gl_INDEX_LOGIC_OP = 0x0BF1+gl_PRIMITIVE_RESTART_NV :: GLenum+gl_PRIMITIVE_RESTART_NV = 0x8558+gl_FLOAT_MAT3x2_NV :: GLenum+gl_FLOAT_MAT3x2_NV = 0x8B67+gl_VERTEX_CONSISTENT_HINT_PGI :: GLenum+gl_VERTEX_CONSISTENT_HINT_PGI = 0x1A22B+gl_LUMINANCE_ALPHA16F_EXT :: GLenum+gl_LUMINANCE_ALPHA16F_EXT = 0x881F+gl_FLOAT_VEC2_ARB :: GLenum+gl_FLOAT_VEC2_ARB = 0x8B50+gl_TEXTURE_SWIZZLE_RGBA :: GLenum+gl_TEXTURE_SWIZZLE_RGBA = 0x8E46+gl_PROGRAM_SEPARABLE_EXT :: GLenum+gl_PROGRAM_SEPARABLE_EXT = 0x8258+gl_COMPRESSED_RGBA_ASTC_10x8_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA+gl_DEPTH_ATTACHMENT_EXT :: GLenum+gl_DEPTH_ATTACHMENT_EXT = 0x8D00+gl_FRAMEBUFFER_UNSUPPORTED_OES :: GLenum+gl_FRAMEBUFFER_UNSUPPORTED_OES = 0x8CDD+gl_OPERAND1_ALPHA :: GLenum+gl_OPERAND1_ALPHA = 0x8599+gl_PIXEL_MAP_I_TO_B_SIZE :: GLenum+gl_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 0x8C8A+gl_EVAL_2D_NV :: GLenum+gl_EVAL_2D_NV = 0x86C0+gl_GREEN_MIN_CLAMP_INGR :: GLenum+gl_GREEN_MIN_CLAMP_INGR = 0x8561+gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0+gl_VERTEX_ARRAY_RANGE_NV :: GLenum+gl_VERTEX_ARRAY_RANGE_NV = 0x851D+gl_CONTEXT_LOST_WEBGL :: GLenum+gl_CONTEXT_LOST_WEBGL = 0x9242+gl_MAX_VERTEX_UNIFORM_BLOCKS :: GLenum+gl_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B+gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE = 0x8A07+gl_TEXTURE_MAX_CLAMP_T_SGIX :: GLenum+gl_TEXTURE_MAX_CLAMP_T_SGIX = 0x836A+gl_LUMINANCE_SNORM :: GLenum+gl_LUMINANCE_SNORM = 0x9011+gl_PIXEL_UNPACK_BUFFER_BINDING :: GLenum+gl_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF+gl_RGBA8_SNORM :: GLenum+gl_RGBA8_SNORM = 0x8F97+gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX :: GLenum+gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048+gl_PIXEL_SUBSAMPLE_2424_SGIX :: GLenum+gl_PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3+gl_TEXTURE_GATHER_SHADOW :: GLenum+gl_TEXTURE_GATHER_SHADOW = 0x82A3+gl_VIEWPORT_INDEX_PROVOKING_VERTEX :: GLenum+gl_VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F+gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT :: GLenum+gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT = 0x90CB+gl_UNSIGNED_INT_IMAGE_CUBE :: GLenum+gl_UNSIGNED_INT_IMAGE_CUBE = 0x9066+gl_WEIGHT_ARRAY_POINTER_OES :: GLenum+gl_WEIGHT_ARRAY_POINTER_OES = 0x86AC+gl_ALL_ATTRIB_BITS :: GLenum+gl_ALL_ATTRIB_BITS = 0xFFFFFFFF+gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL :: GLenum+gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5+gl_TESS_EVALUATION_SHADER_EXT :: GLenum+gl_TESS_EVALUATION_SHADER_EXT = 0x8E87+gl_BUFFER_OBJECT_EXT :: GLenum+gl_BUFFER_OBJECT_EXT = 0x9151+gl_TIMESTAMP :: GLenum+gl_TIMESTAMP = 0x8E28+gl_RGBA_INTEGER_EXT :: GLenum+gl_RGBA_INTEGER_EXT = 0x8D99+gl_RGB16UI :: GLenum+gl_RGB16UI = 0x8D77+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4+gl_SAMPLE_SHADING_OES :: GLenum+gl_SAMPLE_SHADING_OES = 0x8C36+gl_CONVOLUTION_BORDER_COLOR :: GLenum+gl_CONVOLUTION_BORDER_COLOR = 0x8154+gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV :: GLenum+gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1+gl_VERTEX_ARRAY_BUFFER_BINDING :: GLenum+gl_VERTEX_ARRAY_BUFFER_BINDING = 0x8896+gl_DEPTH_CLAMP_NEAR_AMD :: GLenum+gl_DEPTH_CLAMP_NEAR_AMD = 0x901E+gl_POLYGON_TOKEN :: GLenum+gl_POLYGON_TOKEN = 0x0703+gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C+gl_R8_SNORM :: GLenum+gl_R8_SNORM = 0x8F94+gl_DS_BIAS_NV :: GLenum+gl_DS_BIAS_NV = 0x8716+gl_2X_BIT_ATI :: GLenum+gl_2X_BIT_ATI = 0x00000001+gl_ALREADY_SIGNALED :: GLenum+gl_ALREADY_SIGNALED = 0x911A+gl_2D :: GLenum+gl_2D = 0x0600+gl_MAX_VERTEX_UNIFORM_COMPONENTS :: GLenum+gl_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A+gl_DEBUG_CATEGORY_PERFORMANCE_AMD :: GLenum+gl_DEBUG_CATEGORY_PERFORMANCE_AMD = 0x914D+gl_OVERLAY_NV :: GLenum+gl_OVERLAY_NV = 0x9296+gl_ATOMIC_COUNTER_BUFFER_SIZE :: GLenum+gl_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3+gl_COLOR_ATTACHMENT10_EXT :: GLenum+gl_COLOR_ATTACHMENT10_EXT = 0x8CEA+gl_COLOR_TABLE_BLUE_SIZE_SGI :: GLenum+gl_COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC+gl_ADD_SIGNED_EXT :: GLenum+gl_ADD_SIGNED_EXT = 0x8574+gl_INT_SAMPLER_2D_ARRAY_EXT :: GLenum+gl_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF+gl_TRANSFORM_FEEDBACK_BUFFER_INDEX :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B+gl_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum+gl_REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307+gl_FIELD_LOWER_NV :: GLenum+gl_FIELD_LOWER_NV = 0x9023+gl_POST_COLOR_MATRIX_RED_SCALE :: GLenum+gl_POST_COLOR_MATRIX_RED_SCALE = 0x80B4+gl_IMAGE_BUFFER_EXT :: GLenum+gl_IMAGE_BUFFER_EXT = 0x9051+gl_3D_COLOR_TEXTURE :: GLenum+gl_3D_COLOR_TEXTURE = 0x0603+gl_DEBUG_CALLBACK_FUNCTION_KHR :: GLenum+gl_DEBUG_CALLBACK_FUNCTION_KHR = 0x8244+gl_SCISSOR_BIT :: GLenum+gl_SCISSOR_BIT = 0x00080000+gl_IMAGE_TRANSLATE_X_HP :: GLenum+gl_IMAGE_TRANSLATE_X_HP = 0x8157+gl_PIXEL_MAP_I_TO_A :: GLenum+gl_PIXEL_MAP_I_TO_A = 0x0C75+gl_VERTEX_SUBROUTINE :: GLenum+gl_VERTEX_SUBROUTINE = 0x92E8+gl_TEXTURE4_ARB :: GLenum+gl_TEXTURE4_ARB = 0x84C4+gl_PACK_COMPRESSED_BLOCK_DEPTH :: GLenum+gl_PACK_COMPRESSED_BLOCK_DEPTH = 0x912D+gl_SHADER_STORAGE_BLOCK :: GLenum+gl_SHADER_STORAGE_BLOCK = 0x92E6+gl_SIGNED_ALPHA_NV :: GLenum+gl_SIGNED_ALPHA_NV = 0x8705+gl_BLEND_DST_ALPHA_EXT :: GLenum+gl_BLEND_DST_ALPHA_EXT = 0x80CA+gl_MAP2_VERTEX_ATTRIB9_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB9_4_NV = 0x8679+gl_HILO8_NV :: GLenum+gl_HILO8_NV = 0x885E+gl_SHADER_BINARY_FORMATS :: GLenum+gl_SHADER_BINARY_FORMATS = 0x8DF8+gl_DEBUG_OUTPUT_SYNCHRONOUS :: GLenum+gl_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242+gl_TEXTURE_GEN_R :: GLenum+gl_TEXTURE_GEN_R = 0x0C62+gl_PERFORMANCE_MONITOR_AMD :: GLenum+gl_PERFORMANCE_MONITOR_AMD = 0x9152+gl_INTENSITY_FLOAT16_APPLE :: GLenum+gl_INTENSITY_FLOAT16_APPLE = 0x881D+gl_PROGRAM_PIPELINE :: GLenum+gl_PROGRAM_PIPELINE = 0x82E4+gl_COLOR_BUFFER_BIT5_QCOM :: GLenum+gl_COLOR_BUFFER_BIT5_QCOM = 0x00000020+gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT :: GLenum+gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD+gl_DEBUG_TYPE_PORTABILITY_KHR :: GLenum+gl_DEBUG_TYPE_PORTABILITY_KHR = 0x824F+gl_RGB16F_ARB :: GLenum+gl_RGB16F_ARB = 0x881B+gl_PRIMITIVES_GENERATED_EXT :: GLenum+gl_PRIMITIVES_GENERATED_EXT = 0x8C87+gl_PROGRAM_BINARY_FORMATS_OES :: GLenum+gl_PROGRAM_BINARY_FORMATS_OES = 0x87FF+gl_AMBIENT :: GLenum+gl_AMBIENT = 0x1200+gl_QUERY_BY_REGION_NO_WAIT_NV :: GLenum+gl_QUERY_BY_REGION_NO_WAIT_NV = 0x8E16+gl_VIEW_CLASS_RGTC2_RG :: GLenum+gl_VIEW_CLASS_RGTC2_RG = 0x82D1+gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT = 0x8A57+gl_DRAW_BUFFER2_EXT :: GLenum+gl_DRAW_BUFFER2_EXT = 0x8827+gl_TEXTURE_BUFFER_BINDING :: GLenum+gl_TEXTURE_BUFFER_BINDING = 0x8C2A+gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT :: GLenum+gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT = 0x8A55+gl_OPERAND3_ALPHA_NV :: GLenum+gl_OPERAND3_ALPHA_NV = 0x859B+gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV :: GLenum+gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 0x8E58+gl_LINEAR_SHARPEN_SGIS :: GLenum+gl_LINEAR_SHARPEN_SGIS = 0x80AD+gl_MAP_UNSYNCHRONIZED_BIT_EXT :: GLenum+gl_MAP_UNSYNCHRONIZED_BIT_EXT = 0x0020+gl_MODELVIEW28_ARB :: GLenum+gl_MODELVIEW28_ARB = 0x873C+gl_EDGE_FLAG_ARRAY_LIST_IBM :: GLenum+gl_EDGE_FLAG_ARRAY_LIST_IBM = 103075+gl_PALETTE4_RGB5_A1_OES :: GLenum+gl_PALETTE4_RGB5_A1_OES = 0x8B94+gl_MULTIPLY_KHR :: GLenum+gl_MULTIPLY_KHR = 0x9294+gl_GPU_OPTIMIZED_QCOM :: GLenum+gl_GPU_OPTIMIZED_QCOM = 0x8FB2+gl_FOG_FUNC_POINTS_SGIS :: GLenum+gl_FOG_FUNC_POINTS_SGIS = 0x812B+gl_MAX_IMAGE_SAMPLES :: GLenum+gl_MAX_IMAGE_SAMPLES = 0x906D+gl_DRAW_BUFFER3_NV :: GLenum+gl_DRAW_BUFFER3_NV = 0x8828+gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS :: GLenum+gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47+gl_RESET_NOTIFICATION_STRATEGY_ARB :: GLenum+gl_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256+gl_MAX_TEXTURE_STACK_DEPTH :: GLenum+gl_MAX_TEXTURE_STACK_DEPTH = 0x0D39+gl_INT64_NV :: GLenum+gl_INT64_NV = 0x140E+gl_DEBUG_SOURCE_APPLICATION :: GLenum+gl_DEBUG_SOURCE_APPLICATION = 0x824A+gl_STENCIL_CLEAR_VALUE :: GLenum+gl_STENCIL_CLEAR_VALUE = 0x0B91+gl_SRC1_COLOR :: GLenum+gl_SRC1_COLOR = 0x88F9+gl_LIGHT4 :: GLenum+gl_LIGHT4 = 0x4004+gl_PIXEL_PACK_BUFFER_BINDING :: GLenum+gl_PIXEL_PACK_BUFFER_BINDING = 0x88ED+gl_MAX_LIGHTS :: GLenum+gl_MAX_LIGHTS = 0x0D31+gl_OPERAND1_ALPHA_EXT :: GLenum+gl_OPERAND1_ALPHA_EXT = 0x8599+gl_PIXEL_MAP_B_TO_B_SIZE :: GLenum+gl_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8+gl_COLOR_TABLE_FORMAT_SGI :: GLenum+gl_COLOR_TABLE_FORMAT_SGI = 0x80D8+gl_MODELVIEW22_ARB :: GLenum+gl_MODELVIEW22_ARB = 0x8736+gl_UNSIGNED_INT64_VEC4_NV :: GLenum+gl_UNSIGNED_INT64_VEC4_NV = 0x8FF7+gl_COLOR_ARRAY_TYPE_EXT :: GLenum+gl_COLOR_ARRAY_TYPE_EXT = 0x8082+gl_LOSE_CONTEXT_ON_RESET_EXT :: GLenum+gl_LOSE_CONTEXT_ON_RESET_EXT = 0x8252+gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV :: GLenum+gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 0x9034+gl_TEXTURE_PRIORITY_EXT :: GLenum+gl_TEXTURE_PRIORITY_EXT = 0x8066+gl_UNPACK_COMPRESSED_SIZE_SGIX :: GLenum+gl_UNPACK_COMPRESSED_SIZE_SGIX = 0x831A+gl_SEPARATE_ATTRIBS_EXT :: GLenum+gl_SEPARATE_ATTRIBS_EXT = 0x8C8D+gl_IMAGE_BINDING_LAYERED :: GLenum+gl_IMAGE_BINDING_LAYERED = 0x8F3C+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B+gl_READ_ONLY :: GLenum+gl_READ_ONLY = 0x88B8+gl_TEXTURE_3D_BINDING_OES :: GLenum+gl_TEXTURE_3D_BINDING_OES = 0x806A+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7+gl_COVERAGE_ALL_FRAGMENTS_NV :: GLenum+gl_COVERAGE_ALL_FRAGMENTS_NV = 0x8ED5+gl_SRC2_ALPHA :: GLenum+gl_SRC2_ALPHA = 0x858A+gl_PRIMITIVE_ID_NV :: GLenum+gl_PRIMITIVE_ID_NV = 0x8C7C+gl_VIDEO_COLOR_CONVERSION_MAX_NV :: GLenum+gl_VIDEO_COLOR_CONVERSION_MAX_NV = 0x902A+gl_MAP2_TANGENT_EXT :: GLenum+gl_MAP2_TANGENT_EXT = 0x8445+gl_LIGHTING :: GLenum+gl_LIGHTING = 0x0B50+gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB :: GLenum+gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6+gl_VERTEX_ATTRIB_ARRAY2_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY2_NV = 0x8652+gl_PRESENT_TIME_NV :: GLenum+gl_PRESENT_TIME_NV = 0x8E2A+gl_PATCH_DEFAULT_INNER_LEVEL :: GLenum+gl_PATCH_DEFAULT_INNER_LEVEL = 0x8E73+gl_NEVER :: GLenum+gl_NEVER = 0x0200+gl_PATH_STROKE_WIDTH_NV :: GLenum+gl_PATH_STROKE_WIDTH_NV = 0x9075+gl_INVERT_RGB_NV :: GLenum+gl_INVERT_RGB_NV = 0x92A3+gl_BUFFER_MAP_POINTER_ARB :: GLenum+gl_BUFFER_MAP_POINTER_ARB = 0x88BD+gl_MAP2_GRID_SEGMENTS :: GLenum+gl_MAP2_GRID_SEGMENTS = 0x0DD3+gl_INVALID_VALUE :: GLenum+gl_INVALID_VALUE = 0x0501+gl_BLEND_EQUATION_ALPHA_OES :: GLenum+gl_BLEND_EQUATION_ALPHA_OES = 0x883D+gl_MAX_RATIONAL_EVAL_ORDER_NV :: GLenum+gl_MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7+gl_VERTEX_ATTRIB_ARRAY10_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY10_NV = 0x865A+gl_UNPACK_IMAGE_DEPTH_SGIS :: GLenum+gl_UNPACK_IMAGE_DEPTH_SGIS = 0x8133+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES = 0x8CDC+gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266+gl_TRANSPOSE_PROJECTION_MATRIX_ARB :: GLenum+gl_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4+gl_REDUCE_EXT :: GLenum+gl_REDUCE_EXT = 0x8016+gl_RGB8UI_EXT :: GLenum+gl_RGB8UI_EXT = 0x8D7D+gl_MAX_CLIENT_ATTRIB_STACK_DEPTH :: GLenum+gl_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B+gl_RGB9_E5_EXT :: GLenum+gl_RGB9_E5_EXT = 0x8C3D+gl_OUTPUT_TEXTURE_COORD18_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD18_EXT = 0x87AF+gl_COLOR_ATTACHMENT0_EXT :: GLenum+gl_COLOR_ATTACHMENT0_EXT = 0x8CE0+gl_ALPHA_SCALE :: GLenum+gl_ALPHA_SCALE = 0x0D1C+gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV :: GLenum+gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD+gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216+gl_BLEND_SRC :: GLenum+gl_BLEND_SRC = 0x0BE1+gl_TEXTURE_MAX_CLAMP_R_SGIX :: GLenum+gl_TEXTURE_MAX_CLAMP_R_SGIX = 0x836B+gl_MAX_PROGRAM_TEXEL_OFFSET_NV :: GLenum+gl_MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905+gl_TEXTURE_LOD_BIAS_R_SGIX :: GLenum+gl_TEXTURE_LOD_BIAS_R_SGIX = 0x8190+gl_UNSIGNED_INT_SAMPLER_2D :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D = 0x8DD2+gl_TEXTURE_FILTER_CONTROL_EXT :: GLenum+gl_TEXTURE_FILTER_CONTROL_EXT = 0x8500+gl_VARIABLE_G_NV :: GLenum+gl_VARIABLE_G_NV = 0x8529+gl_SELECTION_BUFFER_POINTER :: GLenum+gl_SELECTION_BUFFER_POINTER = 0x0DF3+gl_INT_SAMPLER_1D :: GLenum+gl_INT_SAMPLER_1D = 0x8DC9+gl_COMBINE_ALPHA :: GLenum+gl_COMBINE_ALPHA = 0x8572+gl_FONT_Y_MAX_BOUNDS_BIT_NV :: GLenum+gl_FONT_Y_MAX_BOUNDS_BIT_NV = 0x00080000+gl_UNIFORM_BARRIER_BIT :: GLenum+gl_UNIFORM_BARRIER_BIT = 0x00000004+gl_TEXTURE_BLUE_TYPE_ARB :: GLenum+gl_TEXTURE_BLUE_TYPE_ARB = 0x8C12+gl_STENCIL_INDEX16 :: GLenum+gl_STENCIL_INDEX16 = 0x8D49+gl_SRC_OVER_NV :: GLenum+gl_SRC_OVER_NV = 0x9288+gl_INT_SAMPLER_2D_MULTISAMPLE :: GLenum+gl_INT_SAMPLER_2D_MULTISAMPLE = 0x9109+gl_COLOR_TABLE_GREEN_SIZE_SGI :: GLenum+gl_COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB+gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV :: GLenum+gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4+gl_TEXTURE_COMPRESSED_IMAGE_SIZE :: GLenum+gl_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV :: GLenum+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5C+gl_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum+gl_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308+gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT = 0x8210+gl_MAX_HEIGHT :: GLenum+gl_MAX_HEIGHT = 0x827F+gl_ALPHA32F_ARB :: GLenum+gl_ALPHA32F_ARB = 0x8816+gl_COLOR_ATTACHMENT13 :: GLenum+gl_COLOR_ATTACHMENT13 = 0x8CED+gl_OP_SET_GE_EXT :: GLenum+gl_OP_SET_GE_EXT = 0x878C+gl_RGBA16_EXT :: GLenum+gl_RGBA16_EXT = 0x805B+gl_OPERAND3_RGB_NV :: GLenum+gl_OPERAND3_RGB_NV = 0x8593+gl_RENDERBUFFER_BLUE_SIZE_OES :: GLenum+gl_RENDERBUFFER_BLUE_SIZE_OES = 0x8D52+gl_LUMINANCE_ALPHA_FLOAT16_ATI :: GLenum+gl_LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV = 0x88FE+gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2+gl_MAX_DEPTH :: GLenum+gl_MAX_DEPTH = 0x8280+gl_LINEAR_MIPMAP_NEAREST :: GLenum+gl_LINEAR_MIPMAP_NEAREST = 0x2701+gl_UNSIGNED_INT_8_8_S8_S8_REV_NV :: GLenum+gl_UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB+gl_N3F_V3F :: GLenum+gl_N3F_V3F = 0x2A25+gl_PACK_MAX_COMPRESSED_SIZE_SGIX :: GLenum+gl_PACK_MAX_COMPRESSED_SIZE_SGIX = 0x831B+gl_QUERY_BUFFER_BINDING_AMD :: GLenum+gl_QUERY_BUFFER_BINDING_AMD = 0x9193+gl_FOG_MODE :: GLenum+gl_FOG_MODE = 0x0B65+gl_RGBA32F :: GLenum+gl_RGBA32F = 0x8814+gl_FRAGMENT_SHADER_DERIVATIVE_HINT :: GLenum+gl_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B+gl_UNPACK_SKIP_ROWS_EXT :: GLenum+gl_UNPACK_SKIP_ROWS_EXT = 0x0CF3+gl_LINES :: GLenum+gl_LINES = 0x0001+gl_SPOT_EXPONENT :: GLenum+gl_SPOT_EXPONENT = 0x1205+gl_MAX_NUM_COMPATIBLE_SUBROUTINES :: GLenum+gl_MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8+gl_RGBA_FLOAT32_APPLE :: GLenum+gl_RGBA_FLOAT32_APPLE = 0x8814+gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT :: GLenum+gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE+gl_BLEND_EQUATION_ALPHA :: GLenum+gl_BLEND_EQUATION_ALPHA = 0x883D+gl_PATH_MODELVIEW_STACK_DEPTH_NV :: GLenum+gl_PATH_MODELVIEW_STACK_DEPTH_NV = 0x0BA3+gl_TEXTURE_SHARED_SIZE_EXT :: GLenum+gl_TEXTURE_SHARED_SIZE_EXT = 0x8C3F+gl_RGBA16 :: GLenum+gl_RGBA16 = 0x805B+gl_UNDEFINED_VERTEX_EXT :: GLenum+gl_UNDEFINED_VERTEX_EXT = 0x8260+gl_PALETTE8_RGB5_A1_OES :: GLenum+gl_PALETTE8_RGB5_A1_OES = 0x8B99+gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT :: GLenum+gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0+gl_IMAGE_CLASS_11_11_10 :: GLenum+gl_IMAGE_CLASS_11_11_10 = 0x82C2+gl_HISTOGRAM_GREEN_SIZE_EXT :: GLenum+gl_HISTOGRAM_GREEN_SIZE_EXT = 0x8029+gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT :: GLenum+gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT = 0x90D8+gl_MAX_COMPUTE_IMAGE_UNIFORMS :: GLenum+gl_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD+gl_MAX_PATCH_VERTICES_EXT :: GLenum+gl_MAX_PATCH_VERTICES_EXT = 0x8E7D+gl_ISOLINES :: GLenum+gl_ISOLINES = 0x8E7A+gl_LUMINANCE_ALPHA_SNORM :: GLenum+gl_LUMINANCE_ALPHA_SNORM = 0x9012+gl_PROGRAM_PIPELINE_BINDING_EXT :: GLenum+gl_PROGRAM_PIPELINE_BINDING_EXT = 0x825A+gl_FIRST_VERTEX_CONVENTION_EXT :: GLenum+gl_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D+gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT = 0x8E86+gl_UTF16_NV :: GLenum+gl_UTF16_NV = 0x909B+gl_PRESENT_DURATION_NV :: GLenum+gl_PRESENT_DURATION_NV = 0x8E2B+gl_TEXTURE_SAMPLES :: GLenum+gl_TEXTURE_SAMPLES = 0x9106+gl_BGR :: GLenum+gl_BGR = 0x80E0+gl_CULL_VERTEX_OBJECT_POSITION_EXT :: GLenum+gl_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC+gl_FRAGMENT_PROGRAM_POSITION_MESA :: GLenum+gl_FRAGMENT_PROGRAM_POSITION_MESA = 0x8BB0+gl_FLOAT_RG_NV :: GLenum+gl_FLOAT_RG_NV = 0x8881+gl_PROXY_TEXTURE_2D_MULTISAMPLE :: GLenum+gl_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101+gl_CON_21_ATI :: GLenum+gl_CON_21_ATI = 0x8956+gl_MAX_GEOMETRY_IMAGE_UNIFORMS :: GLenum+gl_MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD+gl_FLOAT_MAT3x4_NV :: GLenum+gl_FLOAT_MAT3x4_NV = 0x8B68+gl_BUFFER_VARIABLE :: GLenum+gl_BUFFER_VARIABLE = 0x92E5+gl_ANY_SAMPLES_PASSED_EXT :: GLenum+gl_ANY_SAMPLES_PASSED_EXT = 0x8C2F+gl_TEXTURE_GEN_Q :: GLenum+gl_TEXTURE_GEN_Q = 0x0C63+gl_GEOMETRY_VERTICES_OUT_ARB :: GLenum+gl_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA+gl_POLYGON_SMOOTH_HINT :: GLenum+gl_POLYGON_SMOOTH_HINT = 0x0C53+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A+gl_SEPARABLE_2D_EXT :: GLenum+gl_SEPARABLE_2D_EXT = 0x8012+gl_VERSION_ES_CL_1_0 :: GLenum+gl_VERSION_ES_CL_1_0 = 1+gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2+gl_RED_INTEGER :: GLenum+gl_RED_INTEGER = 0x8D94+gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD :: GLenum+gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 0x914A+gl_OFFSET_TEXTURE_RECTANGLE_NV :: GLenum+gl_OFFSET_TEXTURE_RECTANGLE_NV = 0x864C+gl_TEXTURE_COORD_ARRAY_TYPE_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089+gl_INT8_NV :: GLenum+gl_INT8_NV = 0x8FE0+gl_VIDEO_COLOR_CONVERSION_MIN_NV :: GLenum+gl_VIDEO_COLOR_CONVERSION_MIN_NV = 0x902B+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV = 0x8C4D+gl_FRAMEBUFFER_ATTACHMENT_ANGLE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_ANGLE = 0x93A3+gl_SRC1_RGB :: GLenum+gl_SRC1_RGB = 0x8581+gl_CON_24_ATI :: GLenum+gl_CON_24_ATI = 0x8959+gl_DEBUG_CALLBACK_USER_PARAM :: GLenum+gl_DEBUG_CALLBACK_USER_PARAM = 0x8245+gl_MALI_SHADER_BINARY_ARM :: GLenum+gl_MALI_SHADER_BINARY_ARM = 0x8F60+gl_VIEW_CLASS_16_BITS :: GLenum+gl_VIEW_CLASS_16_BITS = 0x82CA+gl_DITHER :: GLenum+gl_DITHER = 0x0BD0+gl_PATH_STROKE_COVER_MODE_NV :: GLenum+gl_PATH_STROKE_COVER_MODE_NV = 0x9083+gl_BGR_INTEGER :: GLenum+gl_BGR_INTEGER = 0x8D9A+gl_TEXTURE_MATERIAL_PARAMETER_EXT :: GLenum+gl_TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352+gl_COMPRESSED_RGBA_ASTC_5x4_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1+gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT :: GLenum+gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4+gl_POST_CONVOLUTION_GREEN_BIAS_EXT :: GLenum+gl_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021+gl_PATH_ERROR_POSITION_NV :: GLenum+gl_PATH_ERROR_POSITION_NV = 0x90AB+gl_SAMPLE_ALPHA_TO_COVERAGE :: GLenum+gl_SAMPLE_ALPHA_TO_COVERAGE = 0x809E+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D+gl_NUM_COMPATIBLE_SUBROUTINES :: GLenum+gl_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A+gl_RGBA16UI_EXT :: GLenum+gl_RGBA16UI_EXT = 0x8D76+gl_VERTEX_SHADER_ARB :: GLenum+gl_VERTEX_SHADER_ARB = 0x8B31+gl_RGB :: GLenum+gl_RGB = 0x1907+gl_MAP_PERSISTENT_BIT :: GLenum+gl_MAP_PERSISTENT_BIT = 0x0040+gl_QUERY_COUNTER_BITS_ARB :: GLenum+gl_QUERY_COUNTER_BITS_ARB = 0x8864+gl_BLEND_EQUATION_RGB_OES :: GLenum+gl_BLEND_EQUATION_RGB_OES = 0x8009+gl_FRAGMENT_SHADER_BIT :: GLenum+gl_FRAGMENT_SHADER_BIT = 0x00000002+gl_MATRIX_INDEX_ARRAY_ARB :: GLenum+gl_MATRIX_INDEX_ARRAY_ARB = 0x8844+gl_OUTPUT_TEXTURE_COORD29_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD29_EXT = 0x87BA+gl_HISTOGRAM_FORMAT :: GLenum+gl_HISTOGRAM_FORMAT = 0x8027+gl_MAX_ASYNC_HISTOGRAM_SGIX :: GLenum+gl_MAX_ASYNC_HISTOGRAM_SGIX = 0x832D+gl_MAX_VERTEX_ATTRIBS_ARB :: GLenum+gl_MAX_VERTEX_ATTRIBS_ARB = 0x8869+gl_SAMPLE_MASK_NV :: GLenum+gl_SAMPLE_MASK_NV = 0x8E51+gl_COLOR_INDEXES :: GLenum+gl_COLOR_INDEXES = 0x1603+gl_QUAD_TEXTURE_SELECT_SGIS :: GLenum+gl_QUAD_TEXTURE_SELECT_SGIS = 0x8125+gl_RG16_SNORM :: GLenum+gl_RG16_SNORM = 0x8F99+gl_ACTIVE_SUBROUTINE_MAX_LENGTH :: GLenum+gl_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48+gl_LOGIC_OP_MODE :: GLenum+gl_LOGIC_OP_MODE = 0x0BF0+gl_DEPTH_COMPONENT16_NONLINEAR_NV :: GLenum+gl_DEPTH_COMPONENT16_NONLINEAR_NV = 0x8E2C+gl_PRIMITIVE_RESTART_INDEX_NV :: GLenum+gl_PRIMITIVE_RESTART_INDEX_NV = 0x8559+gl_UNKNOWN_CONTEXT_RESET :: GLenum+gl_UNKNOWN_CONTEXT_RESET = 0x8255+gl_VBO_FREE_MEMORY_ATI :: GLenum+gl_VBO_FREE_MEMORY_ATI = 0x87FB+gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES :: GLenum+gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES = 0x8515+gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR :: GLenum+gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = 0x82FC+gl_TEXTURE_2D_STACK_MESAX :: GLenum+gl_TEXTURE_2D_STACK_MESAX = 0x875A+gl_DRAW_BUFFER10 :: GLenum+gl_DRAW_BUFFER10 = 0x882F+gl_FLOAT16_VEC4_NV :: GLenum+gl_FLOAT16_VEC4_NV = 0x8FFB+gl_SIGNED_HILO16_NV :: GLenum+gl_SIGNED_HILO16_NV = 0x86FA+gl_BUFFER_MAPPED_OES :: GLenum+gl_BUFFER_MAPPED_OES = 0x88BC+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1+gl_DRAW_BUFFER5_EXT :: GLenum+gl_DRAW_BUFFER5_EXT = 0x882A+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8+gl_NUM_EXTENSIONS :: GLenum+gl_NUM_EXTENSIONS = 0x821D+gl_WARP_SIZE_NV :: GLenum+gl_WARP_SIZE_NV = 0x9339+gl_TEXTURE23 :: GLenum+gl_TEXTURE23 = 0x84D7+gl_INT_SAMPLER_2D_RECT_EXT :: GLenum+gl_INT_SAMPLER_2D_RECT_EXT = 0x8DCD+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES = 0x8CDB+gl_REG_4_ATI :: GLenum+gl_REG_4_ATI = 0x8925+gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG :: GLenum+gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = 0x9137+gl_FOG_INDEX :: GLenum+gl_FOG_INDEX = 0x0B61+gl_QUADRATIC_ATTENUATION :: GLenum+gl_QUADRATIC_ATTENUATION = 0x1209+gl_COLOR_MATERIAL :: GLenum+gl_COLOR_MATERIAL = 0x0B57+gl_SAMPLE_MASK :: GLenum+gl_SAMPLE_MASK = 0x8E51+gl_DRAW_FRAMEBUFFER_BINDING_EXT :: GLenum+gl_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6+gl_MULTISAMPLE_BUFFER_BIT5_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT5_QCOM = 0x20000000+gl_DEPTH_STENCIL_OES :: GLenum+gl_DEPTH_STENCIL_OES = 0x84F9+gl_STENCIL_BITS :: GLenum+gl_STENCIL_BITS = 0x0D57+gl_CURRENT_VERTEX_ATTRIB_ARB :: GLenum+gl_CURRENT_VERTEX_ATTRIB_ARB = 0x8626+gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9+gl_COORD_REPLACE_ARB :: GLenum+gl_COORD_REPLACE_ARB = 0x8862+gl_RGBA32I_EXT :: GLenum+gl_RGBA32I_EXT = 0x8D82+gl_TEXTURE6 :: GLenum+gl_TEXTURE6 = 0x84C6+gl_FLOAT_RGB16_NV :: GLenum+gl_FLOAT_RGB16_NV = 0x8888+gl_TEXTURE_IMMUTABLE_FORMAT :: GLenum+gl_TEXTURE_IMMUTABLE_FORMAT = 0x912F+gl_ZERO_EXT :: GLenum+gl_ZERO_EXT = 0x87DD+gl_SOFTLIGHT_NV :: GLenum+gl_SOFTLIGHT_NV = 0x929C+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9+gl_TEXTURE_BASE_LEVEL :: GLenum+gl_TEXTURE_BASE_LEVEL = 0x813C+gl_COMPRESSED_SRGB_ALPHA :: GLenum+gl_COMPRESSED_SRGB_ALPHA = 0x8C49+gl_TEXTURE18_ARB :: GLenum+gl_TEXTURE18_ARB = 0x84D2+gl_AND_INVERTED :: GLenum+gl_AND_INVERTED = 0x1504+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 0x8C8F+gl_ARRAY_BUFFER_ARB :: GLenum+gl_ARRAY_BUFFER_ARB = 0x8892+gl_RGBA32F_EXT :: GLenum+gl_RGBA32F_EXT = 0x8814+gl_BLEND_EQUATION_RGB_EXT :: GLenum+gl_BLEND_EQUATION_RGB_EXT = 0x8009+gl_FRONT_FACE :: GLenum+gl_FRONT_FACE = 0x0B46+gl_SINGLE_COLOR_EXT :: GLenum+gl_SINGLE_COLOR_EXT = 0x81F9+gl_QUERY_COUNTER_BITS_EXT :: GLenum+gl_QUERY_COUNTER_BITS_EXT = 0x8864+gl_TESS_CONTROL_SHADER_PATCHES_ARB :: GLenum+gl_TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1+gl_SPOT_CUTOFF :: GLenum+gl_SPOT_CUTOFF = 0x1206+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A+gl_OUTPUT_TEXTURE_COORD6_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD6_EXT = 0x87A3+gl_COLOR_ATTACHMENT13_NV :: GLenum+gl_COLOR_ATTACHMENT13_NV = 0x8CED+gl_COMPRESSED_RGBA_S3TC_DXT3_EXT :: GLenum+gl_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2+gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV :: GLenum+gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = 0x8E5A+gl_TRANSPOSE_TEXTURE_MATRIX :: GLenum+gl_TRANSPOSE_TEXTURE_MATRIX = 0x84E5+gl_MULTISAMPLE_ARB :: GLenum+gl_MULTISAMPLE_ARB = 0x809D+gl_DEPTH_COMPONENT24 :: GLenum+gl_DEPTH_COMPONENT24 = 0x81A6+gl_PIXEL_MAP_G_TO_G :: GLenum+gl_PIXEL_MAP_G_TO_G = 0x0C77+gl_NAMED_STRING_LENGTH_ARB :: GLenum+gl_NAMED_STRING_LENGTH_ARB = 0x8DE9+gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT = 0x8E83+gl_UNIFORM_SIZE :: GLenum+gl_UNIFORM_SIZE = 0x8A38+gl_MODELVIEW21_ARB :: GLenum+gl_MODELVIEW21_ARB = 0x8735+gl_FRAGMENT_LIGHT7_SGIX :: GLenum+gl_FRAGMENT_LIGHT7_SGIX = 0x8413+gl_DRAW_BUFFER3_ARB :: GLenum+gl_DRAW_BUFFER3_ARB = 0x8828+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES = 0x93E8+gl_UNSIGNED_SHORT :: GLenum+gl_UNSIGNED_SHORT = 0x1403+gl_MULTISAMPLE_BIT_ARB :: GLenum+gl_MULTISAMPLE_BIT_ARB = 0x20000000+gl_FOG :: GLenum+gl_FOG = 0x0B60+gl_TEXTURE_COMPARE_MODE :: GLenum+gl_TEXTURE_COMPARE_MODE = 0x884C+gl_SPHERE_MAP :: GLenum+gl_SPHERE_MAP = 0x2402+gl_TIMEOUT_EXPIRED_APPLE :: GLenum+gl_TIMEOUT_EXPIRED_APPLE = 0x911B+gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E7F+gl_PROXY_TEXTURE_1D_ARRAY :: GLenum+gl_PROXY_TEXTURE_1D_ARRAY = 0x8C19+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6+gl_TEXTURE_BINDING_CUBE_MAP :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP = 0x8514+gl_COLOR_ATTACHMENT14 :: GLenum+gl_COLOR_ATTACHMENT14 = 0x8CEE+gl_STENCIL_BUFFER_BIT :: GLenum+gl_STENCIL_BUFFER_BIT = 0x00000400+gl_SIGNALED :: GLenum+gl_SIGNALED = 0x9119+gl_TEXTURE_WIDTH :: GLenum+gl_TEXTURE_WIDTH = 0x1000+gl_EVAL_BIT :: GLenum+gl_EVAL_BIT = 0x00010000+gl_REG_28_ATI :: GLenum+gl_REG_28_ATI = 0x893D+gl_TEXTURE_BIT :: GLenum+gl_TEXTURE_BIT = 0x00040000+gl_CONTEXT_ROBUST_ACCESS_EXT :: GLenum+gl_CONTEXT_ROBUST_ACCESS_EXT = 0x90F3+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80+gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB :: GLenum+gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED+gl_DEPTH_BUFFER_BIT :: GLenum+gl_DEPTH_BUFFER_BIT = 0x00000100+gl_TEXCOORD2_BIT_PGI :: GLenum+gl_TEXCOORD2_BIT_PGI = 0x20000000+gl_POST_CONVOLUTION_RED_SCALE_EXT :: GLenum+gl_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C+gl_QUERY_KHR :: GLenum+gl_QUERY_KHR = 0x82E3+gl_PACK_IMAGE_HEIGHT_EXT :: GLenum+gl_PACK_IMAGE_HEIGHT_EXT = 0x806C+gl_COMPRESSED_RGBA_ASTC_5x5_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2+gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB :: GLenum+gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A+gl_DEPTH_STENCIL_ATTACHMENT :: GLenum+gl_DEPTH_STENCIL_ATTACHMENT = 0x821A+gl_HSL_HUE_KHR :: GLenum+gl_HSL_HUE_KHR = 0x92AD+gl_ATC_RGB_AMD :: GLenum+gl_ATC_RGB_AMD = 0x8C92+gl_DECR_WRAP :: GLenum+gl_DECR_WRAP = 0x8508+gl_GEOMETRY_VERTICES_OUT :: GLenum+gl_GEOMETRY_VERTICES_OUT = 0x8916+gl_OFFSET_TEXTURE_BIAS_NV :: GLenum+gl_OFFSET_TEXTURE_BIAS_NV = 0x86E3+gl_COLOR_ATTACHMENT5_NV :: GLenum+gl_COLOR_ATTACHMENT5_NV = 0x8CE5+gl_POINT_SIZE_ARRAY_POINTER_OES :: GLenum+gl_POINT_SIZE_ARRAY_POINTER_OES = 0x898C+gl_TEXTURE_COMPARE_FAIL_VALUE_ARB :: GLenum+gl_TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF+gl_RENDERBUFFER_COLOR_SAMPLES_NV :: GLenum+gl_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10+gl_CON_10_ATI :: GLenum+gl_CON_10_ATI = 0x894B+gl_IMAGE_ROTATE_ANGLE_HP :: GLenum+gl_IMAGE_ROTATE_ANGLE_HP = 0x8159+gl_UNIFORM_BUFFER_UNIFIED_NV :: GLenum+gl_UNIFORM_BUFFER_UNIFIED_NV = 0x936E+gl_INTENSITY4 :: GLenum+gl_INTENSITY4 = 0x804A+gl_DEBUG_LOGGED_MESSAGES_KHR :: GLenum+gl_DEBUG_LOGGED_MESSAGES_KHR = 0x9145+gl_MINUS_CLAMPED_NV :: GLenum+gl_MINUS_CLAMPED_NV = 0x92B3+gl_BUFFER_SIZE :: GLenum+gl_BUFFER_SIZE = 0x8764+gl_SRGB_EXT :: GLenum+gl_SRGB_EXT = 0x8C40+gl_PIXEL_TEX_GEN_Q_ROUND_SGIX :: GLenum+gl_PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185+gl_R16I :: GLenum+gl_R16I = 0x8233+gl_COLOR_COMPONENTS :: GLenum+gl_COLOR_COMPONENTS = 0x8283+gl_TEXTURE_VIEW_NUM_LEVELS :: GLenum+gl_TEXTURE_VIEW_NUM_LEVELS = 0x82DC+gl_COLOR_ATTACHMENT11 :: GLenum+gl_COLOR_ATTACHMENT11 = 0x8CEB+gl_OBJECT_PLANE :: GLenum+gl_OBJECT_PLANE = 0x2501+gl_IMAGE_3D_EXT :: GLenum+gl_IMAGE_3D_EXT = 0x904E+gl_MAX_GEOMETRY_INPUT_COMPONENTS :: GLenum+gl_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123+gl_TEXTURE_COORD_ARRAY_LIST_IBM :: GLenum+gl_TEXTURE_COORD_ARRAY_LIST_IBM = 103074+gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C+gl_CLIENT_ACTIVE_TEXTURE :: GLenum+gl_CLIENT_ACTIVE_TEXTURE = 0x84E1+gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB :: GLenum+gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD+gl_OPERAND1_RGB :: GLenum+gl_OPERAND1_RGB = 0x8591+gl_POINT_SIZE_ARRAY_OES :: GLenum+gl_POINT_SIZE_ARRAY_OES = 0x8B9C+gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV :: GLenum+gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40+gl_MODELVIEW6_ARB :: GLenum+gl_MODELVIEW6_ARB = 0x8726+gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR :: GLenum+gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242+gl_AND_REVERSE :: GLenum+gl_AND_REVERSE = 0x1502+gl_CLAMP_TO_BORDER_NV :: GLenum+gl_CLAMP_TO_BORDER_NV = 0x812D+gl_GUILTY_CONTEXT_RESET_ARB :: GLenum+gl_GUILTY_CONTEXT_RESET_ARB = 0x8253+gl_INT64_VEC2_NV :: GLenum+gl_INT64_VEC2_NV = 0x8FE9+gl_C3F_V3F :: GLenum+gl_C3F_V3F = 0x2A24+gl_OBJECT_LINEAR_NV :: GLenum+gl_OBJECT_LINEAR_NV = 0x2401+gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E1F+gl_TEXTURE_FLOAT_COMPONENTS_NV :: GLenum+gl_TEXTURE_FLOAT_COMPONENTS_NV = 0x888C+gl_SOURCE3_ALPHA_NV :: GLenum+gl_SOURCE3_ALPHA_NV = 0x858B+gl_OPERAND2_ALPHA_EXT :: GLenum+gl_OPERAND2_ALPHA_EXT = 0x859A+gl_CON_12_ATI :: GLenum+gl_CON_12_ATI = 0x894D+gl_SYNC_STATUS :: GLenum+gl_SYNC_STATUS = 0x9114+gl_BLEND_SRC_RGB_EXT :: GLenum+gl_BLEND_SRC_RGB_EXT = 0x80C9+gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB :: GLenum+gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247+gl_TEXTURE_2D_MULTISAMPLE_ARRAY :: GLenum+gl_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102+gl_LEFT :: GLenum+gl_LEFT = 0x0406+gl_UNSIGNED_INT_SAMPLER_1D :: GLenum+gl_UNSIGNED_INT_SAMPLER_1D = 0x8DD1+gl_PIXEL_MAP_I_TO_R_SIZE :: GLenum+gl_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2+gl_VERTEX_ARRAY_BINDING_OES :: GLenum+gl_VERTEX_ARRAY_BINDING_OES = 0x85B5+gl_COMBINE_ALPHA_EXT :: GLenum+gl_COMBINE_ALPHA_EXT = 0x8572+gl_TRANSFORM_FEEDBACK_ATTRIBS_NV :: GLenum+gl_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E+gl_CURRENT_WEIGHT_ARB :: GLenum+gl_CURRENT_WEIGHT_ARB = 0x86A8+gl_RASTERIZER_DISCARD_NV :: GLenum+gl_RASTERIZER_DISCARD_NV = 0x8C89+gl_SRC_IN_NV :: GLenum+gl_SRC_IN_NV = 0x928A+gl_OBJECT_DISTANCE_TO_POINT_SGIS :: GLenum+gl_OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1+gl_COMPRESSED_RGB8_ETC2 :: GLenum+gl_COMPRESSED_RGB8_ETC2 = 0x9274+gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6+gl_RGB_SNORM :: GLenum+gl_RGB_SNORM = 0x8F92+gl_INTENSITY4_EXT :: GLenum+gl_INTENSITY4_EXT = 0x804A+gl_R8I :: GLenum+gl_R8I = 0x8231+gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS :: GLenum+gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8+gl_EDGEFLAG_BIT_PGI :: GLenum+gl_EDGEFLAG_BIT_PGI = 0x00040000+gl_MAX_FRAMEBUFFER_SAMPLES :: GLenum+gl_MAX_FRAMEBUFFER_SAMPLES = 0x9318+gl_SECONDARY_COLOR_ARRAY_TYPE :: GLenum+gl_SECONDARY_COLOR_ARRAY_TYPE = 0x845B+gl_ALL_BARRIER_BITS_EXT :: GLenum+gl_ALL_BARRIER_BITS_EXT = 0xFFFFFFFF+gl_TEXTURE14 :: GLenum+gl_TEXTURE14 = 0x84CE+gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1+gl_SRC0_ALPHA :: GLenum+gl_SRC0_ALPHA = 0x8588+gl_MODELVIEW16_ARB :: GLenum+gl_MODELVIEW16_ARB = 0x8730+gl_DARKEN_NV :: GLenum+gl_DARKEN_NV = 0x9297+gl_INTENSITY_EXT :: GLenum+gl_INTENSITY_EXT = 0x8049+gl_CURRENT_BIT :: GLenum+gl_CURRENT_BIT = 0x00000001+gl_FLOAT_RGBA32_NV :: GLenum+gl_FLOAT_RGBA32_NV = 0x888B+gl_SHADOW_ATTENUATION_EXT :: GLenum+gl_SHADOW_ATTENUATION_EXT = 0x834E+gl_COMPRESSED_SRGB8_ETC2 :: GLenum+gl_COMPRESSED_SRGB8_ETC2 = 0x9275+gl_DRAW_BUFFER15 :: GLenum+gl_DRAW_BUFFER15 = 0x8834+gl_COMPARE_R_TO_TEXTURE_ARB :: GLenum+gl_COMPARE_R_TO_TEXTURE_ARB = 0x884E+gl_R11F_G11F_B10F_EXT :: GLenum+gl_R11F_G11F_B10F_EXT = 0x8C3A+gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG :: GLenum+gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = 0x9138+gl_MULTISAMPLE_BUFFER_BIT6_QCOM :: GLenum+gl_MULTISAMPLE_BUFFER_BIT6_QCOM = 0x40000000+gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT :: GLenum+gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT = 0x8F67+gl_FEEDBACK_BUFFER_TYPE :: GLenum+gl_FEEDBACK_BUFFER_TYPE = 0x0DF2+gl_IMAGE_BINDING_FORMAT_EXT :: GLenum+gl_IMAGE_BINDING_FORMAT_EXT = 0x906E+gl_PROXY_TEXTURE_2D_EXT :: GLenum+gl_PROXY_TEXTURE_2D_EXT = 0x8064+gl_DEPTH32F_STENCIL8 :: GLenum+gl_DEPTH32F_STENCIL8 = 0x8CAD+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B+gl_TESS_EVALUATION_SUBROUTINE :: GLenum+gl_TESS_EVALUATION_SUBROUTINE = 0x92EA+gl_TEXTURE_LOD_BIAS_T_SGIX :: GLenum+gl_TEXTURE_LOD_BIAS_T_SGIX = 0x818F+gl_COVERAGE_COMPONENT4_NV :: GLenum+gl_COVERAGE_COMPONENT4_NV = 0x8ED1+gl_TEXTURE6_ARB :: GLenum+gl_TEXTURE6_ARB = 0x84C6+gl_MAX_3D_TEXTURE_SIZE_EXT :: GLenum+gl_MAX_3D_TEXTURE_SIZE_EXT = 0x8073+gl_TEXTURE_RESIDENT :: GLenum+gl_TEXTURE_RESIDENT = 0x8067+gl_FOG_COORD_ARRAY_TYPE :: GLenum+gl_FOG_COORD_ARRAY_TYPE = 0x8454+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR :: GLenum+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D+gl_QUERY_BY_REGION_WAIT :: GLenum+gl_QUERY_BY_REGION_WAIT = 0x8E15+gl_SLUMINANCE_ALPHA :: GLenum+gl_SLUMINANCE_ALPHA = 0x8C44+gl_INT_SAMPLER_CUBE :: GLenum+gl_INT_SAMPLER_CUBE = 0x8DCC+gl_UNSIGNED_SHORT_4_4_4_4_REV :: GLenum+gl_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365+gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB+gl_LUMINANCE4_ALPHA4_EXT :: GLenum+gl_LUMINANCE4_ALPHA4_EXT = 0x8043+gl_OPERAND0_RGB_ARB :: GLenum+gl_OPERAND0_RGB_ARB = 0x8590+gl_PROXY_TEXTURE_2D_STACK_MESAX :: GLenum+gl_PROXY_TEXTURE_2D_STACK_MESAX = 0x875C+gl_TEXTURE_3D_EXT :: GLenum+gl_TEXTURE_3D_EXT = 0x806F+gl_STREAM_RASTERIZATION_AMD :: GLenum+gl_STREAM_RASTERIZATION_AMD = 0x91A0+gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6+gl_DEPTH_COMPONENT32_SGIX :: GLenum+gl_DEPTH_COMPONENT32_SGIX = 0x81A7+gl_LINE_STRIP :: GLenum+gl_LINE_STRIP = 0x0003+gl_CON_25_ATI :: GLenum+gl_CON_25_ATI = 0x895A+gl_SLIM10U_SGIX :: GLenum+gl_SLIM10U_SGIX = 0x831E+gl_COLOR_INDEX2_EXT :: GLenum+gl_COLOR_INDEX2_EXT = 0x80E3+gl_CON_22_ATI :: GLenum+gl_CON_22_ATI = 0x8957+gl_DEFORMATIONS_MASK_SGIX :: GLenum+gl_DEFORMATIONS_MASK_SGIX = 0x8196+gl_INVERSE_TRANSPOSE_NV :: GLenum+gl_INVERSE_TRANSPOSE_NV = 0x862D+gl_MULT :: GLenum+gl_MULT = 0x0103+gl_ATTRIB_ARRAY_STRIDE_NV :: GLenum+gl_ATTRIB_ARRAY_STRIDE_NV = 0x8624+gl_RGBA16_SNORM :: GLenum+gl_RGBA16_SNORM = 0x8F9B+gl_MIN_SAMPLE_SHADING_VALUE :: GLenum+gl_MIN_SAMPLE_SHADING_VALUE = 0x8C37+gl_RG8_SNORM :: GLenum+gl_RG8_SNORM = 0x8F95+gl_OBJECT_ATTACHED_OBJECTS_ARB :: GLenum+gl_OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85+gl_UNPACK_SKIP_PIXELS_EXT :: GLenum+gl_UNPACK_SKIP_PIXELS_EXT = 0x0CF4+gl_ACTIVE_VERTEX_UNITS_ARB :: GLenum+gl_ACTIVE_VERTEX_UNITS_ARB = 0x86A5+gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum+gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5+gl_INTERNALFORMAT_RED_TYPE :: GLenum+gl_INTERNALFORMAT_RED_TYPE = 0x8278+gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV :: GLenum+gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0+gl_FLOAT_RGB_NV :: GLenum+gl_FLOAT_RGB_NV = 0x8882+gl_MAP_FLUSH_EXPLICIT_BIT_EXT :: GLenum+gl_MAP_FLUSH_EXPLICIT_BIT_EXT = 0x0010+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8+gl_HALF_FLOAT_NV :: GLenum+gl_HALF_FLOAT_NV = 0x140B+gl_DEPTH_STENCIL :: GLenum+gl_DEPTH_STENCIL = 0x84F9+gl_PROGRAM_ERROR_POSITION_ARB :: GLenum+gl_PROGRAM_ERROR_POSITION_ARB = 0x864B+gl_TRACE_ERRORS_BIT_MESA :: GLenum+gl_TRACE_ERRORS_BIT_MESA = 0x0020+gl_STENCIL_OP_VALUE_AMD :: GLenum+gl_STENCIL_OP_VALUE_AMD = 0x874C+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES = 0x8CD6+gl_COMPRESSED_SIGNED_R11_EAC :: GLenum+gl_COMPRESSED_SIGNED_R11_EAC = 0x9271+gl_FLOAT_MAT3x2 :: GLenum+gl_FLOAT_MAT3x2 = 0x8B67+gl_PROGRAM_ERROR_STRING_NV :: GLenum+gl_PROGRAM_ERROR_STRING_NV = 0x8874+gl_VERTEX_ID_NV :: GLenum+gl_VERTEX_ID_NV = 0x8C7B+gl_VERTEX_BINDING_OFFSET :: GLenum+gl_VERTEX_BINDING_OFFSET = 0x82D7+gl_RESTART_SUN :: GLenum+gl_RESTART_SUN = 0x0001+gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum+gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F+gl_COLOR_INDEX :: GLenum+gl_COLOR_INDEX = 0x1900+gl_TEXTURE31_ARB :: GLenum+gl_TEXTURE31_ARB = 0x84DF+gl_MAX_DRAW_BUFFERS_ARB :: GLenum+gl_MAX_DRAW_BUFFERS_ARB = 0x8824+gl_MAX_IMAGE_UNITS :: GLenum+gl_MAX_IMAGE_UNITS = 0x8F38+gl_OUTPUT_TEXTURE_COORD4_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD4_EXT = 0x87A1+gl_COLOR_ARRAY_POINTER :: GLenum+gl_COLOR_ARRAY_POINTER = 0x8090+gl_MAX_COLOR_TEXTURE_SAMPLES :: GLenum+gl_MAX_COLOR_TEXTURE_SAMPLES = 0x910E+gl_SIGNED_NEGATE_NV :: GLenum+gl_SIGNED_NEGATE_NV = 0x853D+gl_MAX_GEOMETRY_UNIFORM_BLOCKS :: GLenum+gl_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C+gl_DEBUG_TYPE_ERROR :: GLenum+gl_DEBUG_TYPE_ERROR = 0x824C+gl_HISTOGRAM_RED_SIZE_EXT :: GLenum+gl_HISTOGRAM_RED_SIZE_EXT = 0x8028+gl_SECONDARY_COLOR_ARRAY_POINTER_EXT :: GLenum+gl_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D+gl_UNSIGNALED :: GLenum+gl_UNSIGNALED = 0x9118+gl_CON_8_ATI :: GLenum+gl_CON_8_ATI = 0x8949+gl_COMPRESSED_RED :: GLenum+gl_COMPRESSED_RED = 0x8225+gl_RGBA2_EXT :: GLenum+gl_RGBA2_EXT = 0x8055+gl_T2F_C3F_V3F :: GLenum+gl_T2F_C3F_V3F = 0x2A2A+gl_SECONDARY_COLOR_ARRAY :: GLenum+gl_SECONDARY_COLOR_ARRAY = 0x845E+gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT :: GLenum+gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD+gl_COLOR3_BIT_PGI :: GLenum+gl_COLOR3_BIT_PGI = 0x00010000+gl_CLIP_DISTANCE3 :: GLenum+gl_CLIP_DISTANCE3 = 0x3003+gl_TEXTURE_SWIZZLE_G_EXT :: GLenum+gl_TEXTURE_SWIZZLE_G_EXT = 0x8E43+gl_SAMPLER_CUBE_MAP_ARRAY :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY = 0x900C+gl_4PASS_3_SGIS :: GLenum+gl_4PASS_3_SGIS = 0x80A7+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7+gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT :: GLenum+gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT = 0x92D5+gl_VERTEX_ARRAY_STRIDE :: GLenum+gl_VERTEX_ARRAY_STRIDE = 0x807C+gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS :: GLenum+gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314+gl_TEXTURE_SWIZZLE_A :: GLenum+gl_TEXTURE_SWIZZLE_A = 0x8E45+gl_DOUBLE_MAT3x2 :: GLenum+gl_DOUBLE_MAT3x2 = 0x8F4B+gl_TEXTURE_UPDATE_BARRIER_BIT_EXT :: GLenum+gl_TEXTURE_UPDATE_BARRIER_BIT_EXT = 0x00000100+gl_SHADING_LANGUAGE_VERSION :: GLenum+gl_SHADING_LANGUAGE_VERSION = 0x8B8C+gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP :: GLenum+gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162+gl_FIXED_ONLY_ARB :: GLenum+gl_FIXED_ONLY_ARB = 0x891D+gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI :: GLenum+gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973+gl_CON_19_ATI :: GLenum+gl_CON_19_ATI = 0x8954+gl_CONTEXT_RELEASE_BEHAVIOR :: GLenum+gl_CONTEXT_RELEASE_BEHAVIOR = 0x82FB+gl_ARRAY_BUFFER_BINDING :: GLenum+gl_ARRAY_BUFFER_BINDING = 0x8894+gl_UNPACK_COLORSPACE_CONVERSION_WEBGL :: GLenum+gl_UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243+gl_CONVEX_HULL_NV :: GLenum+gl_CONVEX_HULL_NV = 0x908B+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D+gl_FIRST_TO_REST_NV :: GLenum+gl_FIRST_TO_REST_NV = 0x90AF+gl_MAX_TEXTURE_COORDS :: GLenum+gl_MAX_TEXTURE_COORDS = 0x8871+gl_TEXTURE_DEPTH :: GLenum+gl_TEXTURE_DEPTH = 0x8071+gl_LIGHT0 :: GLenum+gl_LIGHT0 = 0x4000+gl_VERTEX_STREAM4_ATI :: GLenum+gl_VERTEX_STREAM4_ATI = 0x8770+gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI :: GLenum+gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB+gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC+gl_SAMPLER_2D_RECT_SHADOW_ARB :: GLenum+gl_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64+gl_DRAW_BUFFER1_ATI :: GLenum+gl_DRAW_BUFFER1_ATI = 0x8826+gl_SAMPLE_BUFFERS_SGIS :: GLenum+gl_SAMPLE_BUFFERS_SGIS = 0x80A8+gl_SIGNED_LUMINANCE_ALPHA_NV :: GLenum+gl_SIGNED_LUMINANCE_ALPHA_NV = 0x8703+gl_R16_SNORM :: GLenum+gl_R16_SNORM = 0x8F98+gl_DRAW_BUFFER13_ATI :: GLenum+gl_DRAW_BUFFER13_ATI = 0x8832+gl_TEXTURE_LIGHT_EXT :: GLenum+gl_TEXTURE_LIGHT_EXT = 0x8350+gl_BOOL_ARB :: GLenum+gl_BOOL_ARB = 0x8B56+gl_BGRA_IMG :: GLenum+gl_BGRA_IMG = 0x80E1+gl_SRGB_ALPHA_EXT :: GLenum+gl_SRGB_ALPHA_EXT = 0x8C42+gl_RELATIVE_ROUNDED_RECT2_NV :: GLenum+gl_RELATIVE_ROUNDED_RECT2_NV = 0xEB+gl_LUMINANCE16UI_EXT :: GLenum+gl_LUMINANCE16UI_EXT = 0x8D7A+gl_MATRIX7_NV :: GLenum+gl_MATRIX7_NV = 0x8637+gl_INTENSITY16 :: GLenum+gl_INTENSITY16 = 0x804D+gl_DRAW_INDIRECT_BUFFER :: GLenum+gl_DRAW_INDIRECT_BUFFER = 0x8F3F+gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085+gl_MAX_IMAGE_SAMPLES_EXT :: GLenum+gl_MAX_IMAGE_SAMPLES_EXT = 0x906D+gl_DEBUG_SOURCE_OTHER_ARB :: GLenum+gl_DEBUG_SOURCE_OTHER_ARB = 0x824B+gl_POINT_BIT :: GLenum+gl_POINT_BIT = 0x00000002+gl_MAX_VARYING_VECTORS :: GLenum+gl_MAX_VARYING_VECTORS = 0x8DFC+gl_SUBTRACT_ARB :: GLenum+gl_SUBTRACT_ARB = 0x84E7+gl_INT_SAMPLER_BUFFER_AMD :: GLenum+gl_INT_SAMPLER_BUFFER_AMD = 0x9002+gl_SAMPLE_MASK_INVERT_SGIS :: GLenum+gl_SAMPLE_MASK_INVERT_SGIS = 0x80AB+gl_POINT_DISTANCE_ATTENUATION_ARB :: GLenum+gl_POINT_DISTANCE_ATTENUATION_ARB = 0x8129+gl_GREEN_BIT_ATI :: GLenum+gl_GREEN_BIT_ATI = 0x00000002+gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum+gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA+gl_FRAMEBUFFER :: GLenum+gl_FRAMEBUFFER = 0x8D40+gl_TEXTURE_COMPRESSION_HINT_ARB :: GLenum+gl_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF+gl_PROGRAM_INPUT :: GLenum+gl_PROGRAM_INPUT = 0x92E3+gl_SCREEN_NV :: GLenum+gl_SCREEN_NV = 0x9295+gl_TEXTURE_CUBE_MAP_ARRAY_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_ARRAY_EXT = 0x9009+gl_FENCE_STATUS_NV :: GLenum+gl_FENCE_STATUS_NV = 0x84F3+gl_MAX_BINDABLE_UNIFORM_SIZE_EXT :: GLenum+gl_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED+gl_PACK_COMPRESSED_BLOCK_WIDTH :: GLenum+gl_PACK_COMPRESSED_BLOCK_WIDTH = 0x912B+gl_RELATIVE_VERTICAL_LINE_TO_NV :: GLenum+gl_RELATIVE_VERTICAL_LINE_TO_NV = 0x09+gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI :: GLenum+gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2+gl_ALPHA_INTEGER :: GLenum+gl_ALPHA_INTEGER = 0x8D97+gl_MAX_SUBROUTINES :: GLenum+gl_MAX_SUBROUTINES = 0x8DE7+gl_UNSIGNED_INT_VEC3_EXT :: GLenum+gl_UNSIGNED_INT_VEC3_EXT = 0x8DC7+gl_ELEMENT_ARRAY_ATI :: GLenum+gl_ELEMENT_ARRAY_ATI = 0x8768+gl_ONE_MINUS_CONSTANT_COLOR :: GLenum+gl_ONE_MINUS_CONSTANT_COLOR = 0x8002+gl_MODELVIEW18_ARB :: GLenum+gl_MODELVIEW18_ARB = 0x8732+gl_CONSTANT_ARB :: GLenum+gl_CONSTANT_ARB = 0x8576+gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV :: GLenum+gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3+gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL :: GLenum+gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD+gl_DRAW_BUFFER_EXT :: GLenum+gl_DRAW_BUFFER_EXT = 0x0C01+gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT :: GLenum+gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 0x9068+gl_FLOAT_MAT2x4_NV :: GLenum+gl_FLOAT_MAT2x4_NV = 0x8B66+gl_CULL_VERTEX_EXT :: GLenum+gl_CULL_VERTEX_EXT = 0x81AA+gl_MATRIX_PALETTE_ARB :: GLenum+gl_MATRIX_PALETTE_ARB = 0x8840+gl_VERTEX_PROGRAM_POINT_SIZE_ARB :: GLenum+gl_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642+gl_FLOAT_RG16_NV :: GLenum+gl_FLOAT_RG16_NV = 0x8886+gl_CON_1_ATI :: GLenum+gl_CON_1_ATI = 0x8942+gl_BLEND_EQUATION_RGB :: GLenum+gl_BLEND_EQUATION_RGB = 0x8009+gl_OP_CROSS_PRODUCT_EXT :: GLenum+gl_OP_CROSS_PRODUCT_EXT = 0x8797+gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT :: GLenum+gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F+gl_TESS_CONTROL_PROGRAM_NV :: GLenum+gl_TESS_CONTROL_PROGRAM_NV = 0x891E+gl_FIXED_ONLY :: GLenum+gl_FIXED_ONLY = 0x891D+gl_4PASS_1_EXT :: GLenum+gl_4PASS_1_EXT = 0x80A5+gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum+gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910B+gl_UNSIGNED_INT_8_8_8_8_REV :: GLenum+gl_UNSIGNED_INT_8_8_8_8_REV = 0x8367+gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS :: GLenum+gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42+gl_SLUMINANCE_ALPHA_NV :: GLenum+gl_SLUMINANCE_ALPHA_NV = 0x8C44+gl_PROXY_TEXTURE_CUBE_MAP :: GLenum+gl_PROXY_TEXTURE_CUBE_MAP = 0x851B+gl_IMAGE_CLASS_1_X_32 :: GLenum+gl_IMAGE_CLASS_1_X_32 = 0x82BB+gl_STACK_OVERFLOW_KHR :: GLenum+gl_STACK_OVERFLOW_KHR = 0x0503+gl_COMPRESSED_RGBA_ASTC_5x5x5_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_5x5x5_OES = 0x93C6+gl_CLOSE_PATH_NV :: GLenum+gl_CLOSE_PATH_NV = 0x00+gl_PIXEL_COUNT_AVAILABLE_NV :: GLenum+gl_PIXEL_COUNT_AVAILABLE_NV = 0x8867+gl_PATH_DASH_OFFSET_NV :: GLenum+gl_PATH_DASH_OFFSET_NV = 0x907E+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A+gl_GLOBAL_ALPHA_FACTOR_SUN :: GLenum+gl_GLOBAL_ALPHA_FACTOR_SUN = 0x81DA+gl_INDEX_ARRAY_COUNT_EXT :: GLenum+gl_INDEX_ARRAY_COUNT_EXT = 0x8087+gl_PACK_RESAMPLE_OML :: GLenum+gl_PACK_RESAMPLE_OML = 0x8984+gl_LAYER_NV :: GLenum+gl_LAYER_NV = 0x8DAA+gl_DRAW_FRAMEBUFFER :: GLenum+gl_DRAW_FRAMEBUFFER = 0x8CA9+gl_LINEAR_DETAIL_ALPHA_SGIS :: GLenum+gl_LINEAR_DETAIL_ALPHA_SGIS = 0x8098+gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT :: GLenum+gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT = 0x8E89+gl_EDGE_FLAG_ARRAY :: GLenum+gl_EDGE_FLAG_ARRAY = 0x8079+gl_TEXTURE_DEFORMATION_BIT_SGIX :: GLenum+gl_TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001+gl_SOURCE1_RGB :: GLenum+gl_SOURCE1_RGB = 0x8581+gl_TEXTURE_3D_OES :: GLenum+gl_TEXTURE_3D_OES = 0x806F+gl_ALLOW_DRAW_OBJ_HINT_PGI :: GLenum+gl_ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E+gl_PATH_STROKE_BOUNDING_BOX_NV :: GLenum+gl_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2+gl_HINT_BIT :: GLenum+gl_HINT_BIT = 0x00008000+gl_VERTICAL_LINE_TO_NV :: GLenum+gl_VERTICAL_LINE_TO_NV = 0x08+gl_MAX_TEXTURE_BUFFER_SIZE_EXT :: GLenum+gl_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B+gl_MAX_DRAW_BUFFERS_ATI :: GLenum+gl_MAX_DRAW_BUFFERS_ATI = 0x8824+gl_R8_EXT :: GLenum+gl_R8_EXT = 0x8229+gl_TEXTURE_COVERAGE_SAMPLES_NV :: GLenum+gl_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045+gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV :: GLenum+gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 0x9025+gl_REFERENCED_BY_VERTEX_SHADER :: GLenum+gl_REFERENCED_BY_VERTEX_SHADER = 0x9306+gl_FLOAT_RG32_NV :: GLenum+gl_FLOAT_RG32_NV = 0x8887+gl_TESSELLATION_FACTOR_AMD :: GLenum+gl_TESSELLATION_FACTOR_AMD = 0x9005+gl_MAX_PROGRAM_TEMPORARIES_ARB :: GLenum+gl_MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5+gl_COMPRESSED_RGBA_ASTC_12x12_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD+gl_PROJECTION :: GLenum+gl_PROJECTION = 0x1701+gl_S :: GLenum+gl_S = 0x2000+gl_ALPHA_FLOAT32_APPLE :: GLenum+gl_ALPHA_FLOAT32_APPLE = 0x8816+gl_LUMINANCE8_ALPHA8_OES :: GLenum+gl_LUMINANCE8_ALPHA8_OES = 0x8045+gl_4_BYTES_NV :: GLenum+gl_4_BYTES_NV = 0x1409+gl_CONST_EYE_NV :: GLenum+gl_CONST_EYE_NV = 0x86E5+gl_MAT_SPECULAR_BIT_PGI :: GLenum+gl_MAT_SPECULAR_BIT_PGI = 0x04000000+gl_TEXTURE1_ARB :: GLenum+gl_TEXTURE1_ARB = 0x84C1+gl_LINE_WIDTH_GRANULARITY :: GLenum+gl_LINE_WIDTH_GRANULARITY = 0x0B23+gl_DRAW_INDIRECT_BUFFER_BINDING :: GLenum+gl_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43+gl_BLEND_EQUATION :: GLenum+gl_BLEND_EQUATION = 0x8009+gl_RGBA8UI_EXT :: GLenum+gl_RGBA8UI_EXT = 0x8D7C+gl_NORMALIZE :: GLenum+gl_NORMALIZE = 0x0BA1+gl_LUMINANCE_ALPHA_FLOAT16_APPLE :: GLenum+gl_LUMINANCE_ALPHA_FLOAT16_APPLE = 0x881F+gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX :: GLenum+gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049+gl_INVERSE_NV :: GLenum+gl_INVERSE_NV = 0x862B+gl_TEXTURE_SWIZZLE_A_EXT :: GLenum+gl_TEXTURE_SWIZZLE_A_EXT = 0x8E45+gl_DEPTH24_STENCIL8_OES :: GLenum+gl_DEPTH24_STENCIL8_OES = 0x88F0+gl_UNPACK_COMPRESSED_BLOCK_HEIGHT :: GLenum+gl_UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128+gl_RGBA32UI :: GLenum+gl_RGBA32UI = 0x8D70+gl_MAP1_COLOR_4 :: GLenum+gl_MAP1_COLOR_4 = 0x0D90+gl_MAX_ELEMENTS_VERTICES :: GLenum+gl_MAX_ELEMENTS_VERTICES = 0x80E8+gl_CLIENT_VERTEX_ARRAY_BIT :: GLenum+gl_CLIENT_VERTEX_ARRAY_BIT = 0x00000002+gl_TEXTURE_GREEN_TYPE :: GLenum+gl_TEXTURE_GREEN_TYPE = 0x8C11+gl_TEXTURE_BINDING_BUFFER_ARB :: GLenum+gl_TEXTURE_BINDING_BUFFER_ARB = 0x8C2C+gl_MAX_RECTANGLE_TEXTURE_SIZE_NV :: GLenum+gl_MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8+gl_INTERNALFORMAT_GREEN_TYPE :: GLenum+gl_INTERNALFORMAT_GREEN_TYPE = 0x8279+gl_OP_ADD_EXT :: GLenum+gl_OP_ADD_EXT = 0x8787+gl_UNSIGNED_INT_24_8 :: GLenum+gl_UNSIGNED_INT_24_8 = 0x84FA+gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: GLenum+gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32+gl_3D_COLOR :: GLenum+gl_3D_COLOR = 0x0602+gl_MODULATE_COLOR_IMG :: GLenum+gl_MODULATE_COLOR_IMG = 0x8C04+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518+gl_TEXTURE_CLIPMAP_FRAME_SGIX :: GLenum+gl_TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172+gl_NORMAL_ARRAY_STRIDE_EXT :: GLenum+gl_NORMAL_ARRAY_STRIDE_EXT = 0x807F+gl_R16 :: GLenum+gl_R16 = 0x822A+gl_PIXEL_PACK_BUFFER :: GLenum+gl_PIXEL_PACK_BUFFER = 0x88EB+gl_SOFTLIGHT_KHR :: GLenum+gl_SOFTLIGHT_KHR = 0x929C+gl_POST_CONVOLUTION_BLUE_SCALE :: GLenum+gl_POST_CONVOLUTION_BLUE_SCALE = 0x801E+gl_INTERLEAVED_ATTRIBS_NV :: GLenum+gl_INTERLEAVED_ATTRIBS_NV = 0x8C8C+gl_COLOR_ATTACHMENT8 :: GLenum+gl_COLOR_ATTACHMENT8 = 0x8CE8+gl_DEBUG_TYPE_PUSH_GROUP_KHR :: GLenum+gl_DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269+gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9+gl_MOV_ATI :: GLenum+gl_MOV_ATI = 0x8961+gl_PROGRAM_SEPARABLE :: GLenum+gl_PROGRAM_SEPARABLE = 0x8258+gl_REG_20_ATI :: GLenum+gl_REG_20_ATI = 0x8935+gl_DOUBLE_VEC3 :: GLenum+gl_DOUBLE_VEC3 = 0x8FFD+gl_8X_BIT_ATI :: GLenum+gl_8X_BIT_ATI = 0x00000004+gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum+gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C+gl_MATRIX26_ARB :: GLenum+gl_MATRIX26_ARB = 0x88DA+gl_PROXY_TEXTURE_RECTANGLE_ARB :: GLenum+gl_PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7+gl_TRANSFORM_HINT_APPLE :: GLenum+gl_TRANSFORM_HINT_APPLE = 0x85B1+gl_UNPACK_ROW_BYTES_APPLE :: GLenum+gl_UNPACK_ROW_BYTES_APPLE = 0x8A16+gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI :: GLenum+gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB :: GLenum+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F+gl_ONE_MINUS_CONSTANT_COLOR_EXT :: GLenum+gl_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002+gl_TEXTURE_BINDING_CUBE_MAP_OES :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_OES = 0x8514+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E+gl_VERTEX_ARRAY_STORAGE_HINT_APPLE :: GLenum+gl_VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F+gl_VERTEX_BINDING_BUFFER :: GLenum+gl_VERTEX_BINDING_BUFFER = 0x8F4F+gl_FRAGMENT_LIGHT0_SGIX :: GLenum+gl_FRAGMENT_LIGHT0_SGIX = 0x840C+gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV :: GLenum+gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x04+gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT :: GLenum+gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE+gl_SRC2_RGB :: GLenum+gl_SRC2_RGB = 0x8582+gl_NUM_COMPRESSED_TEXTURE_FORMATS :: GLenum+gl_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2+gl_OUTPUT_TEXTURE_COORD2_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD2_EXT = 0x879F+gl_DEPTH_TEXTURE_MODE :: GLenum+gl_DEPTH_TEXTURE_MODE = 0x884B+gl_SAMPLE_PATTERN_EXT :: GLenum+gl_SAMPLE_PATTERN_EXT = 0x80AC+gl_ELEMENT_ARRAY_APPLE :: GLenum+gl_ELEMENT_ARRAY_APPLE = 0x8A0C+gl_MAX_FOG_FUNC_POINTS_SGIS :: GLenum+gl_MAX_FOG_FUNC_POINTS_SGIS = 0x812C+gl_TEXTURE_APPLICATION_MODE_EXT :: GLenum+gl_TEXTURE_APPLICATION_MODE_EXT = 0x834F+gl_COLOR_ARRAY_SIZE_EXT :: GLenum+gl_COLOR_ARRAY_SIZE_EXT = 0x8081+gl_VERTEX_SOURCE_ATI :: GLenum+gl_VERTEX_SOURCE_ATI = 0x8774+gl_MAP2_VERTEX_ATTRIB3_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB3_4_NV = 0x8673+gl_LIGHTEN_KHR :: GLenum+gl_LIGHTEN_KHR = 0x9298+gl_INT_SAMPLER_1D_ARRAY :: GLenum+gl_INT_SAMPLER_1D_ARRAY = 0x8DCE+gl_UNSIGNED_INT_10F_11F_11F_REV_EXT :: GLenum+gl_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B+gl_LUMINANCE8 :: GLenum+gl_LUMINANCE8 = 0x8040+gl_ACCUM_ALPHA_BITS :: GLenum+gl_ACCUM_ALPHA_BITS = 0x0D5B+gl_MINMAX_FORMAT :: GLenum+gl_MINMAX_FORMAT = 0x802F+gl_NOOP :: GLenum+gl_NOOP = 0x1505+gl_READ_FRAMEBUFFER_EXT :: GLenum+gl_READ_FRAMEBUFFER_EXT = 0x8CA8+gl_SHADER :: GLenum+gl_SHADER = 0x82E1+gl_UNSIGNED_INT_10_10_10_2_OES :: GLenum+gl_UNSIGNED_INT_10_10_10_2_OES = 0x8DF6+gl_TEXTURE_COMPRESSED_BLOCK_WIDTH :: GLenum+gl_TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1+gl_DEBUG_OUTPUT_KHR :: GLenum+gl_DEBUG_OUTPUT_KHR = 0x92E0+gl_SOURCE0_ALPHA_ARB :: GLenum+gl_SOURCE0_ALPHA_ARB = 0x8588+gl_SAMPLER_1D_ARRAY_EXT :: GLenum+gl_SAMPLER_1D_ARRAY_EXT = 0x8DC0+gl_T2F_V3F :: GLenum+gl_T2F_V3F = 0x2A27+gl_SAMPLE_MASK_SGIS :: GLenum+gl_SAMPLE_MASK_SGIS = 0x80A0+gl_CIRCULAR_TANGENT_ARC_TO_NV :: GLenum+gl_CIRCULAR_TANGENT_ARC_TO_NV = 0xFC+gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS :: GLenum+gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83+gl_MAX_DEBUG_LOGGED_MESSAGES :: GLenum+gl_MAX_DEBUG_LOGGED_MESSAGES = 0x9144+gl_SOURCE1_ALPHA :: GLenum+gl_SOURCE1_ALPHA = 0x8589+gl_RGB_422_APPLE :: GLenum+gl_RGB_422_APPLE = 0x8A1F+gl_COLOR_TABLE :: GLenum+gl_COLOR_TABLE = 0x80D0+gl_MAP1_TEXTURE_COORD_3 :: GLenum+gl_MAP1_TEXTURE_COORD_3 = 0x0D95+gl_DEBUG_SEVERITY_HIGH_AMD :: GLenum+gl_DEBUG_SEVERITY_HIGH_AMD = 0x9146+gl_UNSIGNED_INT :: GLenum+gl_UNSIGNED_INT = 0x1405+gl_VERTEX_PROGRAM_CALLBACK_MESA :: GLenum+gl_VERTEX_PROGRAM_CALLBACK_MESA = 0x8BB5+gl_BLOCK_INDEX :: GLenum+gl_BLOCK_INDEX = 0x92FD+gl_FLOAT :: GLenum+gl_FLOAT = 0x1406+gl_TRACE_PIXELS_BIT_MESA :: GLenum+gl_TRACE_PIXELS_BIT_MESA = 0x0010+gl_BACK :: GLenum+gl_BACK = 0x0405+gl_PATH_JOIN_STYLE_NV :: GLenum+gl_PATH_JOIN_STYLE_NV = 0x9079+gl_LUMINANCE_ALPHA16I_EXT :: GLenum+gl_LUMINANCE_ALPHA16I_EXT = 0x8D8D+gl_FLOAT_MAT2 :: GLenum+gl_FLOAT_MAT2 = 0x8B5A+gl_SIGNED_IDENTITY_NV :: GLenum+gl_SIGNED_IDENTITY_NV = 0x853C+gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA :: GLenum+gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA = 0x8BB3+gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX :: GLenum+gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312+gl_CLIP_DEPTH_MODE :: GLenum+gl_CLIP_DEPTH_MODE = 0x935D+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT = 0x8D6C+gl_CULL_FACE :: GLenum+gl_CULL_FACE = 0x0B44+gl_DETAIL_TEXTURE_LEVEL_SGIS :: GLenum+gl_DETAIL_TEXTURE_LEVEL_SGIS = 0x809A+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB :: GLenum+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243+gl_PACK_SKIP_ROWS :: GLenum+gl_PACK_SKIP_ROWS = 0x0D03+gl_COEFF :: GLenum+gl_COEFF = 0x0A00+gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E1E+gl_NUM_INSTRUCTIONS_PER_PASS_ATI :: GLenum+gl_NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB :: GLenum+gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1+gl_RGBA8 :: GLenum+gl_RGBA8 = 0x8058+gl_TESS_GEN_VERTEX_ORDER :: GLenum+gl_TESS_GEN_VERTEX_ORDER = 0x8E78+gl_TEXTURE_CUBE_MAP :: GLenum+gl_TEXTURE_CUBE_MAP = 0x8513+gl_VERTEX_PRECLIP_HINT_SGIX :: GLenum+gl_VERTEX_PRECLIP_HINT_SGIX = 0x83EF+gl_NUM_SHADING_LANGUAGE_VERSIONS :: GLenum+gl_NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9+gl_OUTPUT_TEXTURE_COORD9_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD9_EXT = 0x87A6+gl_MAX_PROGRAM_GENERIC_RESULTS_NV :: GLenum+gl_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6+gl_COLOR_ATTACHMENT7_NV :: GLenum+gl_COLOR_ATTACHMENT7_NV = 0x8CE7+gl_OUT_OF_MEMORY :: GLenum+gl_OUT_OF_MEMORY = 0x0505+gl_TEXTURE_COORD_ARRAY_POINTER_EXT :: GLenum+gl_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092+gl_FLOAT_MAT2_ARB :: GLenum+gl_FLOAT_MAT2_ARB = 0x8B5A+gl_COMBINER_AB_DOT_PRODUCT_NV :: GLenum+gl_COMBINER_AB_DOT_PRODUCT_NV = 0x8545+gl_INDEX_ARRAY_POINTER_EXT :: GLenum+gl_INDEX_ARRAY_POINTER_EXT = 0x8091+gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV :: GLenum+gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C+gl_3D :: GLenum+gl_3D = 0x0601+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES = 0x93E7+gl_UPPER_LEFT :: GLenum+gl_UPPER_LEFT = 0x8CA2+gl_IMAGE_1D_ARRAY_EXT :: GLenum+gl_IMAGE_1D_ARRAY_EXT = 0x9052+gl_GREEN :: GLenum+gl_GREEN = 0x1904+gl_RGB12 :: GLenum+gl_RGB12 = 0x8053+gl_GEOMETRY_DEFORMATION_BIT_SGIX :: GLenum+gl_GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002+gl_LUMINANCE_ALPHA_FLOAT32_ATI :: GLenum+gl_LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819+gl_INT_SAMPLER_CUBE_MAP_ARRAY :: GLenum+gl_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E+gl_EVAL_TRIANGULAR_2D_NV :: GLenum+gl_EVAL_TRIANGULAR_2D_NV = 0x86C1+gl_QUERY_BY_REGION_WAIT_INVERTED :: GLenum+gl_QUERY_BY_REGION_WAIT_INVERTED = 0x8E19+gl_CONTEXT_ROBUST_ACCESS_KHR :: GLenum+gl_CONTEXT_ROBUST_ACCESS_KHR = 0x90F3+gl_STREAM_READ_ARB :: GLenum+gl_STREAM_READ_ARB = 0x88E1+gl_INT_IMAGE_1D_ARRAY_EXT :: GLenum+gl_INT_IMAGE_1D_ARRAY_EXT = 0x905D+gl_QUERY_NO_WAIT_INVERTED :: GLenum+gl_QUERY_NO_WAIT_INVERTED = 0x8E18+gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT :: GLenum+gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF+gl_COLOR_ATTACHMENT4_EXT :: GLenum+gl_COLOR_ATTACHMENT4_EXT = 0x8CE4+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR :: GLenum+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E+gl_LOSE_CONTEXT_ON_RESET :: GLenum+gl_LOSE_CONTEXT_ON_RESET = 0x8252+gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084+gl_REPLACEMENT_CODE_SUN :: GLenum+gl_REPLACEMENT_CODE_SUN = 0x81D8+gl_422_REV_EXT :: GLenum+gl_422_REV_EXT = 0x80CD+gl_COMPILE_STATUS :: GLenum+gl_COMPILE_STATUS = 0x8B81+gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE = 0x8A03+gl_TRANSPOSE_COLOR_MATRIX :: GLenum+gl_TRANSPOSE_COLOR_MATRIX = 0x84E6+gl_COLOR_TABLE_FORMAT :: GLenum+gl_COLOR_TABLE_FORMAT = 0x80D8+gl_VERSION_ES_CM_1_1 :: GLenum+gl_VERSION_ES_CM_1_1 = 1+gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24+gl_BUFFER_STORAGE_FLAGS :: GLenum+gl_BUFFER_STORAGE_FLAGS = 0x8220+gl_UNSIGNED_NORMALIZED_EXT :: GLenum+gl_UNSIGNED_NORMALIZED_EXT = 0x8C17+gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE :: GLenum+gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0+gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: GLenum+gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001+gl_3_BYTES :: GLenum+gl_3_BYTES = 0x1408+gl_CND0_ATI :: GLenum+gl_CND0_ATI = 0x896B+gl_TEXTURE_MAX_LEVEL_APPLE :: GLenum+gl_TEXTURE_MAX_LEVEL_APPLE = 0x813D+gl_POINT :: GLenum+gl_POINT = 0x1B00+gl_MODELVIEW11_ARB :: GLenum+gl_MODELVIEW11_ARB = 0x872B+gl_RED_BITS :: GLenum+gl_RED_BITS = 0x0D52+gl_PIXEL_TILE_GRID_WIDTH_SGIX :: GLenum+gl_PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142+gl_DRAW_BUFFER7_NV :: GLenum+gl_DRAW_BUFFER7_NV = 0x882C+gl_OP_SET_LT_EXT :: GLenum+gl_OP_SET_LT_EXT = 0x878D+gl_TEXTURE24_ARB :: GLenum+gl_TEXTURE24_ARB = 0x84D8+gl_TESS_GEN_POINT_MODE :: GLenum+gl_TESS_GEN_POINT_MODE = 0x8E79+gl_INTERNALFORMAT_PREFERRED :: GLenum+gl_INTERNALFORMAT_PREFERRED = 0x8270+gl_VERTEX_SHADER_VARIANTS_EXT :: GLenum+gl_VERTEX_SHADER_VARIANTS_EXT = 0x87D0+gl_COMBINER_CD_OUTPUT_NV :: GLenum+gl_COMBINER_CD_OUTPUT_NV = 0x854B+gl_TRANSPOSE_CURRENT_MATRIX_ARB :: GLenum+gl_TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7+gl_MAX_ARRAY_TEXTURE_LAYERS_EXT :: GLenum+gl_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF+gl_UNSIGNED_SHORT_8_8_MESA :: GLenum+gl_UNSIGNED_SHORT_8_8_MESA = 0x85BA+gl_BLEND_ADVANCED_COHERENT_NV :: GLenum+gl_BLEND_ADVANCED_COHERENT_NV = 0x9285+gl_VERTEX_ARRAY_EXT :: GLenum+gl_VERTEX_ARRAY_EXT = 0x8074+gl_BOOL_VEC4_ARB :: GLenum+gl_BOOL_VEC4_ARB = 0x8B59+gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV :: GLenum+gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853+gl_UNSIGNED_SHORT_5_5_5_1 :: GLenum+gl_UNSIGNED_SHORT_5_5_5_1 = 0x8034+gl_SHADE_MODEL :: GLenum+gl_SHADE_MODEL = 0x0B54+gl_MIRROR_CLAMP_TO_EDGE :: GLenum+gl_MIRROR_CLAMP_TO_EDGE = 0x8743+gl_RGB5_EXT :: GLenum+gl_RGB5_EXT = 0x8050+gl_TEXTURE_GEN_S :: GLenum+gl_TEXTURE_GEN_S = 0x0C60+gl_TEXTURE_COMPRESSED :: GLenum+gl_TEXTURE_COMPRESSED = 0x86A1+gl_FRAMEBUFFER_BLEND :: GLenum+gl_FRAMEBUFFER_BLEND = 0x828B+gl_REPLACE_VALUE_AMD :: GLenum+gl_REPLACE_VALUE_AMD = 0x874B+gl_YCRCB_SGIX :: GLenum+gl_YCRCB_SGIX = 0x8318+gl_UNIFORM_BLOCK_INDEX :: GLenum+gl_UNIFORM_BLOCK_INDEX = 0x8A3A+gl_TEXTURE_TOO_LARGE_EXT :: GLenum+gl_TEXTURE_TOO_LARGE_EXT = 0x8065+gl_MIRRORED_REPEAT_ARB :: GLenum+gl_MIRRORED_REPEAT_ARB = 0x8370+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER :: GLenum+gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB+gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB :: GLenum+gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B+gl_MAX_SAMPLES :: GLenum+gl_MAX_SAMPLES = 0x8D57+gl_ATTENUATION_EXT :: GLenum+gl_ATTENUATION_EXT = 0x834D+gl_MIRROR_CLAMP_EXT :: GLenum+gl_MIRROR_CLAMP_EXT = 0x8742+gl_DEBUG_LOGGED_MESSAGES :: GLenum+gl_DEBUG_LOGGED_MESSAGES = 0x9145+gl_DOT3_ATI :: GLenum+gl_DOT3_ATI = 0x8966+gl_EMBOSS_CONSTANT_NV :: GLenum+gl_EMBOSS_CONSTANT_NV = 0x855E+gl_OUTPUT_TEXTURE_COORD11_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD11_EXT = 0x87A8+gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum+gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8+gl_INDEX :: GLenum+gl_INDEX = 0x8222+gl_CURRENT_MATRIX_ARB :: GLenum+gl_CURRENT_MATRIX_ARB = 0x8641+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS :: GLenum+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4+gl_MAX_DRAW_BUFFERS_EXT :: GLenum+gl_MAX_DRAW_BUFFERS_EXT = 0x8824+gl_ADD_BLEND_IMG :: GLenum+gl_ADD_BLEND_IMG = 0x8C09+gl_CLIP_FAR_HINT_PGI :: GLenum+gl_CLIP_FAR_HINT_PGI = 0x1A221+gl_POST_CONVOLUTION_COLOR_TABLE :: GLenum+gl_POST_CONVOLUTION_COLOR_TABLE = 0x80D1+gl_RGBA4_OES :: GLenum+gl_RGBA4_OES = 0x8056+gl_QUERY_RESULT_AVAILABLE_ARB :: GLenum+gl_QUERY_RESULT_AVAILABLE_ARB = 0x8867+gl_RGB8UI :: GLenum+gl_RGB8UI = 0x8D7D+gl_DYNAMIC_READ :: GLenum+gl_DYNAMIC_READ = 0x88E9+gl_TEXTURE_BINDING_2D_MULTISAMPLE :: GLenum+gl_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104+gl_OBJECT_TYPE_APPLE :: GLenum+gl_OBJECT_TYPE_APPLE = 0x9112+gl_PERCENTAGE_AMD :: GLenum+gl_PERCENTAGE_AMD = 0x8BC3+gl_LIGHT_MODEL_LOCAL_VIEWER :: GLenum+gl_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51+gl_SPARE0_PLUS_SECONDARY_COLOR_NV :: GLenum+gl_SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532+gl_OP_INDEX_EXT :: GLenum+gl_OP_INDEX_EXT = 0x8782+gl_VIEW_CLASS_S3TC_DXT3_RGBA :: GLenum+gl_VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE+gl_TEXTURE_DEPTH_TYPE_ARB :: GLenum+gl_TEXTURE_DEPTH_TYPE_ARB = 0x8C16+gl_TEXTURE_ALPHA_SIZE :: GLenum+gl_TEXTURE_ALPHA_SIZE = 0x805F+gl_YCRCB_422_SGIX :: GLenum+gl_YCRCB_422_SGIX = 0x81BB+gl_INDEX_ARRAY_LENGTH_NV :: GLenum+gl_INDEX_ARRAY_LENGTH_NV = 0x8F2E+gl_TRANSPOSE_AFFINE_3D_NV :: GLenum+gl_TRANSPOSE_AFFINE_3D_NV = 0x9098+gl_MATRIX17_ARB :: GLenum+gl_MATRIX17_ARB = 0x88D1+gl_SRGB_ALPHA :: GLenum+gl_SRGB_ALPHA = 0x8C42+gl_MAP_TESSELLATION_NV :: GLenum+gl_MAP_TESSELLATION_NV = 0x86C2+gl_PACK_SKIP_VOLUMES_SGIS :: GLenum+gl_PACK_SKIP_VOLUMES_SGIS = 0x8130+gl_COLOR_BUFFER_BIT :: GLenum+gl_COLOR_BUFFER_BIT = 0x00004000+gl_REG_6_ATI :: GLenum+gl_REG_6_ATI = 0x8927+gl_ATOMIC_COUNTER_BUFFER_BINDING :: GLenum+gl_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1+gl_POST_CONVOLUTION_ALPHA_BIAS :: GLenum+gl_POST_CONVOLUTION_ALPHA_BIAS = 0x8023+gl_HARDLIGHT_NV :: GLenum+gl_HARDLIGHT_NV = 0x929B+gl_INTENSITY16_SNORM :: GLenum+gl_INTENSITY16_SNORM = 0x901B+gl_TEXCOORD1_BIT_PGI :: GLenum+gl_TEXCOORD1_BIT_PGI = 0x10000000+gl_DEBUG_CALLBACK_FUNCTION :: GLenum+gl_DEBUG_CALLBACK_FUNCTION = 0x8244+gl_TEXTURE8_ARB :: GLenum+gl_TEXTURE8_ARB = 0x84C8+gl_DOUBLE_VEC2_EXT :: GLenum+gl_DOUBLE_VEC2_EXT = 0x8FFC+gl_TRIANGLES_ADJACENCY :: GLenum+gl_TRIANGLES_ADJACENCY = 0x000C+gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44+gl_R16F :: GLenum+gl_R16F = 0x822D+gl_OUTPUT_TEXTURE_COORD19_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD19_EXT = 0x87B0+gl_QUAD_LUMINANCE4_SGIS :: GLenum+gl_QUAD_LUMINANCE4_SGIS = 0x8120+gl_SAMPLER_OBJECT_AMD :: GLenum+gl_SAMPLER_OBJECT_AMD = 0x9155+gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE :: GLenum+gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE = 0x83F2+gl_UNSIGNED_INT_IMAGE_2D :: GLenum+gl_UNSIGNED_INT_IMAGE_2D = 0x9063+gl_ALPHA_TEST :: GLenum+gl_ALPHA_TEST = 0x0BC0+gl_CONVOLUTION_WIDTH :: GLenum+gl_CONVOLUTION_WIDTH = 0x8018+gl_SLUMINANCE_NV :: GLenum+gl_SLUMINANCE_NV = 0x8C46+gl_FRAMEBUFFER_UNDEFINED_OES :: GLenum+gl_FRAMEBUFFER_UNDEFINED_OES = 0x8219+gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23+gl_HALF_FLOAT_OES :: GLenum+gl_HALF_FLOAT_OES = 0x8D61+gl_CONVOLUTION_FORMAT_EXT :: GLenum+gl_CONVOLUTION_FORMAT_EXT = 0x8017+gl_FALSE :: GLenum+gl_FALSE = 0+gl_ADD_ATI :: GLenum+gl_ADD_ATI = 0x8963+gl_STENCIL_BACK_FAIL :: GLenum+gl_STENCIL_BACK_FAIL = 0x8801+gl_DOUBLE_VEC4 :: GLenum+gl_DOUBLE_VEC4 = 0x8FFE+gl_STANDARD_FONT_NAME_NV :: GLenum+gl_STANDARD_FONT_NAME_NV = 0x9072+gl_ALPHA4_EXT :: GLenum+gl_ALPHA4_EXT = 0x803B+gl_EXPAND_NORMAL_NV :: GLenum+gl_EXPAND_NORMAL_NV = 0x8538+gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB :: GLenum+gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A+gl_TRACE_MASK_MESA :: GLenum+gl_TRACE_MASK_MESA = 0x8755+gl_VARIABLE_B_NV :: GLenum+gl_VARIABLE_B_NV = 0x8524+gl_RGB16_EXT :: GLenum+gl_RGB16_EXT = 0x8054+gl_TEXTURE :: GLenum+gl_TEXTURE = 0x1702+gl_PIXEL_UNPACK_BUFFER_BINDING_EXT :: GLenum+gl_PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF+gl_IMAGE_CLASS_1_X_8 :: GLenum+gl_IMAGE_CLASS_1_X_8 = 0x82C1+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56+gl_BOOL_VEC2_ARB :: GLenum+gl_BOOL_VEC2_ARB = 0x8B57+gl_MAP2_VERTEX_3 :: GLenum+gl_MAP2_VERTEX_3 = 0x0DB7+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH :: GLenum+gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243+gl_TEXTURE_WRAP_S :: GLenum+gl_TEXTURE_WRAP_S = 0x2802+gl_TEXTURE_CUBE_MAP_NEGATIVE_X :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516+gl_TEXTURE_CUBE_MAP_ARRAY :: GLenum+gl_TEXTURE_CUBE_MAP_ARRAY = 0x9009+gl_TEXTURE_ALPHA_TYPE :: GLenum+gl_TEXTURE_ALPHA_TYPE = 0x8C13+gl_MAX_COLOR_ATTACHMENTS_NV :: GLenum+gl_MAX_COLOR_ATTACHMENTS_NV = 0x8CDF+gl_MAX_CUBE_MAP_TEXTURE_SIZE :: GLenum+gl_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C+gl_ANY_SAMPLES_PASSED :: GLenum+gl_ANY_SAMPLES_PASSED = 0x8C2F+gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213+gl_COLOR_ARRAY_STRIDE :: GLenum+gl_COLOR_ARRAY_STRIDE = 0x8083+gl_MULTISAMPLE_BIT_EXT :: GLenum+gl_MULTISAMPLE_BIT_EXT = 0x20000000+gl_VERTEX_ATTRIB_ARRAY_DIVISOR :: GLenum+gl_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE+gl_UNSIGNED_INT64_VEC3_NV :: GLenum+gl_UNSIGNED_INT64_VEC3_NV = 0x8FF6+gl_WAIT_FAILED_APPLE :: GLenum+gl_WAIT_FAILED_APPLE = 0x911D+gl_DRAW_BUFFER5_ATI :: GLenum+gl_DRAW_BUFFER5_ATI = 0x882A+gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT :: GLenum+gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C+gl_ONE_MINUS_CONSTANT_ALPHA_EXT :: GLenum+gl_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004+gl_UNSIGNED_INT_8_24_REV_MESA :: GLenum+gl_UNSIGNED_INT_8_24_REV_MESA = 0x8752+gl_MAX_PROGRAM_ENV_PARAMETERS_ARB :: GLenum+gl_MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5+gl_MAX_VERTEX_VARYING_COMPONENTS_EXT :: GLenum+gl_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE+gl_CURRENT_TANGENT_EXT :: GLenum+gl_CURRENT_TANGENT_EXT = 0x843B+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE+gl_ALPHA16 :: GLenum+gl_ALPHA16 = 0x803E+gl_MAP1_VERTEX_4 :: GLenum+gl_MAP1_VERTEX_4 = 0x0D98+gl_SAMPLER_CUBE_SHADOW_NV :: GLenum+gl_SAMPLER_CUBE_SHADOW_NV = 0x8DC5+gl_SAMPLER_2D_SHADOW_ARB :: GLenum+gl_SAMPLER_2D_SHADOW_ARB = 0x8B62+gl_PROGRAM_LENGTH_NV :: GLenum+gl_PROGRAM_LENGTH_NV = 0x8627+gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086+gl_IGNORE_BORDER_HP :: GLenum+gl_IGNORE_BORDER_HP = 0x8150+gl_DEBUG_SOURCE_SHADER_COMPILER :: GLenum+gl_DEBUG_SOURCE_SHADER_COMPILER = 0x8248+gl_TEXTURE_BORDER_VALUES_NV :: GLenum+gl_TEXTURE_BORDER_VALUES_NV = 0x871A+gl_FRAGMENT_SUBROUTINE :: GLenum+gl_FRAGMENT_SUBROUTINE = 0x92EC+gl_MAX_DEPTH_TEXTURE_SAMPLES :: GLenum+gl_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F+gl_VERTEX_ATTRIB_ARRAY_POINTER :: GLenum+gl_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645+gl_COLOR_ATTACHMENT7 :: GLenum+gl_COLOR_ATTACHMENT7 = 0x8CE7+gl_LAST_VERTEX_CONVENTION_EXT :: GLenum+gl_LAST_VERTEX_CONVENTION_EXT = 0x8E4E+gl_TEXTURE_LO_SIZE_NV :: GLenum+gl_TEXTURE_LO_SIZE_NV = 0x871C+gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46+gl_COMPRESSED_RGB8_ETC2_OES :: GLenum+gl_COMPRESSED_RGB8_ETC2_OES = 0x9274+gl_NORMAL_MAP_NV :: GLenum+gl_NORMAL_MAP_NV = 0x8511+gl_COLOR_ARRAY_COUNT_EXT :: GLenum+gl_COLOR_ARRAY_COUNT_EXT = 0x8084+gl_TEXTURE_COMPARE_MODE_EXT :: GLenum+gl_TEXTURE_COMPARE_MODE_EXT = 0x884C+gl_BINORMAL_ARRAY_TYPE_EXT :: GLenum+gl_BINORMAL_ARRAY_TYPE_EXT = 0x8440+gl_OPERAND0_RGB_EXT :: GLenum+gl_OPERAND0_RGB_EXT = 0x8590+gl_MAX_VERTEX_VARYING_COMPONENTS_ARB :: GLenum+gl_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE+gl_PIXEL_MIN_FILTER_EXT :: GLenum+gl_PIXEL_MIN_FILTER_EXT = 0x8332+gl_ACCUM_ADJACENT_PAIRS_NV :: GLenum+gl_ACCUM_ADJACENT_PAIRS_NV = 0x90AD+gl_BLEND_DST :: GLenum+gl_BLEND_DST = 0x0BE0+gl_W_EXT :: GLenum+gl_W_EXT = 0x87D8+gl_RENDERBUFFER_COVERAGE_SAMPLES_NV :: GLenum+gl_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB+gl_STENCIL_FUNC :: GLenum+gl_STENCIL_FUNC = 0x0B92+gl_MAX_VERTEX_STREAMS :: GLenum+gl_MAX_VERTEX_STREAMS = 0x8E71+gl_GEOMETRY_INPUT_TYPE :: GLenum+gl_GEOMETRY_INPUT_TYPE = 0x8917+gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV :: GLenum+gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857+gl_MINMAX_SINK_EXT :: GLenum+gl_MINMAX_SINK_EXT = 0x8030+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC+gl_DOUBLE_MAT2x3 :: GLenum+gl_DOUBLE_MAT2x3 = 0x8F49+gl_FRACTIONAL_EVEN_EXT :: GLenum+gl_FRACTIONAL_EVEN_EXT = 0x8E7C+gl_VERTEX_ARRAY_TYPE_EXT :: GLenum+gl_VERTEX_ARRAY_TYPE_EXT = 0x807B+gl_BINORMAL_ARRAY_POINTER_EXT :: GLenum+gl_BINORMAL_ARRAY_POINTER_EXT = 0x8443+gl_SAMPLE_MASK_EXT :: GLenum+gl_SAMPLE_MASK_EXT = 0x80A0+gl_TESS_CONTROL_SHADER_EXT :: GLenum+gl_TESS_CONTROL_SHADER_EXT = 0x8E88+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 0x8C80+gl_TANGENT_ARRAY_STRIDE_EXT :: GLenum+gl_TANGENT_ARRAY_STRIDE_EXT = 0x843F+gl_GET_TEXTURE_IMAGE_TYPE :: GLenum+gl_GET_TEXTURE_IMAGE_TYPE = 0x8292+gl_OFFSET :: GLenum+gl_OFFSET = 0x92FC+gl_ALL_STATIC_DATA_IBM :: GLenum+gl_ALL_STATIC_DATA_IBM = 103060+gl_READ_PIXEL_DATA_RANGE_LENGTH_NV :: GLenum+gl_READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B+gl_CONSTANT_COLOR :: GLenum+gl_CONSTANT_COLOR = 0x8001+gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT :: GLenum+gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366+gl_MATERIAL_SIDE_HINT_PGI :: GLenum+gl_MATERIAL_SIDE_HINT_PGI = 0x1A22C+gl_UNPACK_RESAMPLE_OML :: GLenum+gl_UNPACK_RESAMPLE_OML = 0x8985+gl_SAMPLE_SHADING :: GLenum+gl_SAMPLE_SHADING = 0x8C36+gl_OUTPUT_TEXTURE_COORD13_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD13_EXT = 0x87AA+gl_MAX_COLOR_MATRIX_STACK_DEPTH :: GLenum+gl_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3+gl_INT64_VEC3_NV :: GLenum+gl_INT64_VEC3_NV = 0x8FEA+gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV :: GLenum+gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x00000010+gl_TEXTURE_STACK_DEPTH :: GLenum+gl_TEXTURE_STACK_DEPTH = 0x0BA5+gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL :: GLenum+gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500+gl_FRAMEBUFFER_UNSUPPORTED_EXT :: GLenum+gl_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD+gl_QUERY_TARGET :: GLenum+gl_QUERY_TARGET = 0x82EA+gl_LUMINANCE4_ALPHA4 :: GLenum+gl_LUMINANCE4_ALPHA4 = 0x8043+gl_TRANSFORM_FEEDBACK_BARRIER_BIT :: GLenum+gl_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800+gl_RGB32UI :: GLenum+gl_RGB32UI = 0x8D71+gl_STATIC_DRAW :: GLenum+gl_STATIC_DRAW = 0x88E4+gl_MAX_COMPUTE_UNIFORM_BLOCKS :: GLenum+gl_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB+gl_PALETTE4_RGBA8_OES :: GLenum+gl_PALETTE4_RGBA8_OES = 0x8B91+gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL :: GLenum+gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241+gl_TEXTURE21 :: GLenum+gl_TEXTURE21 = 0x84D5+gl_RGB32I :: GLenum+gl_RGB32I = 0x8D83+gl_MAX_TEXTURE_LOD_BIAS_EXT :: GLenum+gl_MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD+gl_PATH_GEN_COLOR_FORMAT_NV :: GLenum+gl_PATH_GEN_COLOR_FORMAT_NV = 0x90B2+gl_RGB10_A2UI :: GLenum+gl_RGB10_A2UI = 0x906F+gl_GREEN_BITS :: GLenum+gl_GREEN_BITS = 0x0D53+gl_POLYGON_MODE :: GLenum+gl_POLYGON_MODE = 0x0B40+gl_SUCCESS_NV :: GLenum+gl_SUCCESS_NV = 0x902F+gl_RGBA12 :: GLenum+gl_RGBA12 = 0x805A+gl_PATCHES :: GLenum+gl_PATCHES = 0x000E+gl_ACCUM :: GLenum+gl_ACCUM = 0x0100+gl_NUM_PASSES_ATI :: GLenum+gl_NUM_PASSES_ATI = 0x8970+gl_DEBUG_TYPE_ERROR_ARB :: GLenum+gl_DEBUG_TYPE_ERROR_ARB = 0x824C+gl_TEXTURE_LIGHTING_MODE_HP :: GLenum+gl_TEXTURE_LIGHTING_MODE_HP = 0x8167+gl_HISTOGRAM_SINK_EXT :: GLenum+gl_HISTOGRAM_SINK_EXT = 0x802D+gl_POINT_SIZE_GRANULARITY :: GLenum+gl_POINT_SIZE_GRANULARITY = 0x0B13+gl_R32F :: GLenum+gl_R32F = 0x822E+gl_STATIC_COPY :: GLenum+gl_STATIC_COPY = 0x88E6+gl_FOG_COORDINATE_ARRAY_TYPE_EXT :: GLenum+gl_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454+gl_SPARE0_NV :: GLenum+gl_SPARE0_NV = 0x852E+gl_3DC_XY_AMD :: GLenum+gl_3DC_XY_AMD = 0x87FA+gl_LUMINANCE_ALPHA32F_ARB :: GLenum+gl_LUMINANCE_ALPHA32F_ARB = 0x8819+gl_VERTEX_ARRAY_RANGE_VALID_NV :: GLenum+gl_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F+gl_DEPTH_BUFFER_BIT6_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT6_QCOM = 0x00004000+gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX :: GLenum+gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX = 0x8314+gl_LINE_WIDTH :: GLenum+gl_LINE_WIDTH = 0x0B21+gl_FOG_OFFSET_SGIX :: GLenum+gl_FOG_OFFSET_SGIX = 0x8198+gl_GEOMETRY_SHADER_BIT_EXT :: GLenum+gl_GEOMETRY_SHADER_BIT_EXT = 0x00000004+gl_TEXTURE_BLUE_SIZE :: GLenum+gl_TEXTURE_BLUE_SIZE = 0x805E+gl_TEXTURE_SHADER_NV :: GLenum+gl_TEXTURE_SHADER_NV = 0x86DE+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV :: GLenum+gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5F+gl_FRAMEZOOM_SGIX :: GLenum+gl_FRAMEZOOM_SGIX = 0x818B+gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT = 0x886D+gl_DEPTH_RENDERABLE :: GLenum+gl_DEPTH_RENDERABLE = 0x8287+gl_MAX_TEXTURE_BUFFER_SIZE :: GLenum+gl_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B+gl_COLOR_ALPHA_PAIRING_ATI :: GLenum+gl_COLOR_ALPHA_PAIRING_ATI = 0x8975+gl_PACK_REVERSE_ROW_ORDER_ANGLE :: GLenum+gl_PACK_REVERSE_ROW_ORDER_ANGLE = 0x93A4+gl_VERTEX_ATTRIB_ARRAY_NORMALIZED :: GLenum+gl_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A+gl_OP_MADD_EXT :: GLenum+gl_OP_MADD_EXT = 0x8788+gl_TEXTURE7 :: GLenum+gl_TEXTURE7 = 0x84C7+gl_RGB32I_EXT :: GLenum+gl_RGB32I_EXT = 0x8D83+gl_RED_BIAS :: GLenum+gl_RED_BIAS = 0x0D15+gl_FLOAT_VEC2 :: GLenum+gl_FLOAT_VEC2 = 0x8B50+gl_HALF_APPLE :: GLenum+gl_HALF_APPLE = 0x140B+gl_SGX_BINARY_IMG :: GLenum+gl_SGX_BINARY_IMG = 0x8C0A+gl_CON_28_ATI :: GLenum+gl_CON_28_ATI = 0x895D+gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP :: GLenum+gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163+gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV :: GLenum+gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533+gl_MAP2_VERTEX_ATTRIB2_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB2_4_NV = 0x8672+gl_TRANSFORM_BIT :: GLenum+gl_TRANSFORM_BIT = 0x00001000+gl_R8 :: GLenum+gl_R8 = 0x8229+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV = 0x8D56+gl_T :: GLenum+gl_T = 0x2001+gl_TEXTURE_ENV_MODE :: GLenum+gl_TEXTURE_ENV_MODE = 0x2200+gl_HIGH_INT :: GLenum+gl_HIGH_INT = 0x8DF5+gl_TEXTURE_UNSIGNED_REMAP_MODE_NV :: GLenum+gl_TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F+gl_MAX_PROGRAM_LOOP_COUNT_NV :: GLenum+gl_MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8+gl_PERFQUERY_WAIT_INTEL :: GLenum+gl_PERFQUERY_WAIT_INTEL = 0x83FB+gl_INVALID_FRAMEBUFFER_OPERATION_EXT :: GLenum+gl_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506+gl_TEXTURE_2D_BINDING_EXT :: GLenum+gl_TEXTURE_2D_BINDING_EXT = 0x8069+gl_TEXTURE_NUM_LEVELS_QCOM :: GLenum+gl_TEXTURE_NUM_LEVELS_QCOM = 0x8BD9+gl_TEXTURE_BUFFER_ARB :: GLenum+gl_TEXTURE_BUFFER_ARB = 0x8C2A+gl_TRUE :: GLenum+gl_TRUE = 1+gl_MAX_LAYERS :: GLenum+gl_MAX_LAYERS = 0x8281+gl_MAX_TEXTURE_UNITS_ARB :: GLenum+gl_MAX_TEXTURE_UNITS_ARB = 0x84E2+gl_MAP2_NORMAL :: GLenum+gl_MAP2_NORMAL = 0x0DB2+gl_DUAL_ALPHA16_SGIS :: GLenum+gl_DUAL_ALPHA16_SGIS = 0x8113+gl_PROGRAM_OUTPUT :: GLenum+gl_PROGRAM_OUTPUT = 0x92E4+gl_OUTPUT_TEXTURE_COORD22_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD22_EXT = 0x87B3+gl_SAMPLER_1D_ARB :: GLenum+gl_SAMPLER_1D_ARB = 0x8B5D+gl_POST_CONVOLUTION_GREEN_BIAS :: GLenum+gl_POST_CONVOLUTION_GREEN_BIAS = 0x8021+gl_INT_IMAGE_CUBE :: GLenum+gl_INT_IMAGE_CUBE = 0x905B+gl_CURRENT_VERTEX_WEIGHT_EXT :: GLenum+gl_CURRENT_VERTEX_WEIGHT_EXT = 0x850B+gl_SIGNED_LUMINANCE8_NV :: GLenum+gl_SIGNED_LUMINANCE8_NV = 0x8702+gl_TEXTURE_VIEW_NUM_LAYERS_EXT :: GLenum+gl_TEXTURE_VIEW_NUM_LAYERS_EXT = 0x82DE+gl_RG16F :: GLenum+gl_RG16F = 0x822F+gl_PROGRAM_POINT_SIZE_EXT :: GLenum+gl_PROGRAM_POINT_SIZE_EXT = 0x8642+gl_FILE_NAME_NV :: GLenum+gl_FILE_NAME_NV = 0x9074+gl_INT_IMAGE_BUFFER_EXT :: GLenum+gl_INT_IMAGE_BUFFER_EXT = 0x905C+gl_TEXTURE_UPDATE_BARRIER_BIT :: GLenum+gl_TEXTURE_UPDATE_BARRIER_BIT = 0x00000100+gl_HARDMIX_NV :: GLenum+gl_HARDMIX_NV = 0x92A9+gl_FLOAT_MAT3x4 :: GLenum+gl_FLOAT_MAT3x4 = 0x8B68+gl_TEXTURE_INTERNAL_FORMAT_QCOM :: GLenum+gl_TEXTURE_INTERNAL_FORMAT_QCOM = 0x8BD5+gl_INTERNALFORMAT_BLUE_SIZE :: GLenum+gl_INTERNALFORMAT_BLUE_SIZE = 0x8273+gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV :: GLenum+gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28+gl_HSL_COLOR_NV :: GLenum+gl_HSL_COLOR_NV = 0x92AF+gl_CONDITION_SATISFIED :: GLenum+gl_CONDITION_SATISFIED = 0x911C+gl_UNIFORM_BUFFER_LENGTH_NV :: GLenum+gl_UNIFORM_BUFFER_LENGTH_NV = 0x9370+gl_ALPHA8UI_EXT :: GLenum+gl_ALPHA8UI_EXT = 0x8D7E+gl_REG_23_ATI :: GLenum+gl_REG_23_ATI = 0x8938+gl_UNSIGNED_SHORT_5_6_5_EXT :: GLenum+gl_UNSIGNED_SHORT_5_6_5_EXT = 0x8363+gl_EDGE_FLAG_ARRAY_LENGTH_NV :: GLenum+gl_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30+gl_IMAGE_CLASS_1_X_16 :: GLenum+gl_IMAGE_CLASS_1_X_16 = 0x82BE+gl_LUMINANCE8_ALPHA8_SNORM :: GLenum+gl_LUMINANCE8_ALPHA8_SNORM = 0x9016+gl_PATH_FILL_COVER_MODE_NV :: GLenum+gl_PATH_FILL_COVER_MODE_NV = 0x9082+gl_LUMINANCE_ALPHA_FLOAT32_APPLE :: GLenum+gl_LUMINANCE_ALPHA_FLOAT32_APPLE = 0x8819+gl_INTENSITY16UI_EXT :: GLenum+gl_INTENSITY16UI_EXT = 0x8D79+gl_RENDERBUFFER_SAMPLES_APPLE :: GLenum+gl_RENDERBUFFER_SAMPLES_APPLE = 0x8CAB+gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE :: GLenum+gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF+gl_LUMINANCE_ALPHA32I_EXT :: GLenum+gl_LUMINANCE_ALPHA32I_EXT = 0x8D87+gl_REGISTER_COMBINERS_NV :: GLenum+gl_REGISTER_COMBINERS_NV = 0x8522+gl_R1UI_N3F_V3F_SUN :: GLenum+gl_R1UI_N3F_V3F_SUN = 0x85C7+gl_FOG_COORDINATE_SOURCE :: GLenum+gl_FOG_COORDINATE_SOURCE = 0x8450+gl_DEBUG_SEVERITY_MEDIUM_AMD :: GLenum+gl_DEBUG_SEVERITY_MEDIUM_AMD = 0x9147+gl_MODELVIEW30_ARB :: GLenum+gl_MODELVIEW30_ARB = 0x873E+gl_COMPRESSED_RGBA_S3TC_DXT5_EXT :: GLenum+gl_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3+gl_DRAW_BUFFER0_NV :: GLenum+gl_DRAW_BUFFER0_NV = 0x8825+gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum+gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC+gl_ELEMENT_ARRAY_BARRIER_BIT :: GLenum+gl_ELEMENT_ARRAY_BARRIER_BIT = 0x00000002+gl_SHADER_PIXEL_LOCAL_STORAGE_EXT :: GLenum+gl_SHADER_PIXEL_LOCAL_STORAGE_EXT = 0x8F64+gl_FRONT_LEFT :: GLenum+gl_FRONT_LEFT = 0x0400+gl_UNIFORM_BUFFER_BINDING :: GLenum+gl_UNIFORM_BUFFER_BINDING = 0x8A28+gl_SIGNED_RGBA8_NV :: GLenum+gl_SIGNED_RGBA8_NV = 0x86FC+gl_EYE_PLANE :: GLenum+gl_EYE_PLANE = 0x2502+gl_TEXTURE_1D :: GLenum+gl_TEXTURE_1D = 0x0DE0+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CE+gl_MALI_PROGRAM_BINARY_ARM :: GLenum+gl_MALI_PROGRAM_BINARY_ARM = 0x8F61+gl_SKIP_COMPONENTS3_NV :: GLenum+gl_SKIP_COMPONENTS3_NV = -4+gl_LUMINANCE_ALPHA :: GLenum+gl_LUMINANCE_ALPHA = 0x190A+gl_ACCUM_RED_BITS :: GLenum+gl_ACCUM_RED_BITS = 0x0D58+gl_POLYGON_OFFSET_FACTOR :: GLenum+gl_POLYGON_OFFSET_FACTOR = 0x8038+gl_SAMPLER_2D_ARRAY_SHADOW_NV :: GLenum+gl_SAMPLER_2D_ARRAY_SHADOW_NV = 0x8DC4+gl_VARIABLE_D_NV :: GLenum+gl_VARIABLE_D_NV = 0x8526+gl_TEXTURE_LEQUAL_R_SGIX :: GLenum+gl_TEXTURE_LEQUAL_R_SGIX = 0x819C+gl_INT :: GLenum+gl_INT = 0x1404+gl_IMAGE_TRANSLATE_Y_HP :: GLenum+gl_IMAGE_TRANSLATE_Y_HP = 0x8158+gl_POINT_TOKEN :: GLenum+gl_POINT_TOKEN = 0x0701+gl_RESAMPLE_ZERO_FILL_OML :: GLenum+gl_RESAMPLE_ZERO_FILL_OML = 0x8987+gl_DEBUG_SOURCE_THIRD_PARTY_KHR :: GLenum+gl_DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249+gl_TEXTURE_MAG_SIZE_NV :: GLenum+gl_TEXTURE_MAG_SIZE_NV = 0x871F+gl_PER_STAGE_CONSTANTS_NV :: GLenum+gl_PER_STAGE_CONSTANTS_NV = 0x8535+gl_VIRTUAL_PAGE_SIZE_Y_ARB :: GLenum+gl_VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196+gl_SPRITE_EYE_ALIGNED_SGIX :: GLenum+gl_SPRITE_EYE_ALIGNED_SGIX = 0x814E+gl_EVAL_VERTEX_ATTRIB14_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB14_NV = 0x86D4+gl_TRANSFORM_FEEDBACK_VARYINGS_NV :: GLenum+gl_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83+gl_RGB10 :: GLenum+gl_RGB10 = 0x8052+gl_MAX_VIEWPORT_DIMS :: GLenum+gl_MAX_VIEWPORT_DIMS = 0x0D3A+gl_BLUE_MAX_CLAMP_INGR :: GLenum+gl_BLUE_MAX_CLAMP_INGR = 0x8566+gl_INCR_WRAP :: GLenum+gl_INCR_WRAP = 0x8507+gl_VIRTUAL_PAGE_SIZE_X_AMD :: GLenum+gl_VIRTUAL_PAGE_SIZE_X_AMD = 0x9195+gl_BOOL_VEC3 :: GLenum+gl_BOOL_VEC3 = 0x8B58+gl_CON_17_ATI :: GLenum+gl_CON_17_ATI = 0x8952+gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES :: GLenum+gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES = 0x851C+gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT :: GLenum+gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB+gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI :: GLenum+gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1+gl_MINMAX :: GLenum+gl_MINMAX = 0x802E+gl_CONSTANT_BORDER_HP :: GLenum+gl_CONSTANT_BORDER_HP = 0x8151+gl_SRGB_WRITE :: GLenum+gl_SRGB_WRITE = 0x8298+gl_MAX_TEXTURE_BUFFER_SIZE_ARB :: GLenum+gl_MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B+gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV :: GLenum+gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856+gl_DECAL :: GLenum+gl_DECAL = 0x2101+gl_REG_7_ATI :: GLenum+gl_REG_7_ATI = 0x8928+gl_TESS_GEN_SPACING_EXT :: GLenum+gl_TESS_GEN_SPACING_EXT = 0x8E77+gl_ELEMENT_ARRAY_LENGTH_NV :: GLenum+gl_ELEMENT_ARRAY_LENGTH_NV = 0x8F33+gl_MATRIX31_ARB :: GLenum+gl_MATRIX31_ARB = 0x88DF+gl_TRANSFORM_FEEDBACK_VARYING :: GLenum+gl_TRANSFORM_FEEDBACK_VARYING = 0x92F4+gl_VERTEX_ATTRIB_ARRAY_SIZE :: GLenum+gl_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623+gl_NOTEQUAL :: GLenum+gl_NOTEQUAL = 0x0205+gl_READ_PIXELS_TYPE :: GLenum+gl_READ_PIXELS_TYPE = 0x828E+gl_MODELVIEW_STACK_DEPTH :: GLenum+gl_MODELVIEW_STACK_DEPTH = 0x0BA3+gl_COMPRESSED_RGBA_ASTC_6x6x5_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_6x6x5_OES = 0x93C8+gl_COMBINE_EXT :: GLenum+gl_COMBINE_EXT = 0x8570+gl_NICEST :: GLenum+gl_NICEST = 0x1102+gl_MODELVIEW2_ARB :: GLenum+gl_MODELVIEW2_ARB = 0x8722+gl_UNPACK_IMAGE_HEIGHT :: GLenum+gl_UNPACK_IMAGE_HEIGHT = 0x806E+gl_TEXTURE_CUBE_MAP_ARRAY_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009+gl_DRAW_BUFFER12 :: GLenum+gl_DRAW_BUFFER12 = 0x8831+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET :: GLenum+gl_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C+gl_FRAMEBUFFER_DEFAULT_HEIGHT :: GLenum+gl_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311+gl_DT_BIAS_NV :: GLenum+gl_DT_BIAS_NV = 0x8717+gl_DSDT_NV :: GLenum+gl_DSDT_NV = 0x86F5+gl_IMAGE_CUBE_MAP_ARRAY :: GLenum+gl_IMAGE_CUBE_MAP_ARRAY = 0x9054+gl_STENCIL_INDEX4 :: GLenum+gl_STENCIL_INDEX4 = 0x8D47+gl_ROUND_NV :: GLenum+gl_ROUND_NV = 0x90A4+gl_Y_EXT :: GLenum+gl_Y_EXT = 0x87D6+gl_PATH_DASH_CAPS_NV :: GLenum+gl_PATH_DASH_CAPS_NV = 0x907B+gl_TEXTURE_PRIORITY :: GLenum+gl_TEXTURE_PRIORITY = 0x8066+gl_TEXTURE_4D_BINDING_SGIS :: GLenum+gl_TEXTURE_4D_BINDING_SGIS = 0x814F+gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD :: GLenum+gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 0x914C+gl_CULL_MODES_NV :: GLenum+gl_CULL_MODES_NV = 0x86E0+gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE = 0x8A06+gl_REFERENCED_BY_GEOMETRY_SHADER_EXT :: GLenum+gl_REFERENCED_BY_GEOMETRY_SHADER_EXT = 0x9309+gl_MODELVIEW_MATRIX :: GLenum+gl_MODELVIEW_MATRIX = 0x0BA6+gl_VIDEO_BUFFER_NV :: GLenum+gl_VIDEO_BUFFER_NV = 0x9020+gl_TEXTURE12 :: GLenum+gl_TEXTURE12 = 0x84CC+gl_COLORBURN_NV :: GLenum+gl_COLORBURN_NV = 0x929A+gl_COLOR_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898+gl_READ_BUFFER_EXT :: GLenum+gl_READ_BUFFER_EXT = 0x0C02+gl_RENDERBUFFER_RED_SIZE_OES :: GLenum+gl_RENDERBUFFER_RED_SIZE_OES = 0x8D50+gl_TEXTURE_SHARED_SIZE :: GLenum+gl_TEXTURE_SHARED_SIZE = 0x8C3F+gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS :: GLenum+gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355+gl_ALL_SHADER_BITS_EXT :: GLenum+gl_ALL_SHADER_BITS_EXT = 0xFFFFFFFF+gl_PERFQUERY_SINGLE_CONTEXT_INTEL :: GLenum+gl_PERFQUERY_SINGLE_CONTEXT_INTEL = 0x00000000+gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT = 0x8E82+gl_PERFMON_RESULT_AMD :: GLenum+gl_PERFMON_RESULT_AMD = 0x8BC6+gl_GUILTY_CONTEXT_RESET :: GLenum+gl_GUILTY_CONTEXT_RESET = 0x8253+gl_PREVIOUS :: GLenum+gl_PREVIOUS = 0x8578+gl_UNSIGNED_INT16_VEC3_NV :: GLenum+gl_UNSIGNED_INT16_VEC3_NV = 0x8FF2+gl_VERTEX_ATTRIB_MAP1_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP1_APPLE = 0x8A00+gl_LIGHT3 :: GLenum+gl_LIGHT3 = 0x4003+gl_TESS_EVALUATION_SUBROUTINE_UNIFORM :: GLenum+gl_TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0+gl_DUAL_INTENSITY8_SGIS :: GLenum+gl_DUAL_INTENSITY8_SGIS = 0x8119+gl_PARAMETER_BUFFER_BINDING_ARB :: GLenum+gl_PARAMETER_BUFFER_BINDING_ARB = 0x80EF+gl_CURRENT_SECONDARY_COLOR :: GLenum+gl_CURRENT_SECONDARY_COLOR = 0x8459+gl_RENDERBUFFER_ALPHA_SIZE :: GLenum+gl_RENDERBUFFER_ALPHA_SIZE = 0x8D53+gl_DUAL_INTENSITY12_SGIS :: GLenum+gl_DUAL_INTENSITY12_SGIS = 0x811A+gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING :: GLenum+gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A+gl_OP_MAX_EXT :: GLenum+gl_OP_MAX_EXT = 0x878A+gl_EDGE_FLAG_ARRAY_EXT :: GLenum+gl_EDGE_FLAG_ARRAY_EXT = 0x8079+gl_COLOR_TABLE_LUMINANCE_SIZE :: GLenum+gl_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE+gl_FOG_COORD_ARRAY_ADDRESS_NV :: GLenum+gl_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28+gl_COPY :: GLenum+gl_COPY = 0x1503+gl_DRAW_BUFFER2_NV :: GLenum+gl_DRAW_BUFFER2_NV = 0x8827+gl_SAMPLER_BINDING :: GLenum+gl_SAMPLER_BINDING = 0x8919+gl_COPY_WRITE_BUFFER :: GLenum+gl_COPY_WRITE_BUFFER = 0x8F37+gl_PIXEL_UNPACK_BUFFER :: GLenum+gl_PIXEL_UNPACK_BUFFER = 0x88EC+gl_VIEW_CLASS_S3TC_DXT1_RGBA :: GLenum+gl_VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD+gl_DRAW_FRAMEBUFFER_APPLE :: GLenum+gl_DRAW_FRAMEBUFFER_APPLE = 0x8CA9+gl_PIXEL_MAP_A_TO_A_SIZE :: GLenum+gl_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9+gl_EDGE_FLAG :: GLenum+gl_EDGE_FLAG = 0x0B43+gl_CLIP_DISTANCE2 :: GLenum+gl_CLIP_DISTANCE2 = 0x3002+gl_TEXTURE_GEN_MODE :: GLenum+gl_TEXTURE_GEN_MODE = 0x2500+gl_HALF_BIAS_NORMAL_NV :: GLenum+gl_HALF_BIAS_NORMAL_NV = 0x853A+gl_RESAMPLE_ZERO_FILL_SGIX :: GLenum+gl_RESAMPLE_ZERO_FILL_SGIX = 0x842F+gl_OUTPUT_TEXTURE_COORD12_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD12_EXT = 0x87A9+gl_UNSIGNED_SHORT_8_8_REV_MESA :: GLenum+gl_UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB+gl_PALETTE8_RGBA8_OES :: GLenum+gl_PALETTE8_RGBA8_OES = 0x8B96+gl_TEXTURE_4D_SGIS :: GLenum+gl_TEXTURE_4D_SGIS = 0x8134+gl_PIXEL_PACK_BUFFER_EXT :: GLenum+gl_PIXEL_PACK_BUFFER_EXT = 0x88EB+gl_MAP_ATTRIB_U_ORDER_NV :: GLenum+gl_MAP_ATTRIB_U_ORDER_NV = 0x86C3+gl_FUNC_SUBTRACT :: GLenum+gl_FUNC_SUBTRACT = 0x800A+gl_PIXEL_SUBSAMPLE_4444_SGIX :: GLenum+gl_PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518+gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT :: GLenum+gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D+gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT :: GLenum+gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT = 0x90CD+gl_DYNAMIC_COPY :: GLenum+gl_DYNAMIC_COPY = 0x88EA+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A+gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT :: GLenum+gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3+gl_PROGRAM_LENGTH_ARB :: GLenum+gl_PROGRAM_LENGTH_ARB = 0x8627+gl_MODELVIEW14_ARB :: GLenum+gl_MODELVIEW14_ARB = 0x872E+gl_ITALIC_BIT_NV :: GLenum+gl_ITALIC_BIT_NV = 0x02+gl_OR_INVERTED :: GLenum+gl_OR_INVERTED = 0x150D+gl_CLIP_NEAR_HINT_PGI :: GLenum+gl_CLIP_NEAR_HINT_PGI = 0x1A220+gl_COVERAGE_EDGE_FRAGMENTS_NV :: GLenum+gl_COVERAGE_EDGE_FRAGMENTS_NV = 0x8ED6+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3+gl_PROGRAM_BINARY_LENGTH_OES :: GLenum+gl_PROGRAM_BINARY_LENGTH_OES = 0x8741+gl_DRAW_BUFFER8_ARB :: GLenum+gl_DRAW_BUFFER8_ARB = 0x882D+gl_DRAW_FRAMEBUFFER_EXT :: GLenum+gl_DRAW_FRAMEBUFFER_EXT = 0x8CA9+gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET :: GLenum+gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9+gl_SYNC_CL_EVENT_ARB :: GLenum+gl_SYNC_CL_EVENT_ARB = 0x8240+gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE :: GLenum+gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8+gl_MAX_VERTEX_HINT_PGI :: GLenum+gl_MAX_VERTEX_HINT_PGI = 0x1A22D+gl_UNPACK_IMAGE_HEIGHT_EXT :: GLenum+gl_UNPACK_IMAGE_HEIGHT_EXT = 0x806E+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV :: GLenum+gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV = 0x8C4F+gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214+gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB :: GLenum+gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49+gl_STENCIL_BACK_REF :: GLenum+gl_STENCIL_BACK_REF = 0x8CA3+gl_CLAMP_READ_COLOR_ARB :: GLenum+gl_CLAMP_READ_COLOR_ARB = 0x891C+gl_INTERNALFORMAT_RED_SIZE :: GLenum+gl_INTERNALFORMAT_RED_SIZE = 0x8271+gl_PATCH_DEFAULT_INNER_LEVEL_EXT :: GLenum+gl_PATCH_DEFAULT_INNER_LEVEL_EXT = 0x8E73+gl_OUTPUT_TEXTURE_COORD27_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD27_EXT = 0x87B8+gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD :: GLenum+gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD = 0x00000004+gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC+gl_LOCATION :: GLenum+gl_LOCATION = 0x930E+gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82+gl_POST_COLOR_MATRIX_GREEN_SCALE :: GLenum+gl_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9+gl_POST_COLOR_MATRIX_ALPHA_SCALE :: GLenum+gl_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7+gl_HORIZONTAL_LINE_TO_NV :: GLenum+gl_HORIZONTAL_LINE_TO_NV = 0x06+gl_MAX_FRAGMENT_INPUT_COMPONENTS :: GLenum+gl_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125+gl_PROGRAM_STRING_ARB :: GLenum+gl_PROGRAM_STRING_ARB = 0x8628+gl_EDGE_FLAG_ARRAY_ADDRESS_NV :: GLenum+gl_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26+gl_VENDOR :: GLenum+gl_VENDOR = 0x1F00+gl_CLIPPING_INPUT_PRIMITIVES_ARB :: GLenum+gl_CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6+gl_TEXTURE_RENDERBUFFER_NV :: GLenum+gl_TEXTURE_RENDERBUFFER_NV = 0x8E55+gl_ELEMENT_ARRAY_ADDRESS_NV :: GLenum+gl_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29+gl_LOCAL_EXT :: GLenum+gl_LOCAL_EXT = 0x87C4+gl_GEOMETRY_SHADER_INVOCATIONS :: GLenum+gl_GEOMETRY_SHADER_INVOCATIONS = 0x887F+gl_INT_VEC4_ARB :: GLenum+gl_INT_VEC4_ARB = 0x8B55+gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217+gl_SEPARATE_ATTRIBS_NV :: GLenum+gl_SEPARATE_ATTRIBS_NV = 0x8C8D+gl_FLOAT_MAT4_ARB :: GLenum+gl_FLOAT_MAT4_ARB = 0x8B5C+gl_COLOR_ATTACHMENT_EXT :: GLenum+gl_COLOR_ATTACHMENT_EXT = 0x90F0+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0+gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB :: GLenum+gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841+gl_SHININESS :: GLenum+gl_SHININESS = 0x1601+gl_INTERPOLATE_EXT :: GLenum+gl_INTERPOLATE_EXT = 0x8575+gl_TRANSFORM_FEEDBACK :: GLenum+gl_TRANSFORM_FEEDBACK = 0x8E22+gl_TEXTURE_DEPTH_QCOM :: GLenum+gl_TEXTURE_DEPTH_QCOM = 0x8BD4+gl_DOUBLE_MAT4x2 :: GLenum+gl_DOUBLE_MAT4x2 = 0x8F4D+gl_NORMAL_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897+gl_PIXEL_TEX_GEN_SGIX :: GLenum+gl_PIXEL_TEX_GEN_SGIX = 0x8139+gl_TRANSFORM_FEEDBACK_BUFFER_START :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84+gl_GLYPH_WIDTH_BIT_NV :: GLenum+gl_GLYPH_WIDTH_BIT_NV = 0x01+gl_STENCIL_ATTACHMENT_EXT :: GLenum+gl_STENCIL_ATTACHMENT_EXT = 0x8D20+gl_VERTEX_ARRAY_RANGE_POINTER_APPLE :: GLenum+gl_VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521+gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT :: GLenum+gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E+gl_MATRIX4_NV :: GLenum+gl_MATRIX4_NV = 0x8634+gl_READ_FRAMEBUFFER_ANGLE :: GLenum+gl_READ_FRAMEBUFFER_ANGLE = 0x8CA8+gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS :: GLenum+gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS = 0x919A+gl_VERTEX_ARRAY_POINTER_EXT :: GLenum+gl_VERTEX_ARRAY_POINTER_EXT = 0x808E+gl_RELATIVE_ROUNDED_RECT_NV :: GLenum+gl_RELATIVE_ROUNDED_RECT_NV = 0xE9+gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV :: GLenum+gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11+gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV :: GLenum+gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5+gl_TEXTURE_MEMORY_LAYOUT_INTEL :: GLenum+gl_TEXTURE_MEMORY_LAYOUT_INTEL = 0x83FF+gl_REG_0_ATI :: GLenum+gl_REG_0_ATI = 0x8921+gl_VERTEX_ATTRIB_ARRAY15_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY15_NV = 0x865F+gl_RGB12_EXT :: GLenum+gl_RGB12_EXT = 0x8053+gl_FRAGMENT_LIGHT6_SGIX :: GLenum+gl_FRAGMENT_LIGHT6_SGIX = 0x8412+gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV :: GLenum+gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908+gl_QUERY_ALL_EVENT_BITS_AMD :: GLenum+gl_QUERY_ALL_EVENT_BITS_AMD = 0xFFFFFFFF+gl_INTENSITY_FLOAT32_APPLE :: GLenum+gl_INTENSITY_FLOAT32_APPLE = 0x8817+gl_LIST_INDEX :: GLenum+gl_LIST_INDEX = 0x0B33+gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG :: GLenum+gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01+gl_REG_18_ATI :: GLenum+gl_REG_18_ATI = 0x8933+gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum+gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9061+gl_COMPILE :: GLenum+gl_COMPILE = 0x1300+gl_VIEW_CLASS_128_BITS :: GLenum+gl_VIEW_CLASS_128_BITS = 0x82C4+gl_4X_BIT_ATI :: GLenum+gl_4X_BIT_ATI = 0x00000002+gl_CLIENT_PIXEL_STORE_BIT :: GLenum+gl_CLIENT_PIXEL_STORE_BIT = 0x00000001+gl_OPERAND2_RGB :: GLenum+gl_OPERAND2_RGB = 0x8592+gl_MINMAX_FORMAT_EXT :: GLenum+gl_MINMAX_FORMAT_EXT = 0x802F+gl_UNSIGNED_INT_IMAGE_1D :: GLenum+gl_UNSIGNED_INT_IMAGE_1D = 0x9062+gl_INSTRUMENT_MEASUREMENTS_SGIX :: GLenum+gl_INSTRUMENT_MEASUREMENTS_SGIX = 0x8181+gl_VALIDATE_STATUS :: GLenum+gl_VALIDATE_STATUS = 0x8B83+gl_NORMAL_ARRAY_COUNT_EXT :: GLenum+gl_NORMAL_ARRAY_COUNT_EXT = 0x8080+gl_PATH_STENCIL_REF_NV :: GLenum+gl_PATH_STENCIL_REF_NV = 0x90B8+gl_DRAW_BUFFER5_NV :: GLenum+gl_DRAW_BUFFER5_NV = 0x882A+gl_COMPRESSED_RGBA_ARB :: GLenum+gl_COMPRESSED_RGBA_ARB = 0x84EE+gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV :: GLenum+gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11+gl_MAX_3D_TEXTURE_SIZE :: GLenum+gl_MAX_3D_TEXTURE_SIZE = 0x8073+gl_FRAGMENT_NORMAL_EXT :: GLenum+gl_FRAGMENT_NORMAL_EXT = 0x834A+gl_SHADER_KHR :: GLenum+gl_SHADER_KHR = 0x82E1+gl_TEXTURE_DEPTH_TYPE :: GLenum+gl_TEXTURE_DEPTH_TYPE = 0x8C16+gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA :: GLenum+gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB6+gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE :: GLenum+gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE = 0x93A0+gl_TEXTURE_2D_STACK_BINDING_MESAX :: GLenum+gl_TEXTURE_2D_STACK_BINDING_MESAX = 0x875E+gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB :: GLenum+gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2+gl_INT_SAMPLER_2D_EXT :: GLenum+gl_INT_SAMPLER_2D_EXT = 0x8DCA+gl_RGBA4_S3TC :: GLenum+gl_RGBA4_S3TC = 0x83A3+gl_MAX_SPOT_EXPONENT_NV :: GLenum+gl_MAX_SPOT_EXPONENT_NV = 0x8505+gl_NEGATIVE_X_EXT :: GLenum+gl_NEGATIVE_X_EXT = 0x87D9+gl_SYNC_X11_FENCE_EXT :: GLenum+gl_SYNC_X11_FENCE_EXT = 0x90E1+gl_OP_DOT3_EXT :: GLenum+gl_OP_DOT3_EXT = 0x8784+gl_LUMINANCE8_SNORM :: GLenum+gl_LUMINANCE8_SNORM = 0x9015+gl_SAMPLE_SHADING_ARB :: GLenum+gl_SAMPLE_SHADING_ARB = 0x8C36+gl_CONVOLUTION_2D_EXT :: GLenum+gl_CONVOLUTION_2D_EXT = 0x8011+gl_MAP2_TEXTURE_COORD_2 :: GLenum+gl_MAP2_TEXTURE_COORD_2 = 0x0DB4+gl_SHADER_IMAGE_LOAD :: GLenum+gl_SHADER_IMAGE_LOAD = 0x82A4+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85+gl_TEXTURE_VIEW_NUM_LEVELS_EXT :: GLenum+gl_TEXTURE_VIEW_NUM_LEVELS_EXT = 0x82DC+gl_ACTIVE_UNIFORMS :: GLenum+gl_ACTIVE_UNIFORMS = 0x8B86+gl_ACCUM_GREEN_BITS :: GLenum+gl_ACCUM_GREEN_BITS = 0x0D59+gl_TESS_EVALUATION_PROGRAM_NV :: GLenum+gl_TESS_EVALUATION_PROGRAM_NV = 0x891F+gl_COMPRESSED_SLUMINANCE :: GLenum+gl_COMPRESSED_SLUMINANCE = 0x8C4A+gl_COLOR_ATTACHMENT14_EXT :: GLenum+gl_COLOR_ATTACHMENT14_EXT = 0x8CEE+gl_VERTEX23_BIT_PGI :: GLenum+gl_VERTEX23_BIT_PGI = 0x00000004+gl_BUMP_ROT_MATRIX_ATI :: GLenum+gl_BUMP_ROT_MATRIX_ATI = 0x8775+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56+gl_MAX_PALETTE_MATRICES_OES :: GLenum+gl_MAX_PALETTE_MATRICES_OES = 0x8842+gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV :: GLenum+gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 0x9036+gl_CONVOLUTION_BORDER_MODE_EXT :: GLenum+gl_CONVOLUTION_BORDER_MODE_EXT = 0x8013+gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE :: GLenum+gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = 0x8A05+gl_INTENSITY32I_EXT :: GLenum+gl_INTENSITY32I_EXT = 0x8D85+gl_RASTERIZER_DISCARD_EXT :: GLenum+gl_RASTERIZER_DISCARD_EXT = 0x8C89+gl_MAX_SAMPLES_EXT :: GLenum+gl_MAX_SAMPLES_EXT = 0x8D57+gl_DRAW_BUFFER10_EXT :: GLenum+gl_DRAW_BUFFER10_EXT = 0x882F+gl_INT_IMAGE_2D :: GLenum+gl_INT_IMAGE_2D = 0x9058+gl_PROVOKING_VERTEX :: GLenum+gl_PROVOKING_VERTEX = 0x8E4F+gl_UNPACK_RESAMPLE_SGIX :: GLenum+gl_UNPACK_RESAMPLE_SGIX = 0x842D+gl_SAMPLE_POSITION_NV :: GLenum+gl_SAMPLE_POSITION_NV = 0x8E50+gl_MAX_PROGRAM_MATRICES_ARB :: GLenum+gl_MAX_PROGRAM_MATRICES_ARB = 0x862F+gl_SHADER_STORAGE_BUFFER_BINDING :: GLenum+gl_SHADER_STORAGE_BUFFER_BINDING = 0x90D3+gl_TEXTURE0 :: GLenum+gl_TEXTURE0 = 0x84C0+gl_DSDT_MAG_VIB_NV :: GLenum+gl_DSDT_MAG_VIB_NV = 0x86F7+gl_DOUBLE_MAT4x3 :: GLenum+gl_DOUBLE_MAT4x3 = 0x8F4E+gl_TEXTURE27_ARB :: GLenum+gl_TEXTURE27_ARB = 0x84DB+gl_ACTIVE_ATOMIC_COUNTER_BUFFERS :: GLenum+gl_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9+gl_LUMINANCE32I_EXT :: GLenum+gl_LUMINANCE32I_EXT = 0x8D86+gl_SAMPLER_KHR :: GLenum+gl_SAMPLER_KHR = 0x82E6+gl_MITER_REVERT_NV :: GLenum+gl_MITER_REVERT_NV = 0x90A7+gl_RGB32UI_EXT :: GLenum+gl_RGB32UI_EXT = 0x8D71+gl_DUAL_LUMINANCE12_SGIS :: GLenum+gl_DUAL_LUMINANCE12_SGIS = 0x8116+gl_BOOL_VEC2 :: GLenum+gl_BOOL_VEC2 = 0x8B57+gl_COLOR_ATTACHMENT1_NV :: GLenum+gl_COLOR_ATTACHMENT1_NV = 0x8CE1+gl_MAX_CONVOLUTION_WIDTH :: GLenum+gl_MAX_CONVOLUTION_WIDTH = 0x801A+gl_DRAW_BUFFER14_NV :: GLenum+gl_DRAW_BUFFER14_NV = 0x8833+gl_BLEND_DST_RGB_EXT :: GLenum+gl_BLEND_DST_RGB_EXT = 0x80C8+gl_LUMINANCE12_ALPHA12_EXT :: GLenum+gl_LUMINANCE12_ALPHA12_EXT = 0x8047+gl_DEPTH_BOUNDS_EXT :: GLenum+gl_DEPTH_BOUNDS_EXT = 0x8891+gl_CIRCULAR_CCW_ARC_TO_NV :: GLenum+gl_CIRCULAR_CCW_ARC_TO_NV = 0xF8+gl_COMPRESSED_LUMINANCE_ALPHA :: GLenum+gl_COMPRESSED_LUMINANCE_ALPHA = 0x84EB+gl_SAMPLE_COVERAGE_VALUE_ARB :: GLenum+gl_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA+gl_DEPTH_STENCIL_TO_RGBA_NV :: GLenum+gl_DEPTH_STENCIL_TO_RGBA_NV = 0x886E+gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING :: GLenum+gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C+gl_NAME_LENGTH :: GLenum+gl_NAME_LENGTH = 0x92F9+gl_STENCIL_TEST_TWO_SIDE_EXT :: GLenum+gl_STENCIL_TEST_TWO_SIDE_EXT = 0x8910+gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum+gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898D+gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624+gl_OUTPUT_TEXTURE_COORD30_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD30_EXT = 0x87BB+gl_MAX_PROGRAM_SUBROUTINE_NUM_NV :: GLenum+gl_MAX_PROGRAM_SUBROUTINE_NUM_NV = 0x8F45+gl_MULTIPLY_NV :: GLenum+gl_MULTIPLY_NV = 0x9294+gl_TEXTURE19 :: GLenum+gl_TEXTURE19 = 0x84D3+gl_INVERT_OVG_NV :: GLenum+gl_INVERT_OVG_NV = 0x92B4+gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES :: GLenum+gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B+gl_NEAREST_CLIPMAP_LINEAR_SGIX :: GLenum+gl_NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E+gl_VARIABLE_A_NV :: GLenum+gl_VARIABLE_A_NV = 0x8523+gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT :: GLenum+gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71+gl_TEXTURE_2D_MULTISAMPLE :: GLenum+gl_TEXTURE_2D_MULTISAMPLE = 0x9100+gl_DEBUG_SOURCE_THIRD_PARTY :: GLenum+gl_DEBUG_SOURCE_THIRD_PARTY = 0x8249+gl_DRAW_BUFFER7_ARB :: GLenum+gl_DRAW_BUFFER7_ARB = 0x882C+gl_MAX_DRAW_BUFFERS :: GLenum+gl_MAX_DRAW_BUFFERS = 0x8824+gl_MAX_SERVER_WAIT_TIMEOUT :: GLenum+gl_MAX_SERVER_WAIT_TIMEOUT = 0x9111+gl_COMPRESSED_SIGNED_RG11_EAC :: GLenum+gl_COMPRESSED_SIGNED_RG11_EAC = 0x9273+gl_VERTEX_PROGRAM_POINT_SIZE :: GLenum+gl_VERTEX_PROGRAM_POINT_SIZE = 0x8642+gl_STENCIL_PASS_DEPTH_PASS :: GLenum+gl_STENCIL_PASS_DEPTH_PASS = 0x0B96+gl_RENDERBUFFER_STENCIL_SIZE :: GLenum+gl_RENDERBUFFER_STENCIL_SIZE = 0x8D55+gl_TEXTURE_BINDING_2D :: GLenum+gl_TEXTURE_BINDING_2D = 0x8069+gl_DATA_BUFFER_AMD :: GLenum+gl_DATA_BUFFER_AMD = 0x9151+gl_DEBUG_CATEGORY_APPLICATION_AMD :: GLenum+gl_DEBUG_CATEGORY_APPLICATION_AMD = 0x914F+gl_ASYNC_HISTOGRAM_SGIX :: GLenum+gl_ASYNC_HISTOGRAM_SGIX = 0x832C+gl_UNPACK_LSB_FIRST :: GLenum+gl_UNPACK_LSB_FIRST = 0x0CF1+gl_UNSIGNED_INT_SAMPLER_CUBE_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4+gl_DEPTH_CLAMP_FAR_AMD :: GLenum+gl_DEPTH_CLAMP_FAR_AMD = 0x901F+gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F+gl_VERTEX_ATTRIB_ARRAY_STRIDE :: GLenum+gl_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624+gl_UNSIGNED_INT16_VEC4_NV :: GLenum+gl_UNSIGNED_INT16_VEC4_NV = 0x8FF3+gl_OBJECT_BUFFER_SIZE_ATI :: GLenum+gl_OBJECT_BUFFER_SIZE_ATI = 0x8764+gl_YCRCB_444_SGIX :: GLenum+gl_YCRCB_444_SGIX = 0x81BC+gl_LOSE_CONTEXT_ON_RESET_KHR :: GLenum+gl_LOSE_CONTEXT_ON_RESET_KHR = 0x8252+gl_TEXTURE_VIEW_NUM_LAYERS :: GLenum+gl_TEXTURE_VIEW_NUM_LAYERS = 0x82DE+gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB :: GLenum+gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D+gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC+gl_OBJECT_DELETE_STATUS_ARB :: GLenum+gl_OBJECT_DELETE_STATUS_ARB = 0x8B80+gl_SQUARE_NV :: GLenum+gl_SQUARE_NV = 0x90A3+gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT :: GLenum+gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT = 0x8E81+gl_DEBUG_SEVERITY_NOTIFICATION_KHR :: GLenum+gl_DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B+gl_EYE_LINEAR_NV :: GLenum+gl_EYE_LINEAR_NV = 0x2400+gl_REG_16_ATI :: GLenum+gl_REG_16_ATI = 0x8931+gl_LUMINANCE_ALPHA32UI_EXT :: GLenum+gl_LUMINANCE_ALPHA32UI_EXT = 0x8D75+gl_OUTPUT_TEXTURE_COORD31_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD31_EXT = 0x87BC+gl_COMPRESSED_RG_RGTC2 :: GLenum+gl_COMPRESSED_RG_RGTC2 = 0x8DBD+gl_FLOAT_MAT3 :: GLenum+gl_FLOAT_MAT3 = 0x8B5B+gl_INDEX_ARRAY_POINTER :: GLenum+gl_INDEX_ARRAY_POINTER = 0x8091+gl_FOG_COORD :: GLenum+gl_FOG_COORD = 0x8451+gl_DRAW_BUFFER13 :: GLenum+gl_DRAW_BUFFER13 = 0x8832+gl_SCALED_RESOLVE_NICEST_EXT :: GLenum+gl_SCALED_RESOLVE_NICEST_EXT = 0x90BB+gl_QUERY_RESULT_AVAILABLE :: GLenum+gl_QUERY_RESULT_AVAILABLE = 0x8867+gl_UNPACK_SUBSAMPLE_RATE_SGIX :: GLenum+gl_UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1+gl_3_BYTES_NV :: GLenum+gl_3_BYTES_NV = 0x1408+gl_CLEAR :: GLenum+gl_CLEAR = 0x1500+gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum+gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CD+gl_R8UI :: GLenum+gl_R8UI = 0x8232+gl_OFFSET_TEXTURE_2D_MATRIX_NV :: GLenum+gl_OFFSET_TEXTURE_2D_MATRIX_NV = 0x86E1+gl_BGRA_INTEGER :: GLenum+gl_BGRA_INTEGER = 0x8D9B+gl_MAX_ARRAY_TEXTURE_LAYERS :: GLenum+gl_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF+gl_COMPRESSED_RGB_ARB :: GLenum+gl_COMPRESSED_RGB_ARB = 0x84ED+gl_FOG_COORDINATE_ARRAY_POINTER_EXT :: GLenum+gl_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456+gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT :: GLenum+gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 0x00000020+gl_TEXTURE_MAG_FILTER :: GLenum+gl_TEXTURE_MAG_FILTER = 0x2800+gl_DEPTH_COMPONENT32 :: GLenum+gl_DEPTH_COMPONENT32 = 0x81A7+gl_VIEW_CLASS_S3TC_DXT1_RGB :: GLenum+gl_VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC+gl_FRONT_RIGHT :: GLenum+gl_FRONT_RIGHT = 0x0401+gl_HISTOGRAM_WIDTH :: GLenum+gl_HISTOGRAM_WIDTH = 0x8026+gl_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum+gl_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C+gl_WEIGHT_ARRAY_STRIDE_OES :: GLenum+gl_WEIGHT_ARRAY_STRIDE_OES = 0x86AA+gl_PIXEL_PACK_BUFFER_ARB :: GLenum+gl_PIXEL_PACK_BUFFER_ARB = 0x88EB+gl_DOT_PRODUCT_PASS_THROUGH_NV :: GLenum+gl_DOT_PRODUCT_PASS_THROUGH_NV = 0x885B+gl_COMPRESSED_RG11_EAC :: GLenum+gl_COMPRESSED_RG11_EAC = 0x9272+gl_SRGB_DECODE_ARB :: GLenum+gl_SRGB_DECODE_ARB = 0x8299+gl_OP_SUB_EXT :: GLenum+gl_OP_SUB_EXT = 0x8796+gl_SLIM12S_SGIX :: GLenum+gl_SLIM12S_SGIX = 0x831F+gl_SECONDARY_COLOR_NV :: GLenum+gl_SECONDARY_COLOR_NV = 0x852D+gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS :: GLenum+gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA+gl_MAP1_VERTEX_3 :: GLenum+gl_MAP1_VERTEX_3 = 0x0D97+gl_RELATIVE_ROUNDED_RECT8_NV :: GLenum+gl_RELATIVE_ROUNDED_RECT8_NV = 0xEF+gl_PALETTE4_R5_G6_B5_OES :: GLenum+gl_PALETTE4_R5_G6_B5_OES = 0x8B92+gl_UNSIGNED_INT8_NV :: GLenum+gl_UNSIGNED_INT8_NV = 0x8FEC+gl_CURRENT_MATRIX_STACK_DEPTH_ARB :: GLenum+gl_CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640+gl_PIXEL_MODE_BIT :: GLenum+gl_PIXEL_MODE_BIT = 0x00000020+gl_FONT_UNINTELLIGIBLE_NV :: GLenum+gl_FONT_UNINTELLIGIBLE_NV = 0x936B+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6+gl_LUMINANCE8UI_EXT :: GLenum+gl_LUMINANCE8UI_EXT = 0x8D80+gl_HILO16_NV :: GLenum+gl_HILO16_NV = 0x86F8+gl_MAP2_VERTEX_ATTRIB8_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB8_4_NV = 0x8678+gl_ATTACHED_SHADERS :: GLenum+gl_ATTACHED_SHADERS = 0x8B85+gl_OBJECT_POINT_SGIS :: GLenum+gl_OBJECT_POINT_SGIS = 0x81F5+gl_TEXTURE_CUBE_MAP_SEAMLESS :: GLenum+gl_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F+gl_COLOR_ATTACHMENT0 :: GLenum+gl_COLOR_ATTACHMENT0 = 0x8CE0+gl_POST_CONVOLUTION_ALPHA_BIAS_EXT :: GLenum+gl_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023+gl_SAMPLE_PATTERN_SGIS :: GLenum+gl_SAMPLE_PATTERN_SGIS = 0x80AC+gl_COPY_PIXEL_TOKEN :: GLenum+gl_COPY_PIXEL_TOKEN = 0x0706+gl_BUFFER_SIZE_ARB :: GLenum+gl_BUFFER_SIZE_ARB = 0x8764+gl_DEPTH_BOUNDS_TEST_EXT :: GLenum+gl_DEPTH_BOUNDS_TEST_EXT = 0x8890+gl_SAMPLE_POSITION :: GLenum+gl_SAMPLE_POSITION = 0x8E50+gl_FULL_STIPPLE_HINT_PGI :: GLenum+gl_FULL_STIPPLE_HINT_PGI = 0x1A219+gl_DEBUG_ASSERT_MESA :: GLenum+gl_DEBUG_ASSERT_MESA = 0x875B+gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB :: GLenum+gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A+gl_RENDERBUFFER_WIDTH_OES :: GLenum+gl_RENDERBUFFER_WIDTH_OES = 0x8D42+gl_FLOAT_RGBA16_NV :: GLenum+gl_FLOAT_RGBA16_NV = 0x888A+gl_MODELVIEW5_ARB :: GLenum+gl_MODELVIEW5_ARB = 0x8725+gl_VERSION :: GLenum+gl_VERSION = 0x1F02+gl_TEXTURE17_ARB :: GLenum+gl_TEXTURE17_ARB = 0x84D1+gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT :: GLenum+gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8A32+gl_MODELVIEW0_STACK_DEPTH_EXT :: GLenum+gl_MODELVIEW0_STACK_DEPTH_EXT = 0x0BA3+gl_OUTPUT_TEXTURE_COORD1_EXT :: GLenum+gl_OUTPUT_TEXTURE_COORD1_EXT = 0x879E+gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES :: GLenum+gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES = 0x8D68+gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX :: GLenum+gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408+gl_IMAGE_TRANSFORM_2D_HP :: GLenum+gl_IMAGE_TRANSFORM_2D_HP = 0x8161+gl_HSL_SATURATION_NV :: GLenum+gl_HSL_SATURATION_NV = 0x92AE+gl_UNSIGNED_SHORT_5_6_5_REV :: GLenum+gl_UNSIGNED_SHORT_5_6_5_REV = 0x8364+gl_LINEAR_CLIPMAP_NEAREST_SGIX :: GLenum+gl_LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F+gl_PREVIOUS_ARB :: GLenum+gl_PREVIOUS_ARB = 0x8578+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4+gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1+gl_SLUMINANCE8_EXT :: GLenum+gl_SLUMINANCE8_EXT = 0x8C47+gl_RGBA16F_ARB :: GLenum+gl_RGBA16F_ARB = 0x881A+gl_PIXEL_UNPACK_BUFFER_ARB :: GLenum+gl_PIXEL_UNPACK_BUFFER_ARB = 0x88EC+gl_STENCIL_REF :: GLenum+gl_STENCIL_REF = 0x0B97+gl_TEXTURE_VIEW_MIN_LAYER_EXT :: GLenum+gl_TEXTURE_VIEW_MIN_LAYER_EXT = 0x82DD+gl_HISTOGRAM_RED_SIZE :: GLenum+gl_HISTOGRAM_RED_SIZE = 0x8028+gl_CLIP_PLANE1 :: GLenum+gl_CLIP_PLANE1 = 0x3001+gl_UNKNOWN_CONTEXT_RESET_ARB :: GLenum+gl_UNKNOWN_CONTEXT_RESET_ARB = 0x8255+gl_CMYK_EXT :: GLenum+gl_CMYK_EXT = 0x800C+gl_TEXTURE_COMPRESSED_BLOCK_SIZE :: GLenum+gl_TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3+gl_RGBA8I :: GLenum+gl_RGBA8I = 0x8D8E+gl_TEXTURE29_ARB :: GLenum+gl_TEXTURE29_ARB = 0x84DD+gl_STENCIL_BUFFER_BIT2_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT2_QCOM = 0x00040000+gl_RED_MIN_CLAMP_INGR :: GLenum+gl_RED_MIN_CLAMP_INGR = 0x8560+gl_ATC_RGBA_EXPLICIT_ALPHA_AMD :: GLenum+gl_ATC_RGBA_EXPLICIT_ALPHA_AMD = 0x8C93+gl_ALL_COMPLETED_NV :: GLenum+gl_ALL_COMPLETED_NV = 0x84F2+gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum+gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5+gl_MATRIX10_ARB :: GLenum+gl_MATRIX10_ARB = 0x88CA+gl_MAP1_VERTEX_ATTRIB1_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB1_4_NV = 0x8661+gl_MAX_4D_TEXTURE_SIZE_SGIS :: GLenum+gl_MAX_4D_TEXTURE_SIZE_SGIS = 0x8138+gl_VIEW_CLASS_32_BITS :: GLenum+gl_VIEW_CLASS_32_BITS = 0x82C8+gl_TEXTURE7_ARB :: GLenum+gl_TEXTURE7_ARB = 0x84C7+gl_DEBUG_TYPE_PERFORMANCE_ARB :: GLenum+gl_DEBUG_TYPE_PERFORMANCE_ARB = 0x8250+gl_ACTIVE_VARIABLES :: GLenum+gl_ACTIVE_VARIABLES = 0x9305+gl_SOURCE2_RGB_EXT :: GLenum+gl_SOURCE2_RGB_EXT = 0x8582+gl_PACK_INVERT_MESA :: GLenum+gl_PACK_INVERT_MESA = 0x8758+gl_QUERY_BY_REGION_WAIT_NV :: GLenum+gl_QUERY_BY_REGION_WAIT_NV = 0x8E15+gl_VERTEX_ID_SWIZZLE_AMD :: GLenum+gl_VERTEX_ID_SWIZZLE_AMD = 0x91A5+gl_SPRITE_TRANSLATION_SGIX :: GLenum+gl_SPRITE_TRANSLATION_SGIX = 0x814B+gl_RENDERBUFFER_HEIGHT :: GLenum+gl_RENDERBUFFER_HEIGHT = 0x8D43+gl_CUBIC_EXT :: GLenum+gl_CUBIC_EXT = 0x8334+gl_TEXTURE19_ARB :: GLenum+gl_TEXTURE19_ARB = 0x84D3+gl_T2F_N3F_V3F :: GLenum+gl_T2F_N3F_V3F = 0x2A2B+gl_ATOMIC_COUNTER_BARRIER_BIT_EXT :: GLenum+gl_ATOMIC_COUNTER_BARRIER_BIT_EXT = 0x00001000+gl_ARRAY_ELEMENT_LOCK_FIRST_EXT :: GLenum+gl_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8+gl_PROGRAM_RESULT_COMPONENTS_NV :: GLenum+gl_PROGRAM_RESULT_COMPONENTS_NV = 0x8907+gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB :: GLenum+gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8+gl_TRIANGLE_MESH_SUN :: GLenum+gl_TRIANGLE_MESH_SUN = 0x8615+gl_TEXTURE_WRAP_Q_SGIS :: GLenum+gl_TEXTURE_WRAP_Q_SGIS = 0x8137+gl_ATTRIB_ARRAY_SIZE_NV :: GLenum+gl_ATTRIB_ARRAY_SIZE_NV = 0x8623+gl_DEBUG_LOGGED_MESSAGES_AMD :: GLenum+gl_DEBUG_LOGGED_MESSAGES_AMD = 0x9145+gl_BOOL :: GLenum+gl_BOOL = 0x8B56+gl_MIN_LOD_WARNING_AMD :: GLenum+gl_MIN_LOD_WARNING_AMD = 0x919C+gl_PACK_SKIP_PIXELS :: GLenum+gl_PACK_SKIP_PIXELS = 0x0D04+gl_IMAGE_TEXEL_SIZE :: GLenum+gl_IMAGE_TEXEL_SIZE = 0x82A7+gl_SRC_ALPHA :: GLenum+gl_SRC_ALPHA = 0x0302+gl_DEPENDENT_HILO_TEXTURE_2D_NV :: GLenum+gl_DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858+gl_FRAMEBUFFER_ATTACHMENT_LAYERED :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7+gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1+gl_VERTEX_ARRAY_RANGE_LENGTH_NV :: GLenum+gl_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E+gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS :: GLenum+gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9+gl_POST_CONVOLUTION_GREEN_SCALE :: GLenum+gl_POST_CONVOLUTION_GREEN_SCALE = 0x801D+gl_SEPARATE_ATTRIBS :: GLenum+gl_SEPARATE_ATTRIBS = 0x8C8D+gl_UNSIGNED_BYTE_3_3_2 :: GLenum+gl_UNSIGNED_BYTE_3_3_2 = 0x8032+gl_SCALAR_EXT :: GLenum+gl_SCALAR_EXT = 0x87BE+gl_POINT_SIZE_ARRAY_STRIDE_OES :: GLenum+gl_POINT_SIZE_ARRAY_STRIDE_OES = 0x898B+gl_DOUBLE_MAT3x4 :: GLenum+gl_DOUBLE_MAT3x4 = 0x8F4C+gl_SRC0_RGB :: GLenum+gl_SRC0_RGB = 0x8580+gl_VIEW_CLASS_BPTC_UNORM :: GLenum+gl_VIEW_CLASS_BPTC_UNORM = 0x82D2+gl_SYNC_FLAGS :: GLenum+gl_SYNC_FLAGS = 0x9115+gl_TEXTURE_SWIZZLE_RGBA_EXT :: GLenum+gl_TEXTURE_SWIZZLE_RGBA_EXT = 0x8E46+gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX :: GLenum+gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C+gl_TEXTURE29 :: GLenum+gl_TEXTURE29 = 0x84DD+gl_MEDIUM_INT :: GLenum+gl_MEDIUM_INT = 0x8DF4+gl_CURRENT_QUERY_ARB :: GLenum+gl_CURRENT_QUERY_ARB = 0x8865+gl_DT_SCALE_NV :: GLenum+gl_DT_SCALE_NV = 0x8711+gl_CLAMP_VERTEX_COLOR_ARB :: GLenum+gl_CLAMP_VERTEX_COLOR_ARB = 0x891A+gl_DEPTH_BUFFER_BIT4_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT4_QCOM = 0x00001000+gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: GLenum+gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277+gl_USE_MISSING_GLYPH_NV :: GLenum+gl_USE_MISSING_GLYPH_NV = 0x90AA+gl_MAX_ASYNC_TEX_IMAGE_SGIX :: GLenum+gl_MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F+gl_TESS_CONTROL_TEXTURE :: GLenum+gl_TESS_CONTROL_TEXTURE = 0x829C+gl_DEPTH_FUNC :: GLenum+gl_DEPTH_FUNC = 0x0B74+gl_RG8I :: GLenum+gl_RG8I = 0x8237+gl_MAX_VERTEX_SHADER_VARIANTS_EXT :: GLenum+gl_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6+gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB :: GLenum+gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2+gl_COMPRESSED_SRGB :: GLenum+gl_COMPRESSED_SRGB = 0x8C48+gl_PROGRAM_BINDING_ARB :: GLenum+gl_PROGRAM_BINDING_ARB = 0x8677+gl_SAMPLER_2D_ARRAY :: GLenum+gl_SAMPLER_2D_ARRAY = 0x8DC1+gl_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum+gl_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054+gl_BUFFER_ACCESS_FLAGS :: GLenum+gl_BUFFER_ACCESS_FLAGS = 0x911F+gl_EIGHTH_BIT_ATI :: GLenum+gl_EIGHTH_BIT_ATI = 0x00000020+gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV :: GLenum+gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868+gl_INT8_VEC4_NV :: GLenum+gl_INT8_VEC4_NV = 0x8FE3+gl_CLEAR_TEXTURE :: GLenum+gl_CLEAR_TEXTURE = 0x9365+gl_TEXTURE_CUBE_MAP_OES :: GLenum+gl_TEXTURE_CUBE_MAP_OES = 0x8513+gl_FONT_NUM_GLYPH_INDICES_BIT_NV :: GLenum+gl_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000+gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV :: GLenum+gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520+gl_RENDERBUFFER_DEPTH_SIZE :: GLenum+gl_RENDERBUFFER_DEPTH_SIZE = 0x8D54+gl_DOT_PRODUCT_TEXTURE_1D_NV :: GLenum+gl_DOT_PRODUCT_TEXTURE_1D_NV = 0x885C+gl_DOUBLE_VEC3_EXT :: GLenum+gl_DOUBLE_VEC3_EXT = 0x8FFD+gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E+gl_TEXTURE_LUMINANCE_TYPE :: GLenum+gl_TEXTURE_LUMINANCE_TYPE = 0x8C14+gl_CONTEXT_FLAGS :: GLenum+gl_CONTEXT_FLAGS = 0x821E+gl_NORMAL_ARRAY_BUFFER_BINDING :: GLenum+gl_NORMAL_ARRAY_BUFFER_BINDING = 0x8897+gl_PROGRAM_FORMAT_ARB :: GLenum+gl_PROGRAM_FORMAT_ARB = 0x8876+gl_MOVE_TO_CONTINUES_NV :: GLenum+gl_MOVE_TO_CONTINUES_NV = 0x90B6+gl_LO_BIAS_NV :: GLenum+gl_LO_BIAS_NV = 0x8715+gl_CONVOLUTION_WIDTH_EXT :: GLenum+gl_CONVOLUTION_WIDTH_EXT = 0x8018+gl_FRAGMENT_TEXTURE :: GLenum+gl_FRAGMENT_TEXTURE = 0x829F+gl_NORMAL_BIT_PGI :: GLenum+gl_NORMAL_BIT_PGI = 0x08000000+gl_COMPRESSED_SIGNED_RG11_EAC_OES :: GLenum+gl_COMPRESSED_SIGNED_RG11_EAC_OES = 0x9273+gl_FIRST_VERTEX_CONVENTION :: GLenum+gl_FIRST_VERTEX_CONVENTION = 0x8E4D+gl_ROUNDED_RECT2_NV :: GLenum+gl_ROUNDED_RECT2_NV = 0xEA+gl_POST_COLOR_MATRIX_RED_BIAS :: GLenum+gl_POST_COLOR_MATRIX_RED_BIAS = 0x80B8+gl_UNIFORM_BUFFER :: GLenum+gl_UNIFORM_BUFFER = 0x8A11+gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT :: GLenum+gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336+gl_NUM_SAMPLE_COUNTS :: GLenum+gl_NUM_SAMPLE_COUNTS = 0x9380+gl_FOG_OFFSET_VALUE_SGIX :: GLenum+gl_FOG_OFFSET_VALUE_SGIX = 0x8199+gl_DIFFUSE :: GLenum+gl_DIFFUSE = 0x1201+gl_CLIP_PLANE5 :: GLenum+gl_CLIP_PLANE5 = 0x3005+gl_OUTPUT_FOG_EXT :: GLenum+gl_OUTPUT_FOG_EXT = 0x87BD+gl_PROGRAM_ATTRIB_COMPONENTS_NV :: GLenum+gl_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906+gl_RGBA_SIGNED_COMPONENTS_EXT :: GLenum+gl_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C+gl_COLOR_ARRAY_EXT :: GLenum+gl_COLOR_ARRAY_EXT = 0x8076+gl_PROXY_TEXTURE_1D_STACK_MESAX :: GLenum+gl_PROXY_TEXTURE_1D_STACK_MESAX = 0x875B+gl_TEXTURE_COORD_ARRAY_POINTER :: GLenum+gl_TEXTURE_COORD_ARRAY_POINTER = 0x8092+gl_MAX_COLOR_ATTACHMENTS :: GLenum+gl_MAX_COLOR_ATTACHMENTS = 0x8CDF+gl_TEXTURE28_ARB :: GLenum+gl_TEXTURE28_ARB = 0x84DC+gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX :: GLenum+gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403+gl_DEPTH24_STENCIL8_EXT :: GLenum+gl_DEPTH24_STENCIL8_EXT = 0x88F0+gl_MAX :: GLenum+gl_MAX = 0x8008+gl_MODELVIEW12_ARB :: GLenum+gl_MODELVIEW12_ARB = 0x872C+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES = 0x93E9+gl_PIXEL_MAP_I_TO_I_SIZE :: GLenum+gl_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0+gl_NORMAL_ARRAY_LIST_STRIDE_IBM :: GLenum+gl_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081+gl_SOURCE3_RGB_NV :: GLenum+gl_SOURCE3_RGB_NV = 0x8583+gl_ALPHA12_EXT :: GLenum+gl_ALPHA12_EXT = 0x803D+gl_STREAM_COPY_ARB :: GLenum+gl_STREAM_COPY_ARB = 0x88E2+gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI :: GLenum+gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802+gl_FRAGMENT_SUBROUTINE_UNIFORM :: GLenum+gl_FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2+gl_IS_ROW_MAJOR :: GLenum+gl_IS_ROW_MAJOR = 0x9300+gl_UNPACK_SKIP_IMAGES :: GLenum+gl_UNPACK_SKIP_IMAGES = 0x806D+gl_NUM_GENERAL_COMBINERS_NV :: GLenum+gl_NUM_GENERAL_COMBINERS_NV = 0x854E+gl_STENCIL_CLEAR_TAG_VALUE_EXT :: GLenum+gl_STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: GLenum+gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29+gl_DRAW_BUFFER12_ARB :: GLenum+gl_DRAW_BUFFER12_ARB = 0x8831+gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV :: GLenum+gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850+gl_VERTEX_ARRAY_OBJECT_EXT :: GLenum+gl_VERTEX_ARRAY_OBJECT_EXT = 0x9154+gl_PN_TRIANGLES_NORMAL_MODE_ATI :: GLenum+gl_PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3+gl_C4UB_V3F :: GLenum+gl_C4UB_V3F = 0x2A23+gl_REPEAT :: GLenum+gl_REPEAT = 0x2901+gl_MAX_SAMPLE_MASK_WORDS_NV :: GLenum+gl_MAX_SAMPLE_MASK_WORDS_NV = 0x8E59+gl_STORAGE_SHARED_APPLE :: GLenum+gl_STORAGE_SHARED_APPLE = 0x85BF+gl_TEXTURE9_ARB :: GLenum+gl_TEXTURE9_ARB = 0x84C9+gl_QUERY_BUFFER_BINDING :: GLenum+gl_QUERY_BUFFER_BINDING = 0x9193+gl_UNSIGNED_SHORT_8_8_REV_APPLE :: GLenum+gl_UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB+gl_MAX_FRAGMENT_UNIFORM_VECTORS :: GLenum+gl_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD+gl_UNDEFINED_APPLE :: GLenum+gl_UNDEFINED_APPLE = 0x8A1C+gl_TABLE_TOO_LARGE_EXT :: GLenum+gl_TABLE_TOO_LARGE_EXT = 0x8031+gl_MAX_TESS_PATCH_COMPONENTS_EXT :: GLenum+gl_MAX_TESS_PATCH_COMPONENTS_EXT = 0x8E84+gl_XOR_NV :: GLenum+gl_XOR_NV = 0x1506+gl_MAX_SHADER_BUFFER_ADDRESS_NV :: GLenum+gl_MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35+gl_DEBUG_SOURCE_WINDOW_SYSTEM :: GLenum+gl_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247+gl_UNSIGNALED_APPLE :: GLenum+gl_UNSIGNALED_APPLE = 0x9118+gl_SIGNED_LUMINANCE_NV :: GLenum+gl_SIGNED_LUMINANCE_NV = 0x8701+gl_FOG_DISTANCE_MODE_NV :: GLenum+gl_FOG_DISTANCE_MODE_NV = 0x855A+gl_PN_TRIANGLES_POINT_MODE_ATI :: GLenum+gl_PN_TRIANGLES_POINT_MODE_ATI = 0x87F2+gl_GEOMETRY_SUBROUTINE_UNIFORM :: GLenum+gl_GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1+gl_NEGATIVE_Z_EXT :: GLenum+gl_NEGATIVE_Z_EXT = 0x87DB+gl_PIXEL_MAP_R_TO_R :: GLenum+gl_PIXEL_MAP_R_TO_R = 0x0C76+gl_OBJECT_LINK_STATUS_ARB :: GLenum+gl_OBJECT_LINK_STATUS_ARB = 0x8B82+gl_NUM_ACTIVE_VARIABLES :: GLenum+gl_NUM_ACTIVE_VARIABLES = 0x9304+gl_BUFFER_UPDATE_BARRIER_BIT_EXT :: GLenum+gl_BUFFER_UPDATE_BARRIER_BIT_EXT = 0x00000200+gl_IMAGE_CUBE_EXT :: GLenum+gl_IMAGE_CUBE_EXT = 0x9050+gl_RGB_INTEGER_EXT :: GLenum+gl_RGB_INTEGER_EXT = 0x8D98+gl_DRAW_BUFFER13_EXT :: GLenum+gl_DRAW_BUFFER13_EXT = 0x8832+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0+gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE :: GLenum+gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE = 0x9117+gl_RGB_SCALE :: GLenum+gl_RGB_SCALE = 0x8573+gl_DOUBLE_MAT3x4_EXT :: GLenum+gl_DOUBLE_MAT3x4_EXT = 0x8F4C+gl_EXP :: GLenum+gl_EXP = 0x0800+gl_PERFMON_RESULT_AVAILABLE_AMD :: GLenum+gl_PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4+gl_STENCIL_VALUE_MASK :: GLenum+gl_STENCIL_VALUE_MASK = 0x0B93+gl_COLOR_ATTACHMENT12_NV :: GLenum+gl_COLOR_ATTACHMENT12_NV = 0x8CEC+gl_VERTEX_STREAM2_ATI :: GLenum+gl_VERTEX_STREAM2_ATI = 0x876E+gl_MAP_COHERENT_BIT :: GLenum+gl_MAP_COHERENT_BIT = 0x0080+gl_COMPRESSED_SIGNED_RG_RGTC2 :: GLenum+gl_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE+gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER :: GLenum+gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC+gl_FRAGMENT_PROGRAM_ARB :: GLenum+gl_FRAGMENT_PROGRAM_ARB = 0x8804+gl_COLOR_BUFFER_BIT6_QCOM :: GLenum+gl_COLOR_BUFFER_BIT6_QCOM = 0x00000040+gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV :: GLenum+gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD+gl_WIDE_LINE_HINT_PGI :: GLenum+gl_WIDE_LINE_HINT_PGI = 0x1A222+gl_FRAGMENT_LIGHT4_SGIX :: GLenum+gl_FRAGMENT_LIGHT4_SGIX = 0x8410+gl_RGBA_FLOAT_MODE_ATI :: GLenum+gl_RGBA_FLOAT_MODE_ATI = 0x8820+gl_UNSIGNED_INT_10F_11F_11F_REV :: GLenum+gl_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B+gl_MODELVIEW1_STACK_DEPTH_EXT :: GLenum+gl_MODELVIEW1_STACK_DEPTH_EXT = 0x8502+gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24+gl_POINT_SIZE_MAX :: GLenum+gl_POINT_SIZE_MAX = 0x8127+gl_ALPHA_TEST_REF_QCOM :: GLenum+gl_ALPHA_TEST_REF_QCOM = 0x0BC2+gl_RELATIVE_HORIZONTAL_LINE_TO_NV :: GLenum+gl_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x07+gl_FILTER4_SGIS :: GLenum+gl_FILTER4_SGIS = 0x8146+gl_TEXTURE4 :: GLenum+gl_TEXTURE4 = 0x84C4+gl_INDEX_MATERIAL_EXT :: GLenum+gl_INDEX_MATERIAL_EXT = 0x81B8+gl_FETCH_PER_SAMPLE_ARM :: GLenum+gl_FETCH_PER_SAMPLE_ARM = 0x8F65+gl_VARIANT_ARRAY_TYPE_EXT :: GLenum+gl_VARIANT_ARRAY_TYPE_EXT = 0x87E7+gl_ALPHA_MAX_SGIX :: GLenum+gl_ALPHA_MAX_SGIX = 0x8321+gl_NUM_INSTRUCTIONS_TOTAL_ATI :: GLenum+gl_NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972+gl_TEXTURE_IMAGE_TYPE :: GLenum+gl_TEXTURE_IMAGE_TYPE = 0x8290+gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS :: GLenum+gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB+gl_DRAW_BUFFER11_NV :: GLenum+gl_DRAW_BUFFER11_NV = 0x8830+gl_SURFACE_STATE_NV :: GLenum+gl_SURFACE_STATE_NV = 0x86EB+gl_BLEND_SRC_RGB :: GLenum+gl_BLEND_SRC_RGB = 0x80C9+gl_OBJECT_ACTIVE_UNIFORMS_ARB :: GLenum+gl_OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86+gl_COLORDODGE_NV :: GLenum+gl_COLORDODGE_NV = 0x9299+gl_PRIMITIVES_GENERATED_NV :: GLenum+gl_PRIMITIVES_GENERATED_NV = 0x8C87+gl_IMAGE_2D_ARRAY :: GLenum+gl_IMAGE_2D_ARRAY = 0x9053+gl_LOSE_CONTEXT_ON_RESET_ARB :: GLenum+gl_LOSE_CONTEXT_ON_RESET_ARB = 0x8252+gl_RG_INTEGER :: GLenum+gl_RG_INTEGER = 0x8228+gl_UNSIGNED_INT_SAMPLER_1D_EXT :: GLenum+gl_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1+gl_REFLECTION_MAP_ARB :: GLenum+gl_REFLECTION_MAP_ARB = 0x8512+gl_NORMAL_ARRAY_TYPE_EXT :: GLenum+gl_NORMAL_ARRAY_TYPE_EXT = 0x807E+gl_BLUE_BITS :: GLenum+gl_BLUE_BITS = 0x0D54+gl_ATOMIC_COUNTER_BARRIER_BIT :: GLenum+gl_ATOMIC_COUNTER_BARRIER_BIT = 0x00001000+gl_INTENSITY8I_EXT :: GLenum+gl_INTENSITY8I_EXT = 0x8D91+gl_TEXTURE_BINDING_RECTANGLE_ARB :: GLenum+gl_TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6+gl_SCALE_BY_TWO_NV :: GLenum+gl_SCALE_BY_TWO_NV = 0x853E+gl_PACK_IMAGE_HEIGHT :: GLenum+gl_PACK_IMAGE_HEIGHT = 0x806C+gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL :: GLenum+gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF+gl_DEPTH_COMPONENT24_SGIX :: GLenum+gl_DEPTH_COMPONENT24_SGIX = 0x81A6+gl_NUM_FRAGMENT_CONSTANTS_ATI :: GLenum+gl_NUM_FRAGMENT_CONSTANTS_ATI = 0x896F+gl_EDGE_FLAG_ARRAY_STRIDE_EXT :: GLenum+gl_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT :: GLenum+gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT = 0x900A+gl_SAMPLE_ALPHA_TO_COVERAGE_ARB :: GLenum+gl_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E+gl_UNPACK_SKIP_IMAGES_EXT :: GLenum+gl_UNPACK_SKIP_IMAGES_EXT = 0x806D+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: GLenum+gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2+gl_RGBA8_OES :: GLenum+gl_RGBA8_OES = 0x8058+gl_STENCIL_INDEX8_OES :: GLenum+gl_STENCIL_INDEX8_OES = 0x8D48+gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD :: GLenum+gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD = 0x9199+gl_COMPUTE_SHADER :: GLenum+gl_COMPUTE_SHADER = 0x91B9+gl_QUERY_WAIT_NV :: GLenum+gl_QUERY_WAIT_NV = 0x8E13+gl_TEXTURE_COMPARE_FUNC_ARB :: GLenum+gl_TEXTURE_COMPARE_FUNC_ARB = 0x884D+gl_SCREEN_COORDINATES_REND :: GLenum+gl_SCREEN_COORDINATES_REND = 0x8490+gl_DRAW_BUFFER4_EXT :: GLenum+gl_DRAW_BUFFER4_EXT = 0x8829+gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT :: GLenum+gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337+gl_TOP_LEVEL_ARRAY_SIZE :: GLenum+gl_TOP_LEVEL_ARRAY_SIZE = 0x930C+gl_STATIC_COPY_ARB :: GLenum+gl_STATIC_COPY_ARB = 0x88E6+gl_MAP1_TANGENT_EXT :: GLenum+gl_MAP1_TANGENT_EXT = 0x8444+gl_MAP2_VERTEX_ATTRIB11_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB11_4_NV = 0x867B+gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX :: GLenum+gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187+gl_DRAW_BUFFER9 :: GLenum+gl_DRAW_BUFFER9 = 0x882E+gl_COMPRESSED_INTENSITY_ARB :: GLenum+gl_COMPRESSED_INTENSITY_ARB = 0x84EC+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516+gl_MATRIX19_ARB :: GLenum+gl_MATRIX19_ARB = 0x88D3+gl_MAX_MULTIVIEW_BUFFERS_EXT :: GLenum+gl_MAX_MULTIVIEW_BUFFERS_EXT = 0x90F2+gl_CONJOINT_NV :: GLenum+gl_CONJOINT_NV = 0x9284+gl_INTENSITY_SNORM :: GLenum+gl_INTENSITY_SNORM = 0x9013+gl_DRAW_BUFFER14 :: GLenum+gl_DRAW_BUFFER14 = 0x8833+gl_MAX_PROGRAM_INSTRUCTIONS_ARB :: GLenum+gl_MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1+gl_TEXTURE_BINDING_RECTANGLE :: GLenum+gl_TEXTURE_BINDING_RECTANGLE = 0x84F6+gl_DEBUG_SOURCE_SHADER_COMPILER_ARB :: GLenum+gl_DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR :: GLenum+gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD+gl_MULTISAMPLE_EXT :: GLenum+gl_MULTISAMPLE_EXT = 0x809D+gl_NEAREST_MIPMAP_NEAREST :: GLenum+gl_NEAREST_MIPMAP_NEAREST = 0x2700+gl_COLOR_ATTACHMENT7_EXT :: GLenum+gl_COLOR_ATTACHMENT7_EXT = 0x8CE7+gl_STENCIL_BUFFER_BIT6_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT6_QCOM = 0x00400000+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 0x8C85+gl_REG_29_ATI :: GLenum+gl_REG_29_ATI = 0x893E+gl_COVERAGE_SAMPLES_NV :: GLenum+gl_COVERAGE_SAMPLES_NV = 0x8ED4+gl_RELEASED_APPLE :: GLenum+gl_RELEASED_APPLE = 0x8A19+gl_ALPHA_TEST_FUNC :: GLenum+gl_ALPHA_TEST_FUNC = 0x0BC1+gl_DRAW_BUFFER2 :: GLenum+gl_DRAW_BUFFER2 = 0x8827+gl_VERTEX_PROGRAM_BINDING_NV :: GLenum+gl_VERTEX_PROGRAM_BINDING_NV = 0x864A+gl_IMAGE_2D_RECT :: GLenum+gl_IMAGE_2D_RECT = 0x904F+gl_COLOR_TABLE_BIAS_SGI :: GLenum+gl_COLOR_TABLE_BIAS_SGI = 0x80D7+gl_CLIENT_ACTIVE_TEXTURE_ARB :: GLenum+gl_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1+gl_CURRENT_MATRIX_INDEX_ARB :: GLenum+gl_CURRENT_MATRIX_INDEX_ARB = 0x8845+gl_TEXTURE_COORD_ARRAY_STRIDE :: GLenum+gl_TEXTURE_COORD_ARRAY_STRIDE = 0x808A+gl_FILTER :: GLenum+gl_FILTER = 0x829A+gl_MAX_MODELVIEW_STACK_DEPTH :: GLenum+gl_MAX_MODELVIEW_STACK_DEPTH = 0x0D36+gl_VERTEX_ATTRIB_ARRAY5_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY5_NV = 0x8655+gl_UNSIGNED_BYTE :: GLenum+gl_UNSIGNED_BYTE = 0x1401+gl_DETAIL_TEXTURE_2D_SGIS :: GLenum+gl_DETAIL_TEXTURE_2D_SGIS = 0x8095+gl_POST_CONVOLUTION_BLUE_BIAS :: GLenum+gl_POST_CONVOLUTION_BLUE_BIAS = 0x8022+gl_TYPE :: GLenum+gl_TYPE = 0x92FA+gl_COMPRESSED_RG :: GLenum+gl_COMPRESSED_RG = 0x8226+gl_4PASS_1_SGIS :: GLenum+gl_4PASS_1_SGIS = 0x80A5+gl_SOURCE2_RGB :: GLenum+gl_SOURCE2_RGB = 0x8582+gl_TEXTURE_MAX_LOD :: GLenum+gl_TEXTURE_MAX_LOD = 0x813B+gl_EYE_DISTANCE_TO_LINE_SGIS :: GLenum+gl_EYE_DISTANCE_TO_LINE_SGIS = 0x81F2+gl_LUMINANCE_ALPHA32F_EXT :: GLenum+gl_LUMINANCE_ALPHA32F_EXT = 0x8819+gl_MATRIX_INDEX_ARRAY_STRIDE_ARB :: GLenum+gl_MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848+gl_COLOR_ATTACHMENT4 :: GLenum+gl_COLOR_ATTACHMENT4 = 0x8CE4+gl_INDEX_ARRAY_BUFFER_BINDING :: GLenum+gl_INDEX_ARRAY_BUFFER_BINDING = 0x8899+gl_UNSIGNED_INT_SAMPLER_2D_ARRAY :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7+gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX :: GLenum+gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E+gl_SPECULAR :: GLenum+gl_SPECULAR = 0x1202+gl_PACK_IMAGE_DEPTH_SGIS :: GLenum+gl_PACK_IMAGE_DEPTH_SGIS = 0x8131+gl_PLUS_CLAMPED_NV :: GLenum+gl_PLUS_CLAMPED_NV = 0x92B1+gl_INVALID_FRAMEBUFFER_OPERATION :: GLenum+gl_INVALID_FRAMEBUFFER_OPERATION = 0x0506+gl_RG :: GLenum+gl_RG = 0x8227+gl_COLOR_ATTACHMENT11_NV :: GLenum+gl_COLOR_ATTACHMENT11_NV = 0x8CEB+gl_UNPACK_SKIP_PIXELS :: GLenum+gl_UNPACK_SKIP_PIXELS = 0x0CF4+gl_SAMPLE_BUFFERS :: GLenum+gl_SAMPLE_BUFFERS = 0x80A8+gl_DRAW_BUFFER1_ARB :: GLenum+gl_DRAW_BUFFER1_ARB = 0x8826+gl_COMBINER6_NV :: GLenum+gl_COMBINER6_NV = 0x8556+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES :: GLenum+gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES = 0x851A+gl_TEXTURE_ENV :: GLenum+gl_TEXTURE_ENV = 0x2300+gl_QUAD_MESH_SUN :: GLenum+gl_QUAD_MESH_SUN = 0x8614+gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT :: GLenum+gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT = 0x9307+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV :: GLenum+gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B+gl_TIMEOUT_EXPIRED :: GLenum+gl_TIMEOUT_EXPIRED = 0x911B+gl_FLOAT_MAT4x2_NV :: GLenum+gl_FLOAT_MAT4x2_NV = 0x8B69+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum+gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910D+gl_COMBINER1_NV :: GLenum+gl_COMBINER1_NV = 0x8551+gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB :: GLenum+gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7+gl_RENDERBUFFER_SAMPLES_ANGLE :: GLenum+gl_RENDERBUFFER_SAMPLES_ANGLE = 0x8CAB+gl_VERTEX_ARRAY_SIZE :: GLenum+gl_VERTEX_ARRAY_SIZE = 0x807A+gl_TEXTURE2 :: GLenum+gl_TEXTURE2 = 0x84C2+gl_RELATIVE_MOVE_TO_NV :: GLenum+gl_RELATIVE_MOVE_TO_NV = 0x03+gl_ALPHA_TEST_FUNC_QCOM :: GLenum+gl_ALPHA_TEST_FUNC_QCOM = 0x0BC1+gl_INNOCENT_CONTEXT_RESET_KHR :: GLenum+gl_INNOCENT_CONTEXT_RESET_KHR = 0x8254+gl_MAP1_VERTEX_ATTRIB5_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB5_4_NV = 0x8665+gl_SAMPLER_1D_SHADOW :: GLenum+gl_SAMPLER_1D_SHADOW = 0x8B61+gl_TEXTURE_1D_ARRAY_EXT :: GLenum+gl_TEXTURE_1D_ARRAY_EXT = 0x8C18+gl_STENCIL_INDEX :: GLenum+gl_STENCIL_INDEX = 0x1901+gl_SOURCE2_ALPHA_EXT :: GLenum+gl_SOURCE2_ALPHA_EXT = 0x858A+gl_NORMAL_MAP_EXT :: GLenum+gl_NORMAL_MAP_EXT = 0x8511+gl_FOG_COORDINATE_SOURCE_EXT :: GLenum+gl_FOG_COORDINATE_SOURCE_EXT = 0x8450+gl_TEXTURE_FILTER_CONTROL :: GLenum+gl_TEXTURE_FILTER_CONTROL = 0x8500+gl_REPLACE_OLDEST_SUN :: GLenum+gl_REPLACE_OLDEST_SUN = 0x0003+gl_PROGRAM_ADDRESS_REGISTERS_ARB :: GLenum+gl_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0+gl_2PASS_1_EXT :: GLenum+gl_2PASS_1_EXT = 0x80A3+gl_LIGHT_ENV_MODE_SGIX :: GLenum+gl_LIGHT_ENV_MODE_SGIX = 0x8407+gl_OP_FRAC_EXT :: GLenum+gl_OP_FRAC_EXT = 0x8789+gl_PROXY_TEXTURE_RECTANGLE_NV :: GLenum+gl_PROXY_TEXTURE_RECTANGLE_NV = 0x84F7+gl_RENDERBUFFER :: GLenum+gl_RENDERBUFFER = 0x8D41+gl_MAP2_TEXTURE_COORD_4 :: GLenum+gl_MAP2_TEXTURE_COORD_4 = 0x0DB6+gl_TEXTURE_BORDER_COLOR_EXT :: GLenum+gl_TEXTURE_BORDER_COLOR_EXT = 0x1004+gl_SEPARABLE_2D :: GLenum+gl_SEPARABLE_2D = 0x8012+gl_COMPRESSED_SRGB_S3TC_DXT1_EXT :: GLenum+gl_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C+gl_DRAW_BUFFER0_ATI :: GLenum+gl_DRAW_BUFFER0_ATI = 0x8825+gl_TEXTURE_IMMUTABLE_LEVELS :: GLenum+gl_TEXTURE_IMMUTABLE_LEVELS = 0x82DF+gl_E_TIMES_F_NV :: GLenum+gl_E_TIMES_F_NV = 0x8531+gl_MATRIX24_ARB :: GLenum+gl_MATRIX24_ARB = 0x88D8+gl_PIXEL_GROUP_COLOR_SGIS :: GLenum+gl_PIXEL_GROUP_COLOR_SGIS = 0x8356+gl_CURRENT_RASTER_COLOR :: GLenum+gl_CURRENT_RASTER_COLOR = 0x0B04+gl_DOUBLE_MAT2x4_EXT :: GLenum+gl_DOUBLE_MAT2x4_EXT = 0x8F4A+gl_BUMP_TEX_UNITS_ATI :: GLenum+gl_BUMP_TEX_UNITS_ATI = 0x8778+gl_FOG_COORDINATE_ARRAY_EXT :: GLenum+gl_FOG_COORDINATE_ARRAY_EXT = 0x8457+gl_ALWAYS :: GLenum+gl_ALWAYS = 0x0207+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES :: GLenum+gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5B+gl_MAP2_VERTEX_4 :: GLenum+gl_MAP2_VERTEX_4 = 0x0DB8+gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG :: GLenum+gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03+gl_MODULATE_SIGNED_ADD_ATI :: GLenum+gl_MODULATE_SIGNED_ADD_ATI = 0x8745+gl_RG8 :: GLenum+gl_RG8 = 0x822B+gl_ACTIVE_UNIFORM_BLOCKS :: GLenum+gl_ACTIVE_UNIFORM_BLOCKS = 0x8A36+gl_MAX_SPARSE_TEXTURE_SIZE_AMD :: GLenum+gl_MAX_SPARSE_TEXTURE_SIZE_AMD = 0x9198+gl_COLOR_ATTACHMENT11_EXT :: GLenum+gl_COLOR_ATTACHMENT11_EXT = 0x8CEB+gl_POST_CONVOLUTION_BLUE_BIAS_EXT :: GLenum+gl_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022+gl_BUFFER_OBJECT_APPLE :: GLenum+gl_BUFFER_OBJECT_APPLE = 0x85B3+gl_UNIFORM_TYPE :: GLenum+gl_UNIFORM_TYPE = 0x8A37+gl_VARIABLE_E_NV :: GLenum+gl_VARIABLE_E_NV = 0x8527+gl_MAX_COMPUTE_ATOMIC_COUNTERS :: GLenum+gl_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265+gl_COMPRESSED_RED_RGTC1 :: GLenum+gl_COMPRESSED_RED_RGTC1 = 0x8DBB+gl_LUMINANCE_INTEGER_EXT :: GLenum+gl_LUMINANCE_INTEGER_EXT = 0x8D9C+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY :: GLenum+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE :: GLenum+gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE+gl_R16F_EXT :: GLenum+gl_R16F_EXT = 0x822D+gl_MATRIX4_ARB :: GLenum+gl_MATRIX4_ARB = 0x88C4+gl_MATRIX_INDEX_ARRAY_SIZE_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_SIZE_OES = 0x8846+gl_POLYGON_STIPPLE :: GLenum+gl_POLYGON_STIPPLE = 0x0B42+gl_DUAL_ALPHA12_SGIS :: GLenum+gl_DUAL_ALPHA12_SGIS = 0x8112+gl_PIXEL_MAP_I_TO_B :: GLenum+gl_PIXEL_MAP_I_TO_B = 0x0C74+gl_VERTEX_ATTRIB_ARRAY6_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY6_NV = 0x8656+gl_REG_21_ATI :: GLenum+gl_REG_21_ATI = 0x8936+gl_PERFMON_RESULT_SIZE_AMD :: GLenum+gl_PERFMON_RESULT_SIZE_AMD = 0x8BC5+gl_ALPHA8_OES :: GLenum+gl_ALPHA8_OES = 0x803C+gl_OBJECT_BUFFER_USAGE_ATI :: GLenum+gl_OBJECT_BUFFER_USAGE_ATI = 0x8765+gl_PATH_STENCIL_FUNC_NV :: GLenum+gl_PATH_STENCIL_FUNC_NV = 0x90B7+gl_TEXTURE12_ARB :: GLenum+gl_TEXTURE12_ARB = 0x84CC+gl_DEPTH_COMPONENT16_OES :: GLenum+gl_DEPTH_COMPONENT16_OES = 0x81A5+gl_MODELVIEW20_ARB :: GLenum+gl_MODELVIEW20_ARB = 0x8734+gl_ALPHA12 :: GLenum+gl_ALPHA12 = 0x803D+gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT :: GLenum+gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT = 0x919F+gl_MODULATE_ADD_ATI :: GLenum+gl_MODULATE_ADD_ATI = 0x8744+gl_CLAMP_TO_BORDER_EXT :: GLenum+gl_CLAMP_TO_BORDER_EXT = 0x812D+gl_CONSTANT_EXT :: GLenum+gl_CONSTANT_EXT = 0x8576+gl_OP_LOG_BASE_2_EXT :: GLenum+gl_OP_LOG_BASE_2_EXT = 0x8792+gl_SET_AMD :: GLenum+gl_SET_AMD = 0x874A+gl_ONE_MINUS_SRC_ALPHA :: GLenum+gl_ONE_MINUS_SRC_ALPHA = 0x0303+gl_COMPRESSED_LUMINANCE_ALPHA_ARB :: GLenum+gl_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB+gl_MAX_SERVER_WAIT_TIMEOUT_APPLE :: GLenum+gl_MAX_SERVER_WAIT_TIMEOUT_APPLE = 0x9111+gl_LINE_TOKEN :: GLenum+gl_LINE_TOKEN = 0x0702+gl_PROXY_POST_CONVOLUTION_COLOR_TABLE :: GLenum+gl_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4+gl_TEXTURE_BINDING_3D :: GLenum+gl_TEXTURE_BINDING_3D = 0x806A+gl_INTENSITY16I_EXT :: GLenum+gl_INTENSITY16I_EXT = 0x8D8B+gl_DEPENDENT_AR_TEXTURE_2D_NV :: GLenum+gl_DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9+gl_CURRENT_RASTER_NORMAL_SGIX :: GLenum+gl_CURRENT_RASTER_NORMAL_SGIX = 0x8406+gl_TEXTURE_INTENSITY_TYPE :: GLenum+gl_TEXTURE_INTENSITY_TYPE = 0x8C15+gl_TEXTURE_STORAGE_SPARSE_BIT_AMD :: GLenum+gl_TEXTURE_STORAGE_SPARSE_BIT_AMD = 0x00000001+gl_RENDERBUFFER_INTERNAL_FORMAT_EXT :: GLenum+gl_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44+gl_VERTEX_ATTRIB_ARRAY1_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY1_NV = 0x8651+gl_TEXTURE_RED_SIZE :: GLenum+gl_TEXTURE_RED_SIZE = 0x805C+gl_CURRENT_COLOR :: GLenum+gl_CURRENT_COLOR = 0x0B00+gl_COMPRESSED_RGBA_ASTC_8x5_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5+gl_STENCIL_BUFFER_BIT7_QCOM :: GLenum+gl_STENCIL_BUFFER_BIT7_QCOM = 0x00800000+gl_CLIP_PLANE0_IMG :: GLenum+gl_CLIP_PLANE0_IMG = 0x3000+gl_ALPHA_TEST_REF :: GLenum+gl_ALPHA_TEST_REF = 0x0BC2+gl_POINT_SMOOTH :: GLenum+gl_POINT_SMOOTH = 0x0B10+gl_WEIGHT_ARRAY_SIZE_OES :: GLenum+gl_WEIGHT_ARRAY_SIZE_OES = 0x86AB+gl_DECODE_EXT :: GLenum+gl_DECODE_EXT = 0x8A49+gl_SPARSE_BUFFER_PAGE_SIZE_ARB :: GLenum+gl_SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8+gl_CLIENT_ATTRIB_STACK_DEPTH :: GLenum+gl_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1+gl_TEXTURE_BINDING_EXTERNAL_OES :: GLenum+gl_TEXTURE_BINDING_EXTERNAL_OES = 0x8D67+gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT :: GLenum+gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT = 0x8E8A+gl_RENDERBUFFER_STENCIL_SIZE_OES :: GLenum+gl_RENDERBUFFER_STENCIL_SIZE_OES = 0x8D55+gl_POST_COLOR_MATRIX_ALPHA_BIAS :: GLenum+gl_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB+gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT :: GLenum+gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E+gl_HSL_LUMINOSITY_KHR :: GLenum+gl_HSL_LUMINOSITY_KHR = 0x92B0+gl_MAX_VERTEX_STREAMS_ATI :: GLenum+gl_MAX_VERTEX_STREAMS_ATI = 0x876B+gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL :: GLenum+gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3+gl_COMPRESSED_SIGNED_RED_RGTC1_EXT :: GLenum+gl_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC+gl_DEPTH_COMPONENT32_OES :: GLenum+gl_DEPTH_COMPONENT32_OES = 0x81A7+gl_CON_3_ATI :: GLenum+gl_CON_3_ATI = 0x8944+gl_COMPRESSED_RGBA_S3TC_DXT1_EXT :: GLenum+gl_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1+gl_MATRIX6_ARB :: GLenum+gl_MATRIX6_ARB = 0x88C6+gl_MAP2_VERTEX_ATTRIB5_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB5_4_NV = 0x8675+gl_LINE_WIDTH_RANGE :: GLenum+gl_LINE_WIDTH_RANGE = 0x0B22+gl_GLYPH_VERTICAL_BEARING_X_BIT_NV :: GLenum+gl_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20+gl_FOG_COORDINATE_ARRAY :: GLenum+gl_FOG_COORDINATE_ARRAY = 0x8457+gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE :: GLenum+gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E+gl_CLAMP_FRAGMENT_COLOR :: GLenum+gl_CLAMP_FRAGMENT_COLOR = 0x891B+gl_COMPRESSED_RGBA_ASTC_10x5_KHR :: GLenum+gl_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8+gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB :: GLenum+gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D+gl_COLOR_BUFFER_BIT4_QCOM :: GLenum+gl_COLOR_BUFFER_BIT4_QCOM = 0x00000010+gl_TEXTURE13 :: GLenum+gl_TEXTURE13 = 0x84CD+gl_MAX_DEBUG_MESSAGE_LENGTH_AMD :: GLenum+gl_MAX_DEBUG_MESSAGE_LENGTH_AMD = 0x9143+gl_EVAL_VERTEX_ATTRIB0_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB0_NV = 0x86C6+gl_ALPHA_MIN_CLAMP_INGR :: GLenum+gl_ALPHA_MIN_CLAMP_INGR = 0x8563+gl_SUB_ATI :: GLenum+gl_SUB_ATI = 0x8965+gl_SECONDARY_COLOR_ARRAY_LIST_IBM :: GLenum+gl_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077+gl_RGBA_INTEGER_MODE_EXT :: GLenum+gl_RGBA_INTEGER_MODE_EXT = 0x8D9E+gl_DEBUG_TYPE_MARKER_KHR :: GLenum+gl_DEBUG_TYPE_MARKER_KHR = 0x8268+gl_VERTEX_ATTRIB_ARRAY14_NV :: GLenum+gl_VERTEX_ATTRIB_ARRAY14_NV = 0x865E+gl_TEXTURE_MIN_LOD :: GLenum+gl_TEXTURE_MIN_LOD = 0x813A+gl_INDEX_TEST_REF_EXT :: GLenum+gl_INDEX_TEST_REF_EXT = 0x81B7+gl_AUX0 :: GLenum+gl_AUX0 = 0x0409+gl_UNSIGNED_INT_IMAGE_2D_RECT :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_RECT = 0x9065+gl_2_BYTES :: GLenum+gl_2_BYTES = 0x1407+gl_UNDEFINED_VERTEX :: GLenum+gl_UNDEFINED_VERTEX = 0x8260+gl_LINE_STIPPLE_PATTERN :: GLenum+gl_LINE_STIPPLE_PATTERN = 0x0B25+gl_FRAMEBUFFER_SRGB_CAPABLE_EXT :: GLenum+gl_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA+gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB :: GLenum+gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F+gl_UNSIGNED_INT_SAMPLER_1D_ARRAY :: GLenum+gl_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6+gl_LOAD :: GLenum+gl_LOAD = 0x0101+gl_SIGNED_ALPHA8_NV :: GLenum+gl_SIGNED_ALPHA8_NV = 0x8706+gl_STENCIL_INDEX8_EXT :: GLenum+gl_STENCIL_INDEX8_EXT = 0x8D48+gl_VIEW_CLASS_24_BITS :: GLenum+gl_VIEW_CLASS_24_BITS = 0x82C9+gl_SHADER_STORAGE_BARRIER_BIT :: GLenum+gl_SHADER_STORAGE_BARRIER_BIT = 0x00002000+gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD :: GLenum+gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 0x9003+gl_IMAGE_BINDING_LAYER :: GLenum+gl_IMAGE_BINDING_LAYER = 0x8F3D+gl_MULTISAMPLE_FILTER_HINT_NV :: GLenum+gl_MULTISAMPLE_FILTER_HINT_NV = 0x8534+gl_SPARE1_NV :: GLenum+gl_SPARE1_NV = 0x852F+gl_MAP_READ_BIT_EXT :: GLenum+gl_MAP_READ_BIT_EXT = 0x0001+gl_COMPRESSED_LUMINANCE :: GLenum+gl_COMPRESSED_LUMINANCE = 0x84EA+gl_COMPRESSED_TEXTURE_FORMATS :: GLenum+gl_COMPRESSED_TEXTURE_FORMATS = 0x86A3+gl_UNIFORM_IS_ROW_MAJOR :: GLenum+gl_UNIFORM_IS_ROW_MAJOR = 0x8A3E+gl_OFFSET_TEXTURE_2D_SCALE_NV :: GLenum+gl_OFFSET_TEXTURE_2D_SCALE_NV = 0x86E2+gl_RGBA_DXT5_S3TC :: GLenum+gl_RGBA_DXT5_S3TC = 0x83A4+gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB :: GLenum+gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4+gl_MAX_UNIFORM_BUFFER_BINDINGS :: GLenum+gl_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F+gl_RGB16UI_EXT :: GLenum+gl_RGB16UI_EXT = 0x8D77+gl_TEXTURE_COMPARE_OPERATOR_SGIX :: GLenum+gl_TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B+gl_VIDEO_BUFFER_PITCH_NV :: GLenum+gl_VIDEO_BUFFER_PITCH_NV = 0x9028+gl_RELATIVE_RECT_NV :: GLenum+gl_RELATIVE_RECT_NV = 0xF7+gl_DRAW_BUFFER8_ATI :: GLenum+gl_DRAW_BUFFER8_ATI = 0x882D+gl_SRC_COLOR :: GLenum+gl_SRC_COLOR = 0x0300+gl_SHADER_OBJECT_EXT :: GLenum+gl_SHADER_OBJECT_EXT = 0x8B48+gl_GUILTY_CONTEXT_RESET_KHR :: GLenum+gl_GUILTY_CONTEXT_RESET_KHR = 0x8253+gl_EVAL_VERTEX_ATTRIB5_NV :: GLenum+gl_EVAL_VERTEX_ATTRIB5_NV = 0x86CB+gl_PALETTE4_RGBA4_OES :: GLenum+gl_PALETTE4_RGBA4_OES = 0x8B93+gl_LUMINANCE12_EXT :: GLenum+gl_LUMINANCE12_EXT = 0x8041+gl_DONT_CARE :: GLenum+gl_DONT_CARE = 0x1100+gl_TEXTURE_BUFFER :: GLenum+gl_TEXTURE_BUFFER = 0x8C2A+gl_COMPRESSED_RGBA_ASTC_4x4x4_OES :: GLenum+gl_COMPRESSED_RGBA_ASTC_4x4x4_OES = 0x93C3+gl_TEXTURE_BINDING_1D_ARRAY :: GLenum+gl_TEXTURE_BINDING_1D_ARRAY = 0x8C1C+gl_SEPARATE_SPECULAR_COLOR :: GLenum+gl_SEPARATE_SPECULAR_COLOR = 0x81FA+gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED :: GLenum+gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221+gl_NORMAL_ARRAY_LIST_IBM :: GLenum+gl_NORMAL_ARRAY_LIST_IBM = 103071+gl_CURRENT_MATRIX_STACK_DEPTH_NV :: GLenum+gl_CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640+gl_INT_IMAGE_3D :: GLenum+gl_INT_IMAGE_3D = 0x9059+gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV :: GLenum+gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3+gl_CONTEXT_FLAG_DEBUG_BIT :: GLenum+gl_CONTEXT_FLAG_DEBUG_BIT = 0x00000002+gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB :: GLenum+gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E+gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX :: GLenum+gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA+gl_VECTOR_EXT :: GLenum+gl_VECTOR_EXT = 0x87BF+gl_TEXTURE_BUFFER_DATA_STORE_BINDING :: GLenum+gl_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D+gl_TEXTURE_LOD_BIAS :: GLenum+gl_TEXTURE_LOD_BIAS = 0x8501+gl_GEOMETRY_SHADER_EXT :: GLenum+gl_GEOMETRY_SHADER_EXT = 0x8DD9+gl_TEXTURE30 :: GLenum+gl_TEXTURE30 = 0x84DE+gl_VERTEX_SHADER_BIT :: GLenum+gl_VERTEX_SHADER_BIT = 0x00000001+gl_HISTOGRAM_BLUE_SIZE_EXT :: GLenum+gl_HISTOGRAM_BLUE_SIZE_EXT = 0x802A+gl_PATH_COMMAND_COUNT_NV :: GLenum+gl_PATH_COMMAND_COUNT_NV = 0x909D+gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV :: GLenum+gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 0x903B+gl_STENCIL_TAG_BITS_EXT :: GLenum+gl_STENCIL_TAG_BITS_EXT = 0x88F2+gl_MAX_PROGRAM_LOOP_DEPTH_NV :: GLenum+gl_MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7+gl_FLOAT_MAT2x3_NV :: GLenum+gl_FLOAT_MAT2x3_NV = 0x8B65+gl_CURRENT_RASTER_DISTANCE :: GLenum+gl_CURRENT_RASTER_DISTANCE = 0x0B09+gl_COMPRESSED_SRGB8_ETC2_OES :: GLenum+gl_COMPRESSED_SRGB8_ETC2_OES = 0x9275+gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES :: GLenum+gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9276+gl_PIXEL_MAP_I_TO_G_SIZE :: GLenum+gl_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3+gl_COMBINE :: GLenum+gl_COMBINE = 0x8570+gl_FOG_HINT :: GLenum+gl_FOG_HINT = 0x0C54+gl_COMPUTE_SUBROUTINE_UNIFORM :: GLenum+gl_COMPUTE_SUBROUTINE_UNIFORM = 0x92F3+gl_FRAGMENT_LIGHT3_SGIX :: GLenum+gl_FRAGMENT_LIGHT3_SGIX = 0x840F+gl_DEBUG_TYPE_PORTABILITY_ARB :: GLenum+gl_DEBUG_TYPE_PORTABILITY_ARB = 0x824F+gl_MIN_PROGRAM_TEXEL_OFFSET_EXT :: GLenum+gl_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904+gl_TRANSFORM_FEEDBACK_BUFFER_NV :: GLenum+gl_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E+gl_UNKNOWN_CONTEXT_RESET_EXT :: GLenum+gl_UNKNOWN_CONTEXT_RESET_EXT = 0x8255+gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum+gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E+gl_UNSIGNED_INT_24_8_NV :: GLenum+gl_UNSIGNED_INT_24_8_NV = 0x84FA+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum+gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C+gl_MANUAL_GENERATE_MIPMAP :: GLenum+gl_MANUAL_GENERATE_MIPMAP = 0x8294+gl_MAP2_VERTEX_ATTRIB6_4_NV :: GLenum+gl_MAP2_VERTEX_ATTRIB6_4_NV = 0x8676+gl_FRAMEBUFFER_EXT :: GLenum+gl_FRAMEBUFFER_EXT = 0x8D40+gl_INT16_NV :: GLenum+gl_INT16_NV = 0x8FE4+gl_FULL_RANGE_EXT :: GLenum+gl_FULL_RANGE_EXT = 0x87E1+gl_MAP1_VERTEX_ATTRIB2_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB2_4_NV = 0x8662+gl_UNSIGNED_INT_8_8_8_8_EXT :: GLenum+gl_UNSIGNED_INT_8_8_8_8_EXT = 0x8035+gl_TESS_CONTROL_SUBROUTINE_UNIFORM :: GLenum+gl_TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF+gl_PREVIOUS_TEXTURE_INPUT_NV :: GLenum+gl_PREVIOUS_TEXTURE_INPUT_NV = 0x86E4+gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE :: GLenum+gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4+gl_SYNC_STATUS_APPLE :: GLenum+gl_SYNC_STATUS_APPLE = 0x9114+gl_4PASS_0_EXT :: GLenum+gl_4PASS_0_EXT = 0x80A4+gl_POLYGON_SMOOTH :: GLenum+gl_POLYGON_SMOOTH = 0x0B41+gl_FEEDBACK_BUFFER_SIZE :: GLenum+gl_FEEDBACK_BUFFER_SIZE = 0x0DF1+gl_COLORBURN_KHR :: GLenum+gl_COLORBURN_KHR = 0x929A+gl_DEPTH24_STENCIL8 :: GLenum+gl_DEPTH24_STENCIL8 = 0x88F0+gl_LINEAR_CLIPMAP_LINEAR_SGIX :: GLenum+gl_LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170+gl_TEXTURE_MAX_LEVEL :: GLenum+gl_TEXTURE_MAX_LEVEL = 0x813D+gl_TEXTURE_WRAP_R_EXT :: GLenum+gl_TEXTURE_WRAP_R_EXT = 0x8072+gl_OBJECT_SUBTYPE_ARB :: GLenum+gl_OBJECT_SUBTYPE_ARB = 0x8B4F+gl_MATRIX18_ARB :: GLenum+gl_MATRIX18_ARB = 0x88D2+gl_MATRIX_INDEX_ARRAY_POINTER_OES :: GLenum+gl_MATRIX_INDEX_ARRAY_POINTER_OES = 0x8849+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB :: GLenum+gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E+gl_ALPHA8_SNORM :: GLenum+gl_ALPHA8_SNORM = 0x9014+gl_TESS_CONTROL_SUBROUTINE :: GLenum+gl_TESS_CONTROL_SUBROUTINE = 0x92E9+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum+gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F+gl_POST_CONVOLUTION_ALPHA_SCALE_EXT :: GLenum+gl_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F+gl_RGB5_A1_EXT :: GLenum+gl_RGB5_A1_EXT = 0x8057+gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS :: GLenum+gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC+gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM :: GLenum+gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM = 0x8FB3+gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV :: GLenum+gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A+gl_TEXTURE21_ARB :: GLenum+gl_TEXTURE21_ARB = 0x84D5+gl_SAMPLER_2D_RECT_SHADOW :: GLenum+gl_SAMPLER_2D_RECT_SHADOW = 0x8B64+gl_DEPTH_STENCIL_TEXTURE_MODE :: GLenum+gl_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA+gl_MAP1_VERTEX_ATTRIB10_4_NV :: GLenum+gl_MAP1_VERTEX_ATTRIB10_4_NV = 0x866A+gl_PINLIGHT_NV :: GLenum+gl_PINLIGHT_NV = 0x92A8+gl_TEXTURE_INTERNAL_FORMAT :: GLenum+gl_TEXTURE_INTERNAL_FORMAT = 0x1003+gl_VERTEX_ARRAY_OBJECT_AMD :: GLenum+gl_VERTEX_ARRAY_OBJECT_AMD = 0x9154+gl_OBJECT_LINEAR :: GLenum+gl_OBJECT_LINEAR = 0x2401+gl_TEXTURE_IMMUTABLE_FORMAT_EXT :: GLenum+gl_TEXTURE_IMMUTABLE_FORMAT_EXT = 0x912F+gl_COMBINER_COMPONENT_USAGE_NV :: GLenum+gl_COMBINER_COMPONENT_USAGE_NV = 0x8544+gl_RENDERBUFFER_GREEN_SIZE_EXT :: GLenum+gl_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51+gl_CONVOLUTION_FILTER_SCALE :: GLenum+gl_CONVOLUTION_FILTER_SCALE = 0x8014+gl_TEXTURE11 :: GLenum+gl_TEXTURE11 = 0x84CB+gl_BITMAP :: GLenum+gl_BITMAP = 0x1A00+gl_VIEW_COMPATIBILITY_CLASS :: GLenum+gl_VIEW_COMPATIBILITY_CLASS = 0x82B6+gl_TEXTURE26 :: GLenum+gl_TEXTURE26 = 0x84DA+gl_UNSIGNED_INT8_VEC4_NV :: GLenum+gl_UNSIGNED_INT8_VEC4_NV = 0x8FEF+gl_UNSIGNED_INT_VEC3 :: GLenum+gl_UNSIGNED_INT_VEC3 = 0x8DC7+gl_VERTEX_PRECLIP_SGIX :: GLenum+gl_VERTEX_PRECLIP_SGIX = 0x83EE+gl_PACK_LSB_FIRST :: GLenum+gl_PACK_LSB_FIRST = 0x0D01+gl_NEGATIVE_Y_EXT :: GLenum+gl_NEGATIVE_Y_EXT = 0x87DA+gl_FRAMEBUFFER_BINDING_ANGLE :: GLenum+gl_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6+gl_MAP_INVALIDATE_BUFFER_BIT_EXT :: GLenum+gl_MAP_INVALIDATE_BUFFER_BIT_EXT = 0x0008+gl_NO_RESET_NOTIFICATION :: GLenum+gl_NO_RESET_NOTIFICATION = 0x8261+gl_MINMAX_EXT :: GLenum+gl_MINMAX_EXT = 0x802E+gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST :: GLenum+gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC+gl_QUARTER_BIT_ATI :: GLenum+gl_QUARTER_BIT_ATI = 0x00000010+gl_TEXTURE9 :: GLenum+gl_TEXTURE9 = 0x84C9+gl_FLOAT_R16_NV :: GLenum+gl_FLOAT_R16_NV = 0x8884+gl_BLEND_ADVANCED_COHERENT_KHR :: GLenum+gl_BLEND_ADVANCED_COHERENT_KHR = 0x9285+gl_MATRIX_INDEX_ARRAY_POINTER_ARB :: GLenum+gl_MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849+gl_PROXY_TEXTURE_1D_EXT :: GLenum+gl_PROXY_TEXTURE_1D_EXT = 0x8063+gl_PERTURB_EXT :: GLenum+gl_PERTURB_EXT = 0x85AE+gl_IUI_N3F_V3F_EXT :: GLenum+gl_IUI_N3F_V3F_EXT = 0x81B0+gl_COMBINE_RGB_ARB :: GLenum+gl_COMBINE_RGB_ARB = 0x8571+gl_DEBUG_SOURCE_APPLICATION_KHR :: GLenum+gl_DEBUG_SOURCE_APPLICATION_KHR = 0x824A+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS :: GLenum+gl_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE :: GLenum+gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE = 0x8D56+gl_PROGRAM_ALU_INSTRUCTIONS_ARB :: GLenum+gl_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805+gl_VERTEX_STREAM0_ATI :: GLenum+gl_VERTEX_STREAM0_ATI = 0x876C+gl_EDGE_FLAG_ARRAY_POINTER_EXT :: GLenum+gl_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093+gl_INT_IMAGE_2D_EXT :: GLenum+gl_INT_IMAGE_2D_EXT = 0x9058+gl_READ_FRAMEBUFFER_BINDING_EXT :: GLenum+gl_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA+gl_TEXTURE_CUBE_MAP_ARB :: GLenum+gl_TEXTURE_CUBE_MAP_ARB = 0x8513+gl_LUMINANCE12_ALPHA12 :: GLenum+gl_LUMINANCE12_ALPHA12 = 0x8047+gl_FUNC_ADD :: GLenum+gl_FUNC_ADD = 0x8006+gl_TRANSPOSE_COLOR_MATRIX_ARB :: GLenum+gl_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6+gl_COLOR_ATTACHMENT6 :: GLenum+gl_COLOR_ATTACHMENT6 = 0x8CE6+gl_GEOMETRY_SUBROUTINE :: GLenum+gl_GEOMETRY_SUBROUTINE = 0x92EB+gl_MAX_ELEMENT_INDEX :: GLenum+gl_MAX_ELEMENT_INDEX = 0x8D6B+gl_QUERY_OBJECT_AMD :: GLenum+gl_QUERY_OBJECT_AMD = 0x9153+gl_TEXTURE_CUBE_MAP_EXT :: GLenum+gl_TEXTURE_CUBE_MAP_EXT = 0x8513+gl_CONSTANT_ATTENUATION :: GLenum+gl_CONSTANT_ATTENUATION = 0x1207+gl_LUMINANCE_FLOAT32_APPLE :: GLenum+gl_LUMINANCE_FLOAT32_APPLE = 0x8818+gl_R32UI :: GLenum+gl_R32UI = 0x8236+gl_UNSIGNED_INT_VEC4_EXT :: GLenum+gl_UNSIGNED_INT_VEC4_EXT = 0x8DC8+gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT :: GLenum+gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 0x8E4C+gl_SAMPLE_MASK_VALUE :: GLenum+gl_SAMPLE_MASK_VALUE = 0x8E52+gl_STRICT_DEPTHFUNC_HINT_PGI :: GLenum+gl_STRICT_DEPTHFUNC_HINT_PGI = 0x1A216+gl_CONVOLUTION_HEIGHT_EXT :: GLenum+gl_CONVOLUTION_HEIGHT_EXT = 0x8019+gl_DEPTH_BUFFER_BIT1_QCOM :: GLenum+gl_DEPTH_BUFFER_BIT1_QCOM = 0x00000200+gl_CLIP_DISTANCE_NV :: GLenum+gl_CLIP_DISTANCE_NV = 0x8C7A+gl_DISPATCH_INDIRECT_BUFFER :: GLenum+gl_DISPATCH_INDIRECT_BUFFER = 0x90EE+gl_LUMINANCE4 :: GLenum+gl_LUMINANCE4 = 0x803F+gl_CLAMP :: GLenum+gl_CLAMP = 0x2900+gl_CONVOLUTION_FORMAT :: GLenum+gl_CONVOLUTION_FORMAT = 0x8017+gl_IMAGE_2D_MULTISAMPLE :: GLenum+gl_IMAGE_2D_MULTISAMPLE = 0x9055+gl_TRIANGLE_STRIP :: GLenum+gl_TRIANGLE_STRIP = 0x0005+gl_BGRA_INTEGER_EXT :: GLenum+gl_BGRA_INTEGER_EXT = 0x8D9B+gl_FRAGMENTS_INSTRUMENT_MAX_SGIX :: GLenum+gl_FRAGMENTS_INSTRUMENT_MAX_SGIX = 0x8315+gl_TESS_CONTROL_SHADER_BIT :: GLenum+gl_TESS_CONTROL_SHADER_BIT = 0x00000008+gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES :: GLenum+gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = 0x8B9F+gl_BACK_NORMALS_HINT_PGI :: GLenum+gl_BACK_NORMALS_HINT_PGI = 0x1A223+gl_FOG_COORD_ARRAY :: GLenum+gl_FOG_COORD_ARRAY = 0x8457+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR :: GLenum+gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D+gl_OPERAND1_RGB_EXT :: GLenum+gl_OPERAND1_RGB_EXT = 0x8591+gl_LINEAR_SHARPEN_COLOR_SGIS :: GLenum+gl_LINEAR_SHARPEN_COLOR_SGIS = 0x80AF+gl_POST_TEXTURE_FILTER_SCALE_SGIX :: GLenum+gl_POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A+gl_FRAMEBUFFER_COMPLETE_OES :: GLenum+gl_FRAMEBUFFER_COMPLETE_OES = 0x8CD5+gl_SYNC_OBJECT_APPLE :: GLenum+gl_SYNC_OBJECT_APPLE = 0x8A53+gl_INDEX_WRITEMASK :: GLenum+gl_INDEX_WRITEMASK = 0x0C21+gl_SIGNED_INTENSITY_NV :: GLenum+gl_SIGNED_INTENSITY_NV = 0x8707+gl_SGX_PROGRAM_BINARY_IMG :: GLenum+gl_SGX_PROGRAM_BINARY_IMG = 0x9130+gl_T4F_V4F :: GLenum+gl_T4F_V4F = 0x2A28++data GLsyncob+type GLsync = Ptr GLsyncob++type GLhalf = Word16+type GLhalfARB = Word16+type GLintptrARB = CPtrdiff+type GLsizeiptrARB = CPtrdiff+type GLDEBUGPROC =+    FunPtr (GLenum -> GLenum -> GLuint -> GLenum -> GLsizei -> Ptr GLchar -> Ptr () -> IO ())+type GLDEBUGPROCARB = GLDEBUGPROC+type GLDEBUGPROCKHR = GLDEBUGPROC+type GLDEBUGPROCAMD =+    FunPtr (GLuint -> GLenum -> GLenum -> GLsizei -> Ptr GLchar -> Ptr () -> IO ())+type GLbyte = CChar+type GLubyte = CUChar+type GLfloat = CFloat+type GLclampf = CFloat+type GLfixed = Int32+type GLint64 = Int64+type GLuint64 = Word64+type GLint64EXT = Int64+type GLuint64EXT = Word64+type GLintptr = CIntPtr+type GLsizeiptr = CSize+type GLhalfNV = CUShort+type GLvdpauSurfaceNV = GLintptr+type GLenum = CUInt+type GLboolean = CUChar+type GLvoid = ()+type GLbitfield = CUInt+type GLshort = CShort+type GLint = CInt+type GLclampx = CInt+type GLushort = CUShort+type GLuint = CUInt+type GLsizei = CInt+type GLdouble = CDouble+type GLclampd = CDouble+data GLeglImageOESob+type GLeglImageOES = Ptr GLeglImageOESob+type GLchar = CChar+type GLcharARB = CChar+#ifdef __APPLE__+type GLhandleARB = Ptr ()+#else+type GLhandleARB = CUInt+#endif+