[PATCH v2 0/7] MR1275: opengl32: Use the unixlib interface in more windows functions.

[Rémi Bernon (＠rbernon)]

--
  v2: opengl32: Move wglGetProcAddress extension filtering to unix_wgl.c.
      opengl32: Move function / extension registry mapping to unix_thunks.c.
      opengl32: Move glGetIntegerv extension filtering to unix_wgl.c.
      opengl32: Move glGetString extension filtering to unix_wgl.c.
      opengl32: Move glGetStringi extension filtering to unix_wgl.c.
      opengl32: Move extension filtering helpers to unix_wgl.c.
      opengl32: Introduce new disabled_extensions_index helper.

https://gitlab.winehq.org/wine/wine/-/merge_requests/1275

[PATCH v2 1/7] opengl32: Introduce new disabled_extensions_index helper.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/wgl.c | 49 ++++++++++++++-------------------------------
 1 file changed, 15 insertions(+), 34 deletions(-)

diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index d5b0a78b916..a9039d606c1 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -455,39 +455,32 @@ static BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLui
     return (exts_list && *exts_list) || *disabled_exts;
 }

+static const GLuint *disabled_extensions_index(void)
+{
+    struct wgl_handle *ptr = get_current_context_ptr();
+    GLuint **disabled = &ptr->u.context->disabled_exts;
+    if (*disabled || filter_extensions( NULL, NULL, disabled )) return *disabled;
+    return NULL;
+}
+
 void WINAPI glGetIntegerv(GLenum pname, GLint *data)
 {
     struct glGetIntegerv_params args = { .pname = pname, .data = data, };
+    const GLuint *disabled;
     NTSTATUS status;

TRACE( "pname %d, data %p\n", pname, data );

-    if (pname == GL_NUM_EXTENSIONS)
-    {
-        struct wgl_handle *ptr = get_current_context_ptr();
-        GLuint **disabled = &ptr->u.context->disabled_exts;
-
-        if (*disabled || filter_extensions( NULL, NULL, disabled ))
-        {
-            const GLuint *disabled_exts = *disabled;
-            GLint count, disabled_count = 0;
-
-            args.data = &count;
-            if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#x\n", status );
-
-            while (*disabled_exts++ != ~0u)
-                disabled_count++;
-            *data = count - disabled_count;
-            return;
-        }
-    }
-
     if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#x\n", status );
+
+    if (pname == GL_NUM_EXTENSIONS && (disabled = disabled_extensions_index()))
+        while (*disabled++ != ~0u) (*data)--;
 }

const GLubyte * WINAPI glGetStringi(GLenum name, GLuint index)
 {
     const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    const GLuint *disabled;

TRACE("(%d, %d)\n", name, index);
     if (!funcs->ext.p_glGetStringi)
@@ -497,21 +490,9 @@ const GLubyte * WINAPI glGetStringi(GLenum name, GLuint index)
         *func_ptr = funcs->wgl.p_wglGetProcAddress("glGetStringi");
     }

-    if (name == GL_EXTENSIONS)
-    {
-        struct wgl_handle *ptr = get_current_context_ptr();
-
-        if (ptr->u.context->disabled_exts ||
-            filter_extensions(NULL, NULL, &ptr->u.context->disabled_exts))
-        {
-            const GLuint *disabled_exts = ptr->u.context->disabled_exts;
-            unsigned int disabled_count = 0;
+    if (name == GL_EXTENSIONS && (disabled = disabled_extensions_index()))
+        while (index >= *disabled++) index++;

-            while (index + disabled_count >= *disabled_exts++)
-                disabled_count++;
-            return funcs->ext.p_glGetStringi(name, index + disabled_count);
-        }
-    }
     return funcs->ext.p_glGetStringi(name, index);
 }

[PATCH v2 2/7] opengl32: Move extension filtering helpers to unix_wgl.c.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/opengl_ext.h |   4 +
 dlls/opengl32/unix_wgl.c   | 181 +++++++++++++++++++++++++++++++++++++
 dlls/opengl32/wgl.c        | 178 ------------------------------------
 3 files changed, 185 insertions(+), 178 deletions(-)

diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index 2a579e142b6..b2c3c681a41 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -101,4 +101,8 @@ static inline enum wgl_handle_type get_current_context_type(void)

extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd );

+extern BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts ) DECLSPEC_HIDDEN;
+extern const GLuint *disabled_extensions_index(void) DECLSPEC_HIDDEN;
+extern BOOL check_extension_support( const char *extension, const char *available_extensions ) DECLSPEC_HIDDEN;
+
 #endif /* __DLLS_OPENGL32_OPENGL_EXT_H */
diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index 4771205a47e..9a96f78dacb 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -27,6 +27,7 @@
 #define WIN32_NO_STATUS
 #include "windef.h"
 #include "winbase.h"
+#include "winreg.h"
 #include "ntuser.h"

#include "opengl_ext.h"
@@ -35,6 +36,8 @@

#include "wine/debug.h"

+WINE_DEFAULT_DEBUG_CHANNEL(wgl);
+
 struct wgl_handle wgl_handles[MAX_WGL_HANDLES];
 static struct wgl_handle *next_free;
 static unsigned int handle_count;
@@ -105,6 +108,184 @@ static void free_handle_ptr( struct wgl_handle *ptr )
     LeaveCriticalSection( &wgl_section );
 }

+/* check if the extension is present in the list */
+static BOOL has_extension( const char *list, const char *ext, size_t len )
+{
+    while (list)
+    {
+        while (*list == ' ') list++;
+        if (!strncmp( list, ext, len ) && (!list[len] || list[len] == ' ')) return TRUE;
+        list = strchr( list, ' ' );
+    }
+    return FALSE;
+}
+
+static GLubyte *filter_extensions_list( const char *extensions, const char *disabled )
+{
+    const char *end;
+    char *p, *str;
+
+    p = str = HeapAlloc( GetProcessHeap(), 0, strlen( extensions ) + 2 );
+    if (!str) return NULL;
+
+    TRACE( "GL_EXTENSIONS:\n" );
+
+    for (;;)
+    {
+        while (*extensions == ' ') extensions++;
+        if (!*extensions) break;
+
+        if (!(end = strchr( extensions, ' ' ))) end = extensions + strlen( extensions );
+        memcpy( p, extensions, end - extensions );
+        p[end - extensions] = 0;
+
+        if (!has_extension( disabled, p, strlen( p ) ))
+        {
+            TRACE( "++ %s\n", p );
+            p += end - extensions;
+            *p++ = ' ';
+        }
+        else
+        {
+            TRACE( "-- %s (disabled by config)\n", p );
+        }
+        extensions = end;
+    }
+    *p = 0;
+    return (GLubyte *)str;
+}
+
+static GLuint *filter_extensions_index( const char *disabled )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    GLuint *disabled_index;
+    GLint extensions_count;
+    unsigned int i = 0, j;
+    const char *ext;
+
+    if (!funcs->ext.p_glGetStringi)
+    {
+        void **func_ptr = (void **)&funcs->ext.p_glGetStringi;
+        *func_ptr = funcs->wgl.p_wglGetProcAddress( "glGetStringi" );
+        if (!funcs->ext.p_glGetStringi) return NULL;
+    }
+
+    funcs->gl.p_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
+    disabled_index = HeapAlloc( GetProcessHeap(), 0, extensions_count * sizeof(*disabled_index) );
+    if (!disabled_index) return NULL;
+
+    TRACE( "GL_EXTENSIONS:\n" );
+
+    for (j = 0; j < extensions_count; ++j)
+    {
+        ext = (const char *)funcs->ext.p_glGetStringi( GL_EXTENSIONS, j );
+        if (!has_extension( disabled, ext, strlen( ext ) ))
+        {
+            TRACE( "++ %s\n", ext );
+        }
+        else
+        {
+            TRACE( "-- %s (disabled by config)\n", ext );
+            disabled_index[i++] = j;
+        }
+    }
+
+    disabled_index[i] = ~0u;
+    return disabled_index;
+}
+
+/* build the extension string by filtering out the disabled extensions */
+BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts )
+{
+    static const char *disabled;
+
+    if (!disabled)
+    {
+        HKEY hkey;
+        DWORD size;
+        char *str = NULL;
+
+        /* @@ Wine registry key: HKCU\Software\Wine\OpenGL */
+        if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\Wine\OpenGL", &hkey ))
+        {
+            if (!RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, NULL, &size ))
+            {
+                str = HeapAlloc( GetProcessHeap(), 0, size );
+                if (RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, (BYTE *)str, &size )) *str = 0;
+            }
+            RegCloseKey( hkey );
+        }
+        if (str)
+        {
+            if (InterlockedCompareExchangePointer( (void **)&disabled, str, NULL ))
+                HeapFree( GetProcessHeap(), 0, str );
+        }
+        else disabled = "";
+    }
+
+    if (!disabled[0]) return FALSE;
+    if (extensions && !*exts_list) *exts_list = filter_extensions_list( extensions, disabled );
+    if (!*disabled_exts) *disabled_exts = filter_extensions_index( disabled );
+    return (exts_list && *exts_list) || *disabled_exts;
+}
+
+const GLuint *disabled_extensions_index(void)
+{
+    struct wgl_handle *ptr = get_current_context_ptr();
+    GLuint **disabled = &ptr->u.context->disabled_exts;
+    if (*disabled || filter_extensions( NULL, NULL, disabled )) return *disabled;
+    return NULL;
+}
+
+/* Check if a GL extension is supported */
+BOOL check_extension_support( const char *extension, const char *available_extensions )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    size_t len;
+
+    TRACE( "Checking for extension '%s'\n", extension );
+
+    /* We use the GetProcAddress function from the display driver to retrieve function pointers
+     * for OpenGL and WGL extensions. In case of winex11.drv the OpenGL extension lookup is done
+     * using glXGetProcAddress. This function is quite unreliable in the sense that its specs don't
+     * require the function to return NULL when an extension isn't found. For this reason we check
+     * if the OpenGL extension required for the function we are looking up is supported. */
+
+    while ((len = strcspn( extension, " " )))
+    {
+        /* Check if the extension is part of the GL extension string to see if it is supported. */
+        if (has_extension( available_extensions, extension, len )) return TRUE;
+
+        /* In general an OpenGL function starts as an ARB/EXT extension and at some stage
+         * it becomes part of the core OpenGL library and can be reached without the ARB/EXT
+         * suffix as well. In the extension table, these functions contain GL_VERSION_major_minor.
+         * Check if we are searching for a core GL function */
+        if (!strncmp( extension, "GL_VERSION_", 11 ))
+        {
+            const GLubyte *gl_version = funcs->gl.p_glGetString( GL_VERSION );
+            const char *version = extension + 11; /* Move past 'GL_VERSION_' */
+
+            if (!gl_version)
+            {
+                ERR( "No OpenGL version found!\n" );
+                return FALSE;
+            }
+
+            /* Compare the major/minor version numbers of the native OpenGL library and what is required by the function.
+             * The gl_version string is guaranteed to have at least a major/minor and sometimes it has a release number as well. */
+            if ((gl_version[0] > version[0]) || ((gl_version[0] == version[0]) && (gl_version[2] >= version[2]))) return TRUE;
+
+            WARN( "The function requires OpenGL version '%c.%c' while your drivers only provide '%c.%c'\n",
+                  version[0], version[2], gl_version[0], gl_version[2] );
+        }
+
+        if (extension[len] == ' ') len++;
+        extension += len;
+    }
+
+    return FALSE;
+}
+
 static BOOL wrap_wglCopyContext( HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask )
 {
     struct wgl_handle *src, *dst;
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index a9039d606c1..60ba7bf3bdf 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -334,135 +334,6 @@ int WINAPI wglGetLayerPaletteEntries(HDC hdc,
   return 0;
 }

-/* check if the extension is present in the list */
-static BOOL has_extension( const char *list, const char *ext, size_t len )
-{
-    while (list)
-    {
-        while (*list == ' ') list++;
-        if (!strncmp( list, ext, len ) && (!list[len] || list[len] == ' ')) return TRUE;
-        list = strchr( list, ' ' );
-    }
-    return FALSE;
-}
-
-static GLubyte *filter_extensions_list( const char *extensions, const char *disabled )
-{
-    const char *end;
-    char *p, *str;
-
-    p = str = HeapAlloc( GetProcessHeap(), 0, strlen( extensions ) + 2 );
-    if (!str) return NULL;
-
-    TRACE( "GL_EXTENSIONS:\n" );
-
-    for (;;)
-    {
-        while (*extensions == ' ') extensions++;
-        if (!*extensions) break;
-
-        if (!(end = strchr( extensions, ' ' ))) end = extensions + strlen( extensions );
-        memcpy( p, extensions, end - extensions );
-        p[end - extensions] = 0;
-
-        if (!has_extension( disabled, p, strlen( p ) ))
-        {
-            TRACE( "++ %s\n", p );
-            p += end - extensions;
-            *p++ = ' ';
-        }
-        else
-        {
-            TRACE( "-- %s (disabled by config)\n", p );
-        }
-        extensions = end;
-    }
-    *p = 0;
-    return (GLubyte *)str;
-}
-
-static GLuint *filter_extensions_index( const char *disabled )
-{
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    GLuint *disabled_index;
-    GLint extensions_count;
-    unsigned int i = 0, j;
-    const char *ext;
-
-    if (!funcs->ext.p_glGetStringi)
-    {
-        void **func_ptr = (void **)&funcs->ext.p_glGetStringi;
-        *func_ptr = funcs->wgl.p_wglGetProcAddress( "glGetStringi" );
-        if (!funcs->ext.p_glGetStringi) return NULL;
-    }
-
-    funcs->gl.p_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
-    disabled_index = HeapAlloc( GetProcessHeap(), 0, extensions_count * sizeof(*disabled_index) );
-    if (!disabled_index) return NULL;
-
-    TRACE( "GL_EXTENSIONS:\n" );
-
-    for (j = 0; j < extensions_count; ++j)
-    {
-        ext = (const char *)funcs->ext.p_glGetStringi( GL_EXTENSIONS, j );
-        if (!has_extension( disabled, ext, strlen( ext ) ))
-        {
-            TRACE( "++ %s\n", ext );
-        }
-        else
-        {
-            TRACE( "-- %s (disabled by config)\n", ext );
-            disabled_index[i++] = j;
-        }
-    }
-
-    disabled_index[i] = ~0u;
-    return disabled_index;
-}
-
-/* build the extension string by filtering out the disabled extensions */
-static BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts )
-{
-    static const char *disabled;
-
-    if (!disabled)
-    {
-        HKEY hkey;
-        DWORD size;
-        char *str = NULL;
-
-        /* @@ Wine registry key: HKCU\Software\Wine\OpenGL */
-        if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\Wine\OpenGL", &hkey ))
-        {
-            if (!RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, NULL, &size ))
-            {
-                str = HeapAlloc( GetProcessHeap(), 0, size );
-                if (RegQueryValueExA( hkey, "DisabledExtensions", 0, NULL, (BYTE *)str, &size )) *str = 0;
-            }
-            RegCloseKey( hkey );
-        }
-        if (str)
-        {
-            if (InterlockedCompareExchangePointer( (void **)&disabled, str, NULL ))
-                HeapFree( GetProcessHeap(), 0, str );
-        }
-        else disabled = "";
-    }
-
-    if (!disabled[0]) return FALSE;
-    if (extensions && !*exts_list) *exts_list = filter_extensions_list( extensions, disabled );
-    if (!*disabled_exts) *disabled_exts = filter_extensions_index( disabled );
-    return (exts_list && *exts_list) || *disabled_exts;
-}
-
-static const GLuint *disabled_extensions_index(void)
-{
-    struct wgl_handle *ptr = get_current_context_ptr();
-    GLuint **disabled = &ptr->u.context->disabled_exts;
-    if (*disabled || filter_extensions( NULL, NULL, disabled )) return *disabled;
-    return NULL;
-}
-
 void WINAPI glGetIntegerv(GLenum pname, GLint *data)
 {
     struct glGetIntegerv_params args = { .pname = pname, .data = data, };
@@ -501,55 +372,6 @@ static int compar(const void *elt_a, const void *elt_b) {
    	((const OpenGL_extension *) elt_b)->name);
 }

-/* Check if a GL extension is supported */
-static BOOL check_extension_support( const char *extension, const char *available_extensions )
-{
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    size_t len;
-
-    TRACE("Checking for extension '%s'\n", extension);
-
-    /* We use the GetProcAddress function from the display driver to retrieve function pointers
-     * for OpenGL and WGL extensions. In case of winex11.drv the OpenGL extension lookup is done
-     * using glXGetProcAddress. This function is quite unreliable in the sense that its specs don't
-     * require the function to return NULL when an extension isn't found. For this reason we check
-     * if the OpenGL extension required for the function we are looking up is supported. */
-
-    while ((len = strcspn( extension, " " )))
-    {
-        /* Check if the extension is part of the GL extension string to see if it is supported. */
-        if (has_extension( available_extensions, extension, len )) return TRUE;
-
-        /* In general an OpenGL function starts as an ARB/EXT extension and at some stage
-         * it becomes part of the core OpenGL library and can be reached without the ARB/EXT
-         * suffix as well. In the extension table, these functions contain GL_VERSION_major_minor.
-         * Check if we are searching for a core GL function */
-        if (!strncmp( extension, "GL_VERSION_", 11 ))
-        {
-            const GLubyte *gl_version = funcs->gl.p_glGetString(GL_VERSION);
-            const char *version = extension + 11; /* Move past 'GL_VERSION_' */
-
-            if (!gl_version)
-            {
-                ERR( "No OpenGL version found!\n" );
-                return FALSE;
-            }
-
-            /* Compare the major/minor version numbers of the native OpenGL library and what is required by the function.
-             * The gl_version string is guaranteed to have at least a major/minor and sometimes it has a release number as well. */
-            if ((gl_version[0] > version[0]) || ((gl_version[0] == version[0]) && (gl_version[2] >= version[2]))) return TRUE;
-
-            WARN( "The function requires OpenGL version '%c.%c' while your drivers only provide '%c.%c'\n",
-                  version[0], version[2], gl_version[0], gl_version[2] );
-        }
-
-        if (extension[len] == ' ') len++;
-        extension += len;
-    }
-
-    return FALSE;
-}
-
 static char *build_extension_list(void)
 {
     GLint len = 0, capacity, i, extensions_count;

[PATCH v2 3/7] opengl32: Move glGetStringi extension filtering to unix_wgl.c.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/make_opengl   |  3 +--
 dlls/opengl32/opengl_ext.h  |  1 +
 dlls/opengl32/thunks.c      | 10 +++++++-
 dlls/opengl32/unix_thunks.c |  9 +-------
 dlls/opengl32/unix_wgl.c    | 46 +++++++++++++++++++++++++++++++++++++
 dlls/opengl32/wgl.c         | 41 ---------------------------------
 6 files changed, 58 insertions(+), 52 deletions(-)

diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 78368ec6c2f..733b5795306 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -163,7 +163,6 @@ my %manual_win_thunks =
     (
      "glGetIntegerv" => 1,
      "glGetString" => 1,
-     "glGetStringi" => 1,
      "wglGetCurrentReadDCARB" => 1,
      "wglGetPixelFormat" => 1,
      "wglGetProcAddress" => 1,
@@ -511,7 +510,7 @@ sub needs_wrapper($$)
 {
     my ($name, $func) = @_;

-    return 1 if $name =~ /^glDebugMessageCallback/;
+    return 1 if $name =~ /^glDebugMessageCallback|^glGetStringi/;

# check if return value needs special handling
     (my $type = $func->[0]->textContent()) =~ s/ $//;
diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index b2c3c681a41..132a414399d 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -104,5 +104,6 @@ extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFO
 extern BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts ) DECLSPEC_HIDDEN;
 extern const GLuint *disabled_extensions_index(void) DECLSPEC_HIDDEN;
 extern BOOL check_extension_support( const char *extension, const char *available_extensions ) DECLSPEC_HIDDEN;
+extern char *build_extension_list(void) DECLSPEC_HIDDEN;

#endif /* __DLLS_OPENGL32_OPENGL_EXT_H */
diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c
index a2a78bff97d..ca133a25830 100644
--- a/dlls/opengl32/thunks.c
+++ b/dlls/opengl32/thunks.c
@@ -9898,6 +9898,15 @@ static GLushort WINAPI glGetStageIndexNV( GLenum shadertype )
     return args.ret;
 }

+static const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index )
+{
+    struct glGetStringi_params args = { .name = name, .index = index, };
+    NTSTATUS status;
+    TRACE( "name %d, index %d\n", name, index );
+    if ((status = UNIX_CALL( glGetStringi, &args ))) WARN( "glGetStringi returned %#x\n", status );
+    return args.ret;
+}
+
 static GLuint WINAPI glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name )
 {
     struct glGetSubroutineIndex_params args = { .program = program, .shadertype = shadertype, .name = name, };
@@ -24462,7 +24471,6 @@ static BOOL WINAPI wglSwapIntervalEXT( int interval )
     return args.ret;
 }

-extern const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) DECLSPEC_HIDDEN;
 extern HDC WINAPI wglGetCurrentReadDCARB(void) DECLSPEC_HIDDEN;

const int extension_registry_size = 2694;
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
index 86af754b278..3f00f6ce394 100644
--- a/dlls/opengl32/unix_thunks.c
+++ b/dlls/opengl32/unix_thunks.c
@@ -21,6 +21,7 @@ extern NTSTATUS wgl_wglShareLists( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallback( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallbackAMD( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallbackARB( void *args ) DECLSPEC_HIDDEN;
+extern NTSTATUS ext_glGetStringi( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_wglBindTexImageARB( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_wglCreateContextAttribsARB( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_wglCreatePbufferARB( void *args ) DECLSPEC_HIDDEN;
@@ -9797,14 +9798,6 @@ static NTSTATUS ext_glGetStageIndexNV( void *args )
     return STATUS_SUCCESS;
 }

-static NTSTATUS ext_glGetStringi( void *args )
-{
-    struct glGetStringi_params *params = args;
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    params->ret = funcs->ext.p_glGetStringi( params->name, params->index );
-    return STATUS_SUCCESS;
-}
-
 static NTSTATUS ext_glGetSubroutineIndex( void *args )
 {
     struct glGetSubroutineIndex_params *params = args;
diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index 9a96f78dacb..4fe594d42f9 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -286,6 +286,45 @@ BOOL check_extension_support( const char *extension, const char *available_exten
     return FALSE;
 }

+static const GLubyte * WINAPI wrap_glGetStringi( GLenum name, GLuint index )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    const GLuint *disabled;
+
+    if (!funcs->ext.p_glGetStringi)
+    {
+        void **func_ptr = (void **)&funcs->ext.p_glGetStringi;
+        *func_ptr = funcs->wgl.p_wglGetProcAddress( "glGetStringi" );
+    }
+
+    if (name == GL_EXTENSIONS && (disabled = disabled_extensions_index()))
+        while (index >= *disabled++) index++;
+
+    return funcs->ext.p_glGetStringi( name, index );
+}
+
+char *build_extension_list(void)
+{
+    GLint len = 0, capacity, i, extensions_count;
+    char *extension, *tmp, *available_extensions;
+
+    glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
+    capacity = 128 * extensions_count;
+
+    if (!(available_extensions = HeapAlloc( GetProcessHeap(), 0, capacity ))) return NULL;
+    for (i = 0; i < extensions_count; ++i)
+    {
+        extension = (char *)wrap_glGetStringi( GL_EXTENSIONS, i );
+        capacity = max( capacity, len + strlen( extension ) + 2 );
+        if (!(tmp = HeapReAlloc( GetProcessHeap(), 0, available_extensions, capacity ))) break;
+        available_extensions = tmp;
+        len += sprintf( available_extensions + len, "%s ", extension );
+    }
+    if (len) available_extensions[len - 1] = 0;
+
+    return available_extensions;
+}
+
 static BOOL wrap_wglCopyContext( HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask )
 {
     struct wgl_handle *src, *dst;
@@ -691,6 +730,13 @@ NTSTATUS ext_glDebugMessageCallbackARB( void *args )
     return STATUS_SUCCESS;
 }

+NTSTATUS ext_glGetStringi( void *args )
+{
+    struct glGetStringi_params *params = args;
+    params->ret = wrap_glGetStringi( params->name, params->index );
+    return STATUS_SUCCESS;
+}
+
 NTSTATUS ext_wglBindTexImageARB( void *args )
 {
     struct wglBindTexImageARB_params *params = args;
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index 60ba7bf3bdf..ec1e875c56c 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -348,52 +348,11 @@ void WINAPI glGetIntegerv(GLenum pname, GLint *data)
         while (*disabled++ != ~0u) (*data)--;
 }

-const GLubyte * WINAPI glGetStringi(GLenum name, GLuint index)
-{
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    const GLuint *disabled;
-
-    TRACE("(%d, %d)\n", name, index);
-    if (!funcs->ext.p_glGetStringi)
-    {
-        void **func_ptr = (void **)&funcs->ext.p_glGetStringi;
-
-        *func_ptr = funcs->wgl.p_wglGetProcAddress("glGetStringi");
-    }
-
-    if (name == GL_EXTENSIONS && (disabled = disabled_extensions_index()))
-        while (index >= *disabled++) index++;
-
-    return funcs->ext.p_glGetStringi(name, index);
-}
-
 static int compar(const void *elt_a, const void *elt_b) {
   return strcmp(((const OpenGL_extension *) elt_a)->name,
    	((const OpenGL_extension *) elt_b)->name);
 }

-static char *build_extension_list(void)
-{
-    GLint len = 0, capacity, i, extensions_count;
-    char *extension, *tmp, *available_extensions;
-
-    glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
-    capacity = 128 * extensions_count;
-
-    if (!(available_extensions = HeapAlloc( GetProcessHeap(), 0, capacity ))) return NULL;
-    for (i = 0; i < extensions_count; ++i)
-    {
-        extension = (char *)glGetStringi( GL_EXTENSIONS, i );
-        capacity = max( capacity, len + strlen( extension ) + 2 );
-        if (!(tmp = HeapReAlloc( GetProcessHeap(), 0, available_extensions, capacity ))) break;
-        available_extensions = tmp;
-        len += sprintf( available_extensions + len, "%s ", extension );
-    }
-    if (len) available_extensions[len - 1] = 0;
-
-    return available_extensions;
-}
-
 static char *heap_strdup( const char *str )
 {
     int len = strlen( str ) + 1;

[PATCH v2 4/7] opengl32: Move glGetString extension filtering to unix_wgl.c.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/make_opengl   | 10 ++++++++--
 dlls/opengl32/opengl_ext.h  |  1 -
 dlls/opengl32/thunks.c      |  9 +++++++++
 dlls/opengl32/unix_thunks.c |  9 +--------
 dlls/opengl32/unix_wgl.c    | 25 ++++++++++++++++++++++++-
 dlls/opengl32/wgl.c         | 23 -----------------------
 6 files changed, 42 insertions(+), 35 deletions(-)

diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 733b5795306..5e269d89109 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -162,7 +162,6 @@ my %manual_win_functions =
 my %manual_win_thunks =
     (
      "glGetIntegerv" => 1,
-     "glGetString" => 1,
      "wglGetCurrentReadDCARB" => 1,
      "wglGetPixelFormat" => 1,
      "wglGetProcAddress" => 1,
@@ -510,7 +509,7 @@ sub needs_wrapper($$)
 {
     my ($name, $func) = @_;

-    return 1 if $name =~ /^glDebugMessageCallback|^glGetStringi/;
+    return 1 if $name =~ /^glDebugMessageCallback|^glGetString/;

# check if return value needs special handling
     (my $type = $func->[0]->textContent()) =~ s/ $//;
@@ -941,6 +940,12 @@ foreach (sort keys %wgl_functions)
     next unless needs_wrapper( $_, $wgl_functions{$_} );
     print OUT "extern NTSTATUS wgl_$_( void *args ) DECLSPEC_HIDDEN;\n";
 }
+foreach (sort keys %norm_functions)
+{
+    next if defined $manual_win_functions{$_};
+    next unless needs_wrapper( $_, $norm_functions{$_} );
+    print OUT "extern NTSTATUS gl_$_( void *args ) DECLSPEC_HIDDEN;\n";
+}
 foreach (sort keys %ext_functions)
 {
     next if defined $manual_win_functions{$_};
@@ -958,6 +963,7 @@ foreach (sort keys %wgl_functions)
 foreach (sort keys %norm_functions)
 {
     next if defined $manual_win_functions{$_};
+    next if needs_wrapper( $_, $norm_functions{$_} );
     print OUT generate_unix_thunk($_, $norm_functions{$_}, "gl");
 }
 foreach (sort keys %ext_functions)
diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index 132a414399d..6e069cf5bd5 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -101,7 +101,6 @@ static inline enum wgl_handle_type get_current_context_type(void)

extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd );

-extern BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts ) DECLSPEC_HIDDEN;
 extern const GLuint *disabled_extensions_index(void) DECLSPEC_HIDDEN;
 extern BOOL check_extension_support( const char *extension, const char *available_extensions ) DECLSPEC_HIDDEN;
 extern char *build_extension_list(void) DECLSPEC_HIDDEN;
diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c
index ca133a25830..0a9fb8bb677 100644
--- a/dlls/opengl32/thunks.c
+++ b/dlls/opengl32/thunks.c
@@ -1011,6 +1011,15 @@ void WINAPI glGetPolygonStipple( GLubyte *mask )
     if ((status = UNIX_CALL( glGetPolygonStipple, &args ))) WARN( "glGetPolygonStipple returned %#x\n", status );
 }

+const GLubyte * WINAPI glGetString( GLenum name )
+{
+    struct glGetString_params args = { .name = name, };
+    NTSTATUS status;
+    TRACE( "name %d\n", name );
+    if ((status = UNIX_CALL( glGetString, &args ))) WARN( "glGetString returned %#x\n", status );
+    return args.ret;
+}
+
 void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
 {
     struct glGetTexEnvfv_params args = { .target = target, .pname = pname, .params = params, };
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
index 3f00f6ce394..375d1630cf9 100644
--- a/dlls/opengl32/unix_thunks.c
+++ b/dlls/opengl32/unix_thunks.c
@@ -18,6 +18,7 @@ extern NTSTATUS wgl_wglCreateContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglDeleteContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglMakeCurrent( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglShareLists( void *args ) DECLSPEC_HIDDEN;
+extern NTSTATUS gl_glGetString( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallback( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallbackAMD( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallbackARB( void *args ) DECLSPEC_HIDDEN;
@@ -1009,14 +1010,6 @@ static NTSTATUS gl_glGetPolygonStipple( void *args )
     return STATUS_SUCCESS;
 }

-static NTSTATUS gl_glGetString( void *args )
-{
-    struct glGetString_params *params = args;
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    params->ret = funcs->gl.p_glGetString( params->name );
-    return STATUS_SUCCESS;
-}
-
 static NTSTATUS gl_glGetTexEnvfv( void *args )
 {
     struct glGetTexEnvfv_params *params = args;
diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index 4fe594d42f9..a0207ad533a 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -195,7 +195,7 @@ static GLuint *filter_extensions_index( const char *disabled )
 }

/* build the extension string by filtering out the disabled extensions */
-BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts )
+static BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts )
 {
     static const char *disabled;

@@ -286,6 +286,22 @@ BOOL check_extension_support( const char *extension, const char *available_exten
     return FALSE;
 }

+static const GLubyte * WINAPI wrap_glGetString( GLenum name )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    const GLubyte *ret;
+
+    if ((ret = funcs->gl.p_glGetString( name )) && name == GL_EXTENSIONS)
+    {
+        struct wgl_handle *ptr = get_current_context_ptr();
+        GLubyte **extensions = &ptr->u.context->extensions;
+        GLuint **disabled = &ptr->u.context->disabled_exts;
+        if (*extensions || filter_extensions( (const char *)ret, extensions, disabled )) return *extensions;
+    }
+
+    return ret;
+}
+
 static const GLubyte * WINAPI wrap_glGetStringi( GLenum name, GLuint index )
 {
     const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
@@ -711,6 +727,13 @@ NTSTATUS wgl_wglShareLists( void *args )
     return STATUS_SUCCESS;
 }

+NTSTATUS gl_glGetString( void *args )
+{
+    struct glGetString_params *params = args;
+    params->ret = wrap_glGetString( params->name );
+    return STATUS_SUCCESS;
+}
+
 NTSTATUS ext_glDebugMessageCallback( void *args )
 {
     struct glDebugMessageCallback_params *params = args;
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index ec1e875c56c..3aa37bd5cb4 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -955,29 +955,6 @@ GLint WINAPI glDebugEntry( GLint unknown1, GLint unknown2 )
     return 0;
 }

-/***********************************************************************
- *              glGetString (OPENGL32.@)
- */
-const GLubyte * WINAPI glGetString( GLenum name )
-{
-    struct glGetString_params args = { .name = name, };
-    NTSTATUS status;
-
-    TRACE( "name %d\n", name );
-
-    if ((status = UNIX_CALL( glGetString, &args ))) WARN( "glGetString returned %#x\n", status );
-
-    if (name == GL_EXTENSIONS && args.ret)
-    {
-        struct wgl_handle *ptr = get_current_context_ptr();
-        GLubyte **extensions = &ptr->u.context->extensions;
-        GLuint **disabled = &ptr->u.context->disabled_exts;
-        if (*extensions || filter_extensions( (const char *)args.ret, extensions, disabled )) return *extensions;
-    }
-
-    return args.ret;
-}
-
 static BOOL WINAPI call_opengl_debug_message_callback( struct wine_gl_debug_message_params *params, ULONG size )
 {
     params->user_callback( params->source, params->type, params->id, params->severity,

[PATCH v2 5/7] opengl32: Move glGetIntegerv extension filtering to unix_wgl.c.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/make_opengl   |  3 +--
 dlls/opengl32/opengl_ext.h  |  1 -
 dlls/opengl32/thunks.c      |  8 ++++++++
 dlls/opengl32/unix_thunks.c |  9 +--------
 dlls/opengl32/unix_wgl.c    | 22 ++++++++++++++++++++--
 dlls/opengl32/wgl.c         | 14 --------------
 6 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 5e269d89109..a5326d5f40d 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -161,7 +161,6 @@ my %manual_win_functions =
     );
 my %manual_win_thunks =
     (
-     "glGetIntegerv" => 1,
      "wglGetCurrentReadDCARB" => 1,
      "wglGetPixelFormat" => 1,
      "wglGetProcAddress" => 1,
@@ -509,7 +508,7 @@ sub needs_wrapper($$)
 {
     my ($name, $func) = @_;

-    return 1 if $name =~ /^glDebugMessageCallback|^glGetString/;
+    return 1 if $name =~ /^glDebugMessageCallback|^glGetString|^glGetIntegerv/;

# check if return value needs special handling
     (my $type = $func->[0]->textContent()) =~ s/ $//;
diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index 6e069cf5bd5..3638494829c 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -101,7 +101,6 @@ static inline enum wgl_handle_type get_current_context_type(void)

extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd );

-extern const GLuint *disabled_extensions_index(void) DECLSPEC_HIDDEN;
 extern BOOL check_extension_support( const char *extension, const char *available_extensions ) DECLSPEC_HIDDEN;
 extern char *build_extension_list(void) DECLSPEC_HIDDEN;

diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c
index 0a9fb8bb677..a5a117657fc 100644
--- a/dlls/opengl32/thunks.c
+++ b/dlls/opengl32/thunks.c
@@ -915,6 +915,14 @@ void WINAPI glGetFloatv( GLenum pname, GLfloat *data )
     if ((status = UNIX_CALL( glGetFloatv, &args ))) WARN( "glGetFloatv returned %#x\n", status );
 }

+void WINAPI glGetIntegerv( GLenum pname, GLint *data )
+{
+    struct glGetIntegerv_params args = { .pname = pname, .data = data, };
+    NTSTATUS status;
+    TRACE( "pname %d, data %p\n", pname, data );
+    if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#x\n", status );
+}
+
 void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
 {
     struct glGetLightfv_params args = { .light = light, .pname = pname, .params = params, };
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
index 375d1630cf9..41374ed9d74 100644
--- a/dlls/opengl32/unix_thunks.c
+++ b/dlls/opengl32/unix_thunks.c
@@ -18,6 +18,7 @@ extern NTSTATUS wgl_wglCreateContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglDeleteContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglMakeCurrent( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglShareLists( void *args ) DECLSPEC_HIDDEN;
+extern NTSTATUS gl_glGetIntegerv( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS gl_glGetString( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallback( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS ext_glDebugMessageCallbackAMD( void *args ) DECLSPEC_HIDDEN;
@@ -906,14 +907,6 @@ static NTSTATUS gl_glGetFloatv( void *args )
     return STATUS_SUCCESS;
 }

-static NTSTATUS gl_glGetIntegerv( void *args )
-{
-    struct glGetIntegerv_params *params = args;
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    funcs->gl.p_glGetIntegerv( params->pname, params->data );
-    return STATUS_SUCCESS;
-}
-
 static NTSTATUS gl_glGetLightfv( void *args )
 {
     struct glGetLightfv_params *params = args;
diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index a0207ad533a..3213bfcb6bc 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -229,7 +229,7 @@ static BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLui
     return (exts_list && *exts_list) || *disabled_exts;
 }

-const GLuint *disabled_extensions_index(void)
+static const GLuint *disabled_extensions_index(void)
 {
     struct wgl_handle *ptr = get_current_context_ptr();
     GLuint **disabled = &ptr->u.context->disabled_exts;
@@ -286,6 +286,17 @@ BOOL check_extension_support( const char *extension, const char *available_exten
     return FALSE;
 }

+static void WINAPI wrap_glGetIntegerv( GLenum pname, GLint *data )
+{
+    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    const GLuint *disabled;
+
+    funcs->gl.p_glGetIntegerv( pname, data );
+
+    if (pname == GL_NUM_EXTENSIONS && (disabled = disabled_extensions_index()))
+        while (*disabled++ != ~0u) (*data)--;
+}
+
 static const GLubyte * WINAPI wrap_glGetString( GLenum name )
 {
     const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
@@ -324,7 +335,7 @@ char *build_extension_list(void)
     GLint len = 0, capacity, i, extensions_count;
     char *extension, *tmp, *available_extensions;

-    glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
+    wrap_glGetIntegerv( GL_NUM_EXTENSIONS, &extensions_count );
     capacity = 128 * extensions_count;

if (!(available_extensions = HeapAlloc( GetProcessHeap(), 0, capacity ))) return NULL;
@@ -727,6 +738,13 @@ NTSTATUS wgl_wglShareLists( void *args )
     return STATUS_SUCCESS;
 }

+NTSTATUS gl_glGetIntegerv( void *args )
+{
+    struct glGetIntegerv_params *params = args;
+    wrap_glGetIntegerv( params->pname, params->data );
+    return STATUS_SUCCESS;
+}
+
 NTSTATUS gl_glGetString( void *args )
 {
     struct glGetString_params *params = args;
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index 3aa37bd5cb4..a39bbcdd000 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -334,20 +334,6 @@ int WINAPI wglGetLayerPaletteEntries(HDC hdc,
   return 0;
 }

-void WINAPI glGetIntegerv(GLenum pname, GLint *data)
-{
-    struct glGetIntegerv_params args = { .pname = pname, .data = data, };
-    const GLuint *disabled;
-    NTSTATUS status;
-
-    TRACE( "pname %d, data %p\n", pname, data );
-
-    if ((status = UNIX_CALL( glGetIntegerv, &args ))) WARN( "glGetIntegerv returned %#x\n", status );
-
-    if (pname == GL_NUM_EXTENSIONS && (disabled = disabled_extensions_index()))
-        while (*disabled++ != ~0u) (*data)--;
-}
-
 static int compar(const void *elt_a, const void *elt_b) {
   return strcmp(((const OpenGL_extension *) elt_a)->name,
    	((const OpenGL_extension *) elt_b)->name);

[PATCH v2 6/7] opengl32: Move function / extension registry mapping to unix_thunks.c.

[Rémi Bernon]

From: Rémi Bernon

Keeping the extension function pointers array on the PE side.
---
 dlls/opengl32/make_opengl   |   20 +-
 dlls/opengl32/opengl_ext.h  |   13 +-
 dlls/opengl32/thunks.c      | 5394 +++++++++++++++++------------------
 dlls/opengl32/unix_thunks.c | 2699 ++++++++++++++++++
 dlls/opengl32/wgl.c         |   32 +-
 5 files changed, 5432 insertions(+), 2726 deletions(-)

diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index a5326d5f40d..1ebd6e01bb8 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -901,15 +901,11 @@ foreach (sort keys %ext_functions)
     printf OUT "extern %s WINAPI %s(%s) DECLSPEC_HIDDEN;\n", $func_ret, $_, $decl_args;
 }

-# Then the table giving the string <-> function correspondence */
-my $count = keys %ext_functions;
-print OUT "\nconst int extension_registry_size = $count;\n";
-print OUT "const OpenGL_extension extension_registry[$count] =\n";
+print OUT "const void *extension_procs[] =\n";
 print OUT "{\n";
 foreach (sort keys %ext_functions)
 {
-    my $func = $ext_functions{$_};
-    printf OUT "    { "%s", "%s", %s },\n", $_, join(" ", sort @{$func->[2]}), $_;
+    printf OUT "    &%s,\n", $_;
 }
 print OUT "};\n";

@@ -1034,4 +1030,16 @@ foreach (sort keys %ext_functions)
 print OUT "    },\n";
 print OUT "};\n";

+# Then the table giving the string <-> function correspondence */
+my $count = keys %ext_functions;
+print OUT "\nconst int extension_registry_size = $count;\n";
+print OUT "const struct registry_entry extension_registry[$count] =\n";
+print OUT "{\n";
+foreach (sort keys %ext_functions)
+{
+    my $func = $ext_functions{$_};
+    printf OUT "    { "%s", "%s" },\n", $_, join(" ", sort @{$func->[2]});
+}
+print OUT "};\n";
+
 close OUT;
diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index 3638494829c..7b19e302e82 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -30,14 +30,15 @@
 #include "wine/wgl.h"
 #include "wine/wgl_driver.h"

-typedef struct {
-  const char  *name;     /* name of the extension */
-  const char  *extension; /* name of the GL/WGL extension */
-  void  *func;     /* pointer to the Wine function for this extension */
-} OpenGL_extension;
+struct registry_entry
+{
+    const char *name;     /* name of the extension */
+    const char *extension; /* name of the GL/WGL extension */
+};

-extern const OpenGL_extension extension_registry[] DECLSPEC_HIDDEN;
+extern const struct registry_entry extension_registry[] DECLSPEC_HIDDEN;
 extern const int extension_registry_size DECLSPEC_HIDDEN;
+extern const void *extension_procs[] DECLSPEC_HIDDEN;
 extern struct opengl_funcs null_opengl_funcs DECLSPEC_HIDDEN;

static inline struct opengl_funcs *get_dc_funcs( HDC hdc )
diff --git a/dlls/opengl32/thunks.c b/dlls/opengl32/thunks.c
index a5a117657fc..4bad067050d 100644
--- a/dlls/opengl32/thunks.c
+++ b/dlls/opengl32/thunks.c
@@ -24489,2702 +24489,2700 @@ static BOOL WINAPI wglSwapIntervalEXT( int interval )
 }

extern HDC WINAPI wglGetCurrentReadDCARB(void) DECLSPEC_HIDDEN;
-
-const int extension_registry_size = 2694;
-const OpenGL_extension extension_registry[2694] =
-{
-    { "glAccumxOES", "GL_OES_fixed_point", glAccumxOES },
-    { "glAcquireKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex", glAcquireKeyedMutexWin32EXT },
-    { "glActiveProgramEXT", "GL_EXT_separate_shader_objects", glActiveProgramEXT },
-    { "glActiveShaderProgram", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glActiveShaderProgram },
-    { "glActiveStencilFaceEXT", "GL_EXT_stencil_two_side", glActiveStencilFaceEXT },
-    { "glActiveTexture", "GL_VERSION_1_3", glActiveTexture },
-    { "glActiveTextureARB", "GL_ARB_multitexture", glActiveTextureARB },
-    { "glActiveVaryingNV", "GL_NV_transform_feedback", glActiveVaryingNV },
-    { "glAlphaFragmentOp1ATI", "GL_ATI_fragment_shader", glAlphaFragmentOp1ATI },
-    { "glAlphaFragmentOp2ATI", "GL_ATI_fragment_shader", glAlphaFragmentOp2ATI },
-    { "glAlphaFragmentOp3ATI", "GL_ATI_fragment_shader", glAlphaFragmentOp3ATI },
-    { "glAlphaFuncxOES", "GL_OES_fixed_point", glAlphaFuncxOES },
-    { "glAlphaToCoverageDitherControlNV", "GL_NV_alpha_to_coverage_dither_control", glAlphaToCoverageDitherControlNV },
-    { "glApplyFramebufferAttachmentCMAAINTEL", "GL_INTEL_framebuffer_CMAA", glApplyFramebufferAttachmentCMAAINTEL },
-    { "glApplyTextureEXT", "GL_EXT_light_texture", glApplyTextureEXT },
-    { "glAreProgramsResidentNV", "GL_NV_vertex_program", glAreProgramsResidentNV },
-    { "glAreTexturesResidentEXT", "GL_EXT_texture_object", glAreTexturesResidentEXT },
-    { "glArrayElementEXT", "GL_EXT_vertex_array", glArrayElementEXT },
-    { "glArrayObjectATI", "GL_ATI_vertex_array_object", glArrayObjectATI },
-    { "glAsyncCopyBufferSubDataNVX", "GL_NVX_gpu_multicast2", glAsyncCopyBufferSubDataNVX },
-    { "glAsyncCopyImageSubDataNVX", "GL_NVX_gpu_multicast2", glAsyncCopyImageSubDataNVX },
-    { "glAsyncMarkerSGIX", "GL_SGIX_async", glAsyncMarkerSGIX },
-    { "glAttachObjectARB", "GL_ARB_shader_objects", glAttachObjectARB },
-    { "glAttachShader", "GL_VERSION_2_0", glAttachShader },
-    { "glBeginConditionalRender", "GL_VERSION_3_0", glBeginConditionalRender },
-    { "glBeginConditionalRenderNV", "GL_NV_conditional_render", glBeginConditionalRenderNV },
-    { "glBeginConditionalRenderNVX", "GL_NVX_conditional_render", glBeginConditionalRenderNVX },
-    { "glBeginFragmentShaderATI", "GL_ATI_fragment_shader", glBeginFragmentShaderATI },
-    { "glBeginOcclusionQueryNV", "GL_NV_occlusion_query", glBeginOcclusionQueryNV },
-    { "glBeginPerfMonitorAMD", "GL_AMD_performance_monitor", glBeginPerfMonitorAMD },
-    { "glBeginPerfQueryINTEL", "GL_INTEL_performance_query", glBeginPerfQueryINTEL },
-    { "glBeginQuery", "GL_VERSION_1_5", glBeginQuery },
-    { "glBeginQueryARB", "GL_ARB_occlusion_query", glBeginQueryARB },
-    { "glBeginQueryIndexed", "GL_ARB_transform_feedback3 GL_VERSION_4_0", glBeginQueryIndexed },
-    { "glBeginTransformFeedback", "GL_VERSION_3_0", glBeginTransformFeedback },
-    { "glBeginTransformFeedbackEXT", "GL_EXT_transform_feedback", glBeginTransformFeedbackEXT },
-    { "glBeginTransformFeedbackNV", "GL_NV_transform_feedback", glBeginTransformFeedbackNV },
-    { "glBeginVertexShaderEXT", "GL_EXT_vertex_shader", glBeginVertexShaderEXT },
-    { "glBeginVideoCaptureNV", "GL_NV_video_capture", glBeginVideoCaptureNV },
-    { "glBindAttribLocation", "GL_VERSION_2_0", glBindAttribLocation },
-    { "glBindAttribLocationARB", "GL_ARB_vertex_shader", glBindAttribLocationARB },
-    { "glBindBuffer", "GL_VERSION_1_5", glBindBuffer },
-    { "glBindBufferARB", "GL_ARB_vertex_buffer_object", glBindBufferARB },
-    { "glBindBufferBase", "GL_ARB_uniform_buffer_object GL_VERSION_3_0", glBindBufferBase },
-    { "glBindBufferBaseEXT", "GL_EXT_transform_feedback", glBindBufferBaseEXT },
-    { "glBindBufferBaseNV", "GL_NV_transform_feedback", glBindBufferBaseNV },
-    { "glBindBufferOffsetEXT", "GL_EXT_transform_feedback", glBindBufferOffsetEXT },
-    { "glBindBufferOffsetNV", "GL_NV_transform_feedback", glBindBufferOffsetNV },
-    { "glBindBufferRange", "GL_ARB_uniform_buffer_object GL_VERSION_3_0", glBindBufferRange },
-    { "glBindBufferRangeEXT", "GL_EXT_transform_feedback", glBindBufferRangeEXT },
-    { "glBindBufferRangeNV", "GL_NV_transform_feedback", glBindBufferRangeNV },
-    { "glBindBuffersBase", "GL_ARB_multi_bind GL_VERSION_4_4", glBindBuffersBase },
-    { "glBindBuffersRange", "GL_ARB_multi_bind GL_VERSION_4_4", glBindBuffersRange },
-    { "glBindFragDataLocation", "GL_VERSION_3_0", glBindFragDataLocation },
-    { "glBindFragDataLocationEXT", "GL_EXT_gpu_shader4", glBindFragDataLocationEXT },
-    { "glBindFragDataLocationIndexed", "GL_ARB_blend_func_extended GL_VERSION_3_3", glBindFragDataLocationIndexed },
-    { "glBindFragmentShaderATI", "GL_ATI_fragment_shader", glBindFragmentShaderATI },
-    { "glBindFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glBindFramebuffer },
-    { "glBindFramebufferEXT", "GL_EXT_framebuffer_object", glBindFramebufferEXT },
-    { "glBindImageTexture", "GL_ARB_shader_image_load_store GL_VERSION_4_2", glBindImageTexture },
-    { "glBindImageTextureEXT", "GL_EXT_shader_image_load_store", glBindImageTextureEXT },
-    { "glBindImageTextures", "GL_ARB_multi_bind GL_VERSION_4_4", glBindImageTextures },
-    { "glBindLightParameterEXT", "GL_EXT_vertex_shader", glBindLightParameterEXT },
-    { "glBindMaterialParameterEXT", "GL_EXT_vertex_shader", glBindMaterialParameterEXT },
-    { "glBindMultiTextureEXT", "GL_EXT_direct_state_access", glBindMultiTextureEXT },
-    { "glBindParameterEXT", "GL_EXT_vertex_shader", glBindParameterEXT },
-    { "glBindProgramARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glBindProgramARB },
-    { "glBindProgramNV", "GL_NV_vertex_program", glBindProgramNV },
-    { "glBindProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glBindProgramPipeline },
-    { "glBindRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glBindRenderbuffer },
-    { "glBindRenderbufferEXT", "GL_EXT_framebuffer_object", glBindRenderbufferEXT },
-    { "glBindSampler", "GL_ARB_sampler_objects GL_VERSION_3_3", glBindSampler },
-    { "glBindSamplers", "GL_ARB_multi_bind GL_VERSION_4_4", glBindSamplers },
-    { "glBindShadingRateImageNV", "GL_NV_shading_rate_image", glBindShadingRateImageNV },
-    { "glBindTexGenParameterEXT", "GL_EXT_vertex_shader", glBindTexGenParameterEXT },
-    { "glBindTextureEXT", "GL_EXT_texture_object", glBindTextureEXT },
-    { "glBindTextureUnit", "GL_ARB_direct_state_access GL_VERSION_4_5", glBindTextureUnit },
-    { "glBindTextureUnitParameterEXT", "GL_EXT_vertex_shader", glBindTextureUnitParameterEXT },
-    { "glBindTextures", "GL_ARB_multi_bind GL_VERSION_4_4", glBindTextures },
-    { "glBindTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glBindTransformFeedback },
-    { "glBindTransformFeedbackNV", "GL_NV_transform_feedback2", glBindTransformFeedbackNV },
-    { "glBindVertexArray", "GL_ARB_vertex_array_object GL_VERSION_3_0", glBindVertexArray },
-    { "glBindVertexArrayAPPLE", "GL_APPLE_vertex_array_object", glBindVertexArrayAPPLE },
-    { "glBindVertexBuffer", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glBindVertexBuffer },
-    { "glBindVertexBuffers", "GL_ARB_multi_bind GL_VERSION_4_4", glBindVertexBuffers },
-    { "glBindVertexShaderEXT", "GL_EXT_vertex_shader", glBindVertexShaderEXT },
-    { "glBindVideoCaptureStreamBufferNV", "GL_NV_video_capture", glBindVideoCaptureStreamBufferNV },
-    { "glBindVideoCaptureStreamTextureNV", "GL_NV_video_capture", glBindVideoCaptureStreamTextureNV },
-    { "glBinormal3bEXT", "GL_EXT_coordinate_frame", glBinormal3bEXT },
-    { "glBinormal3bvEXT", "GL_EXT_coordinate_frame", glBinormal3bvEXT },
-    { "glBinormal3dEXT", "GL_EXT_coordinate_frame", glBinormal3dEXT },
-    { "glBinormal3dvEXT", "GL_EXT_coordinate_frame", glBinormal3dvEXT },
-    { "glBinormal3fEXT", "GL_EXT_coordinate_frame", glBinormal3fEXT },
-    { "glBinormal3fvEXT", "GL_EXT_coordinate_frame", glBinormal3fvEXT },
-    { "glBinormal3iEXT", "GL_EXT_coordinate_frame", glBinormal3iEXT },
-    { "glBinormal3ivEXT", "GL_EXT_coordinate_frame", glBinormal3ivEXT },
-    { "glBinormal3sEXT", "GL_EXT_coordinate_frame", glBinormal3sEXT },
-    { "glBinormal3svEXT", "GL_EXT_coordinate_frame", glBinormal3svEXT },
-    { "glBinormalPointerEXT", "GL_EXT_coordinate_frame", glBinormalPointerEXT },
-    { "glBitmapxOES", "GL_OES_fixed_point", glBitmapxOES },
-    { "glBlendBarrierKHR", "GL_KHR_blend_equation_advanced", glBlendBarrierKHR },
-    { "glBlendBarrierNV", "GL_NV_blend_equation_advanced", glBlendBarrierNV },
-    { "glBlendColor", "GL_ARB_imaging GL_VERSION_1_4", glBlendColor },
-    { "glBlendColorEXT", "GL_EXT_blend_color", glBlendColorEXT },
-    { "glBlendColorxOES", "GL_OES_fixed_point", glBlendColorxOES },
-    { "glBlendEquation", "GL_ARB_imaging GL_VERSION_1_4", glBlendEquation },
-    { "glBlendEquationEXT", "GL_EXT_blend_minmax", glBlendEquationEXT },
-    { "glBlendEquationIndexedAMD", "GL_AMD_draw_buffers_blend", glBlendEquationIndexedAMD },
-    { "glBlendEquationSeparate", "GL_VERSION_2_0", glBlendEquationSeparate },
-    { "glBlendEquationSeparateEXT", "GL_EXT_blend_equation_separate", glBlendEquationSeparateEXT },
-    { "glBlendEquationSeparateIndexedAMD", "GL_AMD_draw_buffers_blend", glBlendEquationSeparateIndexedAMD },
-    { "glBlendEquationSeparatei", "GL_VERSION_4_0", glBlendEquationSeparatei },
-    { "glBlendEquationSeparateiARB", "GL_ARB_draw_buffers_blend", glBlendEquationSeparateiARB },
-    { "glBlendEquationi", "GL_VERSION_4_0", glBlendEquationi },
-    { "glBlendEquationiARB", "GL_ARB_draw_buffers_blend", glBlendEquationiARB },
-    { "glBlendFuncIndexedAMD", "GL_AMD_draw_buffers_blend", glBlendFuncIndexedAMD },
-    { "glBlendFuncSeparate", "GL_VERSION_1_4", glBlendFuncSeparate },
-    { "glBlendFuncSeparateEXT", "GL_EXT_blend_func_separate", glBlendFuncSeparateEXT },
-    { "glBlendFuncSeparateINGR", "GL_INGR_blend_func_separate", glBlendFuncSeparateINGR },
-    { "glBlendFuncSeparateIndexedAMD", "GL_AMD_draw_buffers_blend", glBlendFuncSeparateIndexedAMD },
-    { "glBlendFuncSeparatei", "GL_VERSION_4_0", glBlendFuncSeparatei },
-    { "glBlendFuncSeparateiARB", "GL_ARB_draw_buffers_blend", glBlendFuncSeparateiARB },
-    { "glBlendFunci", "GL_VERSION_4_0", glBlendFunci },
-    { "glBlendFunciARB", "GL_ARB_draw_buffers_blend", glBlendFunciARB },
-    { "glBlendParameteriNV", "GL_NV_blend_equation_advanced", glBlendParameteriNV },
-    { "glBlitFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glBlitFramebuffer },
-    { "glBlitFramebufferEXT", "GL_EXT_framebuffer_blit", glBlitFramebufferEXT },
-    { "glBlitNamedFramebuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glBlitNamedFramebuffer },
-    { "glBufferAddressRangeNV", "GL_NV_vertex_buffer_unified_memory", glBufferAddressRangeNV },
-    { "glBufferAttachMemoryNV", "GL_NV_memory_attachment", glBufferAttachMemoryNV },
-    { "glBufferData", "GL_VERSION_1_5", glBufferData },
-    { "glBufferDataARB", "GL_ARB_vertex_buffer_object", glBufferDataARB },
-    { "glBufferPageCommitmentARB", "GL_ARB_sparse_buffer", glBufferPageCommitmentARB },
-    { "glBufferParameteriAPPLE", "GL_APPLE_flush_buffer_range", glBufferParameteriAPPLE },
-    { "glBufferRegionEnabled", "GL_KTX_buffer_region", glBufferRegionEnabled },
-    { "glBufferStorage", "GL_ARB_buffer_storage GL_VERSION_4_4", glBufferStorage },
-    { "glBufferStorageExternalEXT", "GL_EXT_external_buffer", glBufferStorageExternalEXT },
-    { "glBufferStorageMemEXT", "GL_EXT_memory_object", glBufferStorageMemEXT },
-    { "glBufferSubData", "GL_VERSION_1_5", glBufferSubData },
-    { "glBufferSubDataARB", "GL_ARB_vertex_buffer_object", glBufferSubDataARB },
-    { "glCallCommandListNV", "GL_NV_command_list", glCallCommandListNV },
-    { "glCheckFramebufferStatus", "GL_ARB_framebuffer_object GL_VERSION_3_0", glCheckFramebufferStatus },
-    { "glCheckFramebufferStatusEXT", "GL_EXT_framebuffer_object", glCheckFramebufferStatusEXT },
-    { "glCheckNamedFramebufferStatus", "GL_ARB_direct_state_access GL_VERSION_4_5", glCheckNamedFramebufferStatus },
-    { "glCheckNamedFramebufferStatusEXT", "GL_EXT_direct_state_access", glCheckNamedFramebufferStatusEXT },
-    { "glClampColor", "GL_VERSION_3_0", glClampColor },
-    { "glClampColorARB", "GL_ARB_color_buffer_float", glClampColorARB },
-    { "glClearAccumxOES", "GL_OES_fixed_point", glClearAccumxOES },
-    { "glClearBufferData", "GL_ARB_clear_buffer_object GL_VERSION_4_3", glClearBufferData },
-    { "glClearBufferSubData", "GL_ARB_clear_buffer_object GL_VERSION_4_3", glClearBufferSubData },
-    { "glClearBufferfi", "GL_VERSION_3_0", glClearBufferfi },
-    { "glClearBufferfv", "GL_VERSION_3_0", glClearBufferfv },
-    { "glClearBufferiv", "GL_VERSION_3_0", glClearBufferiv },
-    { "glClearBufferuiv", "GL_VERSION_3_0", glClearBufferuiv },
-    { "glClearColorIiEXT", "GL_EXT_texture_integer", glClearColorIiEXT },
-    { "glClearColorIuiEXT", "GL_EXT_texture_integer", glClearColorIuiEXT },
-    { "glClearColorxOES", "GL_OES_fixed_point", glClearColorxOES },
-    { "glClearDepthdNV", "GL_NV_depth_buffer_float", glClearDepthdNV },
-    { "glClearDepthf", "GL_ARB_ES2_compatibility GL_VERSION_4_1", glClearDepthf },
-    { "glClearDepthfOES", "GL_OES_single_precision", glClearDepthfOES },
-    { "glClearDepthxOES", "GL_OES_fixed_point", glClearDepthxOES },
-    { "glClearNamedBufferData", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedBufferData },
-    { "glClearNamedBufferDataEXT", "GL_EXT_direct_state_access", glClearNamedBufferDataEXT },
-    { "glClearNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedBufferSubData },
-    { "glClearNamedBufferSubDataEXT", "GL_EXT_direct_state_access", glClearNamedBufferSubDataEXT },
-    { "glClearNamedFramebufferfi", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedFramebufferfi },
-    { "glClearNamedFramebufferfv", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedFramebufferfv },
-    { "glClearNamedFramebufferiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedFramebufferiv },
-    { "glClearNamedFramebufferuiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glClearNamedFramebufferuiv },
-    { "glClearTexImage", "GL_ARB_clear_texture GL_VERSION_4_4", glClearTexImage },
-    { "glClearTexSubImage", "GL_ARB_clear_texture GL_VERSION_4_4", glClearTexSubImage },
-    { "glClientActiveTexture", "GL_VERSION_1_3", glClientActiveTexture },
-    { "glClientActiveTextureARB", "GL_ARB_multitexture", glClientActiveTextureARB },
-    { "glClientActiveVertexStreamATI", "GL_ATI_vertex_streams", glClientActiveVertexStreamATI },
-    { "glClientAttribDefaultEXT", "GL_EXT_direct_state_access", glClientAttribDefaultEXT },
-    { "glClientWaitSemaphoreui64NVX", "GL_NVX_progress_fence", glClientWaitSemaphoreui64NVX },
-    { "glClientWaitSync", "GL_ARB_sync GL_VERSION_3_2", glClientWaitSync },
-    { "glClipControl", "GL_ARB_clip_control GL_VERSION_4_5", glClipControl },
-    { "glClipPlanefOES", "GL_OES_single_precision", glClipPlanefOES },
-    { "glClipPlanexOES", "GL_OES_fixed_point", glClipPlanexOES },
-    { "glColor3fVertex3fSUN", "GL_SUN_vertex", glColor3fVertex3fSUN },
-    { "glColor3fVertex3fvSUN", "GL_SUN_vertex", glColor3fVertex3fvSUN },
-    { "glColor3hNV", "GL_NV_half_float", glColor3hNV },
-    { "glColor3hvNV", "GL_NV_half_float", glColor3hvNV },
-    { "glColor3xOES", "GL_OES_fixed_point", glColor3xOES },
-    { "glColor3xvOES", "GL_OES_fixed_point", glColor3xvOES },
-    { "glColor4fNormal3fVertex3fSUN", "GL_SUN_vertex", glColor4fNormal3fVertex3fSUN },
-    { "glColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex", glColor4fNormal3fVertex3fvSUN },
-    { "glColor4hNV", "GL_NV_half_float", glColor4hNV },
-    { "glColor4hvNV", "GL_NV_half_float", glColor4hvNV },
-    { "glColor4ubVertex2fSUN", "GL_SUN_vertex", glColor4ubVertex2fSUN },
-    { "glColor4ubVertex2fvSUN", "GL_SUN_vertex", glColor4ubVertex2fvSUN },
-    { "glColor4ubVertex3fSUN", "GL_SUN_vertex", glColor4ubVertex3fSUN },
-    { "glColor4ubVertex3fvSUN", "GL_SUN_vertex", glColor4ubVertex3fvSUN },
-    { "glColor4xOES", "GL_OES_fixed_point", glColor4xOES },
-    { "glColor4xvOES", "GL_OES_fixed_point", glColor4xvOES },
-    { "glColorFormatNV", "GL_NV_vertex_buffer_unified_memory", glColorFormatNV },
-    { "glColorFragmentOp1ATI", "GL_ATI_fragment_shader", glColorFragmentOp1ATI },
-    { "glColorFragmentOp2ATI", "GL_ATI_fragment_shader", glColorFragmentOp2ATI },
-    { "glColorFragmentOp3ATI", "GL_ATI_fragment_shader", glColorFragmentOp3ATI },
-    { "glColorMaskIndexedEXT", "GL_EXT_draw_buffers2", glColorMaskIndexedEXT },
-    { "glColorMaski", "GL_VERSION_3_0", glColorMaski },
-    { "glColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glColorP3ui },
-    { "glColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glColorP3uiv },
-    { "glColorP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glColorP4ui },
-    { "glColorP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glColorP4uiv },
-    { "glColorPointerEXT", "GL_EXT_vertex_array", glColorPointerEXT },
-    { "glColorPointerListIBM", "GL_IBM_vertex_array_lists", glColorPointerListIBM },
-    { "glColorPointervINTEL", "GL_INTEL_parallel_arrays", glColorPointervINTEL },
-    { "glColorSubTable", "GL_ARB_imaging", glColorSubTable },
-    { "glColorSubTableEXT", "GL_EXT_color_subtable", glColorSubTableEXT },
-    { "glColorTable", "GL_ARB_imaging", glColorTable },
-    { "glColorTableEXT", "GL_EXT_paletted_texture", glColorTableEXT },
-    { "glColorTableParameterfv", "GL_ARB_imaging", glColorTableParameterfv },
-    { "glColorTableParameterfvSGI", "GL_SGI_color_table", glColorTableParameterfvSGI },
-    { "glColorTableParameteriv", "GL_ARB_imaging", glColorTableParameteriv },
-    { "glColorTableParameterivSGI", "GL_SGI_color_table", glColorTableParameterivSGI },
-    { "glColorTableSGI", "GL_SGI_color_table", glColorTableSGI },
-    { "glCombinerInputNV", "GL_NV_register_combiners", glCombinerInputNV },
-    { "glCombinerOutputNV", "GL_NV_register_combiners", glCombinerOutputNV },
-    { "glCombinerParameterfNV", "GL_NV_register_combiners", glCombinerParameterfNV },
-    { "glCombinerParameterfvNV", "GL_NV_register_combiners", glCombinerParameterfvNV },
-    { "glCombinerParameteriNV", "GL_NV_register_combiners", glCombinerParameteriNV },
-    { "glCombinerParameterivNV", "GL_NV_register_combiners", glCombinerParameterivNV },
-    { "glCombinerStageParameterfvNV", "GL_NV_register_combiners2", glCombinerStageParameterfvNV },
-    { "glCommandListSegmentsNV", "GL_NV_command_list", glCommandListSegmentsNV },
-    { "glCompileCommandListNV", "GL_NV_command_list", glCompileCommandListNV },
-    { "glCompileShader", "GL_VERSION_2_0", glCompileShader },
-    { "glCompileShaderARB", "GL_ARB_shader_objects", glCompileShaderARB },
-    { "glCompileShaderIncludeARB", "GL_ARB_shading_language_include", glCompileShaderIncludeARB },
-    { "glCompressedMultiTexImage1DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexImage1DEXT },
-    { "glCompressedMultiTexImage2DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexImage2DEXT },
-    { "glCompressedMultiTexImage3DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexImage3DEXT },
-    { "glCompressedMultiTexSubImage1DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexSubImage1DEXT },
-    { "glCompressedMultiTexSubImage2DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexSubImage2DEXT },
-    { "glCompressedMultiTexSubImage3DEXT", "GL_EXT_direct_state_access", glCompressedMultiTexSubImage3DEXT },
-    { "glCompressedTexImage1D", "GL_VERSION_1_3", glCompressedTexImage1D },
-    { "glCompressedTexImage1DARB", "GL_ARB_texture_compression", glCompressedTexImage1DARB },
-    { "glCompressedTexImage2D", "GL_VERSION_1_3", glCompressedTexImage2D },
-    { "glCompressedTexImage2DARB", "GL_ARB_texture_compression", glCompressedTexImage2DARB },
-    { "glCompressedTexImage3D", "GL_VERSION_1_3", glCompressedTexImage3D },
-    { "glCompressedTexImage3DARB", "GL_ARB_texture_compression", glCompressedTexImage3DARB },
-    { "glCompressedTexSubImage1D", "GL_VERSION_1_3", glCompressedTexSubImage1D },
-    { "glCompressedTexSubImage1DARB", "GL_ARB_texture_compression", glCompressedTexSubImage1DARB },
-    { "glCompressedTexSubImage2D", "GL_VERSION_1_3", glCompressedTexSubImage2D },
-    { "glCompressedTexSubImage2DARB", "GL_ARB_texture_compression", glCompressedTexSubImage2DARB },
-    { "glCompressedTexSubImage3D", "GL_VERSION_1_3", glCompressedTexSubImage3D },
-    { "glCompressedTexSubImage3DARB", "GL_ARB_texture_compression", glCompressedTexSubImage3DARB },
-    { "glCompressedTextureImage1DEXT", "GL_EXT_direct_state_access", glCompressedTextureImage1DEXT },
-    { "glCompressedTextureImage2DEXT", "GL_EXT_direct_state_access", glCompressedTextureImage2DEXT },
-    { "glCompressedTextureImage3DEXT", "GL_EXT_direct_state_access", glCompressedTextureImage3DEXT },
-    { "glCompressedTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCompressedTextureSubImage1D },
-    { "glCompressedTextureSubImage1DEXT", "GL_EXT_direct_state_access", glCompressedTextureSubImage1DEXT },
-    { "glCompressedTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCompressedTextureSubImage2D },
-    { "glCompressedTextureSubImage2DEXT", "GL_EXT_direct_state_access", glCompressedTextureSubImage2DEXT },
-    { "glCompressedTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCompressedTextureSubImage3D },
-    { "glCompressedTextureSubImage3DEXT", "GL_EXT_direct_state_access", glCompressedTextureSubImage3DEXT },
-    { "glConservativeRasterParameterfNV", "GL_NV_conservative_raster_dilate", glConservativeRasterParameterfNV },
-    { "glConservativeRasterParameteriNV", "GL_NV_conservative_raster_pre_snap_triangles", glConservativeRasterParameteriNV },
-    { "glConvolutionFilter1D", "GL_ARB_imaging", glConvolutionFilter1D },
-    { "glConvolutionFilter1DEXT", "GL_EXT_convolution", glConvolutionFilter1DEXT },
-    { "glConvolutionFilter2D", "GL_ARB_imaging", glConvolutionFilter2D },
-    { "glConvolutionFilter2DEXT", "GL_EXT_convolution", glConvolutionFilter2DEXT },
-    { "glConvolutionParameterf", "GL_ARB_imaging", glConvolutionParameterf },
-    { "glConvolutionParameterfEXT", "GL_EXT_convolution", glConvolutionParameterfEXT },
-    { "glConvolutionParameterfv", "GL_ARB_imaging", glConvolutionParameterfv },
-    { "glConvolutionParameterfvEXT", "GL_EXT_convolution", glConvolutionParameterfvEXT },
-    { "glConvolutionParameteri", "GL_ARB_imaging", glConvolutionParameteri },
-    { "glConvolutionParameteriEXT", "GL_EXT_convolution", glConvolutionParameteriEXT },
-    { "glConvolutionParameteriv", "GL_ARB_imaging", glConvolutionParameteriv },
-    { "glConvolutionParameterivEXT", "GL_EXT_convolution", glConvolutionParameterivEXT },
-    { "glConvolutionParameterxOES", "GL_OES_fixed_point", glConvolutionParameterxOES },
-    { "glConvolutionParameterxvOES", "GL_OES_fixed_point", glConvolutionParameterxvOES },
-    { "glCopyBufferSubData", "GL_ARB_copy_buffer GL_VERSION_3_1", glCopyBufferSubData },
-    { "glCopyColorSubTable", "GL_ARB_imaging", glCopyColorSubTable },
-    { "glCopyColorSubTableEXT", "GL_EXT_color_subtable", glCopyColorSubTableEXT },
-    { "glCopyColorTable", "GL_ARB_imaging", glCopyColorTable },
-    { "glCopyColorTableSGI", "GL_SGI_color_table", glCopyColorTableSGI },
-    { "glCopyConvolutionFilter1D", "GL_ARB_imaging", glCopyConvolutionFilter1D },
-    { "glCopyConvolutionFilter1DEXT", "GL_EXT_convolution", glCopyConvolutionFilter1DEXT },
-    { "glCopyConvolutionFilter2D", "GL_ARB_imaging", glCopyConvolutionFilter2D },
-    { "glCopyConvolutionFilter2DEXT", "GL_EXT_convolution", glCopyConvolutionFilter2DEXT },
-    { "glCopyImageSubData", "GL_ARB_copy_image GL_VERSION_4_3", glCopyImageSubData },
-    { "glCopyImageSubDataNV", "GL_NV_copy_image", glCopyImageSubDataNV },
-    { "glCopyMultiTexImage1DEXT", "GL_EXT_direct_state_access", glCopyMultiTexImage1DEXT },
-    { "glCopyMultiTexImage2DEXT", "GL_EXT_direct_state_access", glCopyMultiTexImage2DEXT },
-    { "glCopyMultiTexSubImage1DEXT", "GL_EXT_direct_state_access", glCopyMultiTexSubImage1DEXT },
-    { "glCopyMultiTexSubImage2DEXT", "GL_EXT_direct_state_access", glCopyMultiTexSubImage2DEXT },
-    { "glCopyMultiTexSubImage3DEXT", "GL_EXT_direct_state_access", glCopyMultiTexSubImage3DEXT },
-    { "glCopyNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5", glCopyNamedBufferSubData },
-    { "glCopyPathNV", "GL_NV_path_rendering", glCopyPathNV },
-    { "glCopyTexImage1DEXT", "GL_EXT_copy_texture", glCopyTexImage1DEXT },
-    { "glCopyTexImage2DEXT", "GL_EXT_copy_texture", glCopyTexImage2DEXT },
-    { "glCopyTexSubImage1DEXT", "GL_EXT_copy_texture", glCopyTexSubImage1DEXT },
-    { "glCopyTexSubImage2DEXT", "GL_EXT_copy_texture", glCopyTexSubImage2DEXT },
-    { "glCopyTexSubImage3D", "GL_VERSION_1_2", glCopyTexSubImage3D },
-    { "glCopyTexSubImage3DEXT", "GL_EXT_copy_texture", glCopyTexSubImage3DEXT },
-    { "glCopyTextureImage1DEXT", "GL_EXT_direct_state_access", glCopyTextureImage1DEXT },
-    { "glCopyTextureImage2DEXT", "GL_EXT_direct_state_access", glCopyTextureImage2DEXT },
-    { "glCopyTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCopyTextureSubImage1D },
-    { "glCopyTextureSubImage1DEXT", "GL_EXT_direct_state_access", glCopyTextureSubImage1DEXT },
-    { "glCopyTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCopyTextureSubImage2D },
-    { "glCopyTextureSubImage2DEXT", "GL_EXT_direct_state_access", glCopyTextureSubImage2DEXT },
-    { "glCopyTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5", glCopyTextureSubImage3D },
-    { "glCopyTextureSubImage3DEXT", "GL_EXT_direct_state_access", glCopyTextureSubImage3DEXT },
-    { "glCoverFillPathInstancedNV", "GL_NV_path_rendering", glCoverFillPathInstancedNV },
-    { "glCoverFillPathNV", "GL_NV_path_rendering", glCoverFillPathNV },
-    { "glCoverStrokePathInstancedNV", "GL_NV_path_rendering", glCoverStrokePathInstancedNV },
-    { "glCoverStrokePathNV", "GL_NV_path_rendering", glCoverStrokePathNV },
-    { "glCoverageModulationNV", "GL_NV_framebuffer_mixed_samples", glCoverageModulationNV },
-    { "glCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples", glCoverageModulationTableNV },
-    { "glCreateBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateBuffers },
-    { "glCreateCommandListsNV", "GL_NV_command_list", glCreateCommandListsNV },
-    { "glCreateFramebuffers", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateFramebuffers },
-    { "glCreateMemoryObjectsEXT", "GL_EXT_memory_object", glCreateMemoryObjectsEXT },
-    { "glCreatePerfQueryINTEL", "GL_INTEL_performance_query", glCreatePerfQueryINTEL },
-    { "glCreateProgram", "GL_VERSION_2_0", glCreateProgram },
-    { "glCreateProgramObjectARB", "GL_ARB_shader_objects", glCreateProgramObjectARB },
-    { "glCreateProgramPipelines", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateProgramPipelines },
-    { "glCreateProgressFenceNVX", "GL_NVX_progress_fence", glCreateProgressFenceNVX },
-    { "glCreateQueries", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateQueries },
-    { "glCreateRenderbuffers", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateRenderbuffers },
-    { "glCreateSamplers", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateSamplers },
-    { "glCreateShader", "GL_VERSION_2_0", glCreateShader },
-    { "glCreateShaderObjectARB", "GL_ARB_shader_objects", glCreateShaderObjectARB },
-    { "glCreateShaderProgramEXT", "GL_EXT_separate_shader_objects", glCreateShaderProgramEXT },
-    { "glCreateShaderProgramv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glCreateShaderProgramv },
-    { "glCreateStatesNV", "GL_NV_command_list", glCreateStatesNV },
-    { "glCreateSyncFromCLeventARB", "GL_ARB_cl_event", glCreateSyncFromCLeventARB },
-    { "glCreateTextures", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateTextures },
-    { "glCreateTransformFeedbacks", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateTransformFeedbacks },
-    { "glCreateVertexArrays", "GL_ARB_direct_state_access GL_VERSION_4_5", glCreateVertexArrays },
-    { "glCullParameterdvEXT", "GL_EXT_cull_vertex", glCullParameterdvEXT },
-    { "glCullParameterfvEXT", "GL_EXT_cull_vertex", glCullParameterfvEXT },
-    { "glCurrentPaletteMatrixARB", "GL_ARB_matrix_palette", glCurrentPaletteMatrixARB },
-    { "glDebugMessageCallback", "GL_KHR_debug GL_VERSION_4_3", glDebugMessageCallback },
-    { "glDebugMessageCallbackAMD", "GL_AMD_debug_output", glDebugMessageCallbackAMD },
-    { "glDebugMessageCallbackARB", "GL_ARB_debug_output", glDebugMessageCallbackARB },
-    { "glDebugMessageControl", "GL_KHR_debug GL_VERSION_4_3", glDebugMessageControl },
-    { "glDebugMessageControlARB", "GL_ARB_debug_output", glDebugMessageControlARB },
-    { "glDebugMessageEnableAMD", "GL_AMD_debug_output", glDebugMessageEnableAMD },
-    { "glDebugMessageInsert", "GL_KHR_debug GL_VERSION_4_3", glDebugMessageInsert },
-    { "glDebugMessageInsertAMD", "GL_AMD_debug_output", glDebugMessageInsertAMD },
-    { "glDebugMessageInsertARB", "GL_ARB_debug_output", glDebugMessageInsertARB },
-    { "glDeformSGIX", "GL_SGIX_polynomial_ffd", glDeformSGIX },
-    { "glDeformationMap3dSGIX", "GL_SGIX_polynomial_ffd", glDeformationMap3dSGIX },
-    { "glDeformationMap3fSGIX", "GL_SGIX_polynomial_ffd", glDeformationMap3fSGIX },
-    { "glDeleteAsyncMarkersSGIX", "GL_SGIX_async", glDeleteAsyncMarkersSGIX },
-    { "glDeleteBufferRegion", "GL_KTX_buffer_region", glDeleteBufferRegion },
-    { "glDeleteBuffers", "GL_VERSION_1_5", glDeleteBuffers },
-    { "glDeleteBuffersARB", "GL_ARB_vertex_buffer_object", glDeleteBuffersARB },
-    { "glDeleteCommandListsNV", "GL_NV_command_list", glDeleteCommandListsNV },
-    { "glDeleteFencesAPPLE", "GL_APPLE_fence", glDeleteFencesAPPLE },
-    { "glDeleteFencesNV", "GL_NV_fence", glDeleteFencesNV },
-    { "glDeleteFragmentShaderATI", "GL_ATI_fragment_shader", glDeleteFragmentShaderATI },
-    { "glDeleteFramebuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0", glDeleteFramebuffers },
-    { "glDeleteFramebuffersEXT", "GL_EXT_framebuffer_object", glDeleteFramebuffersEXT },
-    { "glDeleteMemoryObjectsEXT", "GL_EXT_memory_object", glDeleteMemoryObjectsEXT },
-    { "glDeleteNamedStringARB", "GL_ARB_shading_language_include", glDeleteNamedStringARB },
-    { "glDeleteNamesAMD", "GL_AMD_name_gen_delete", glDeleteNamesAMD },
-    { "glDeleteObjectARB", "GL_ARB_shader_objects", glDeleteObjectARB },
-    { "glDeleteObjectBufferATI", "GL_ATI_vertex_array_object", glDeleteObjectBufferATI },
-    { "glDeleteOcclusionQueriesNV", "GL_NV_occlusion_query", glDeleteOcclusionQueriesNV },
-    { "glDeletePathsNV", "GL_NV_path_rendering", glDeletePathsNV },
-    { "glDeletePerfMonitorsAMD", "GL_AMD_performance_monitor", glDeletePerfMonitorsAMD },
-    { "glDeletePerfQueryINTEL", "GL_INTEL_performance_query", glDeletePerfQueryINTEL },
-    { "glDeleteProgram", "GL_VERSION_2_0", glDeleteProgram },
-    { "glDeleteProgramPipelines", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glDeleteProgramPipelines },
-    { "glDeleteProgramsARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glDeleteProgramsARB },
-    { "glDeleteProgramsNV", "GL_NV_vertex_program", glDeleteProgramsNV },
-    { "glDeleteQueries", "GL_VERSION_1_5", glDeleteQueries },
-    { "glDeleteQueriesARB", "GL_ARB_occlusion_query", glDeleteQueriesARB },
-    { "glDeleteQueryResourceTagNV", "GL_NV_query_resource_tag", glDeleteQueryResourceTagNV },
-    { "glDeleteRenderbuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0", glDeleteRenderbuffers },
-    { "glDeleteRenderbuffersEXT", "GL_EXT_framebuffer_object", glDeleteRenderbuffersEXT },
-    { "glDeleteSamplers", "GL_ARB_sampler_objects GL_VERSION_3_3", glDeleteSamplers },
-    { "glDeleteSemaphoresEXT", "GL_EXT_semaphore", glDeleteSemaphoresEXT },
-    { "glDeleteShader", "GL_VERSION_2_0", glDeleteShader },
-    { "glDeleteStatesNV", "GL_NV_command_list", glDeleteStatesNV },
-    { "glDeleteSync", "GL_ARB_sync GL_VERSION_3_2", glDeleteSync },
-    { "glDeleteTexturesEXT", "GL_EXT_texture_object", glDeleteTexturesEXT },
-    { "glDeleteTransformFeedbacks", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glDeleteTransformFeedbacks },
-    { "glDeleteTransformFeedbacksNV", "GL_NV_transform_feedback2", glDeleteTransformFeedbacksNV },
-    { "glDeleteVertexArrays", "GL_ARB_vertex_array_object GL_VERSION_3_0", glDeleteVertexArrays },
-    { "glDeleteVertexArraysAPPLE", "GL_APPLE_vertex_array_object", glDeleteVertexArraysAPPLE },
-    { "glDeleteVertexShaderEXT", "GL_EXT_vertex_shader", glDeleteVertexShaderEXT },
-    { "glDepthBoundsEXT", "GL_EXT_depth_bounds_test", glDepthBoundsEXT },
-    { "glDepthBoundsdNV", "GL_NV_depth_buffer_float", glDepthBoundsdNV },
-    { "glDepthRangeArraydvNV", "GL_ARB_viewport_array", glDepthRangeArraydvNV },
-    { "glDepthRangeArrayv", "GL_ARB_viewport_array GL_VERSION_4_1", glDepthRangeArrayv },
-    { "glDepthRangeIndexed", "GL_ARB_viewport_array GL_VERSION_4_1", glDepthRangeIndexed },
-    { "glDepthRangeIndexeddNV", "GL_ARB_viewport_array", glDepthRangeIndexeddNV },
-    { "glDepthRangedNV", "GL_NV_depth_buffer_float", glDepthRangedNV },
-    { "glDepthRangef", "GL_ARB_ES2_compatibility GL_VERSION_4_1", glDepthRangef },
-    { "glDepthRangefOES", "GL_OES_single_precision", glDepthRangefOES },
-    { "glDepthRangexOES", "GL_OES_fixed_point", glDepthRangexOES },
-    { "glDetachObjectARB", "GL_ARB_shader_objects", glDetachObjectARB },
-    { "glDetachShader", "GL_VERSION_2_0", glDetachShader },
-    { "glDetailTexFuncSGIS", "GL_SGIS_detail_texture", glDetailTexFuncSGIS },
-    { "glDisableClientStateIndexedEXT", "GL_EXT_direct_state_access", glDisableClientStateIndexedEXT },
-    { "glDisableClientStateiEXT", "GL_EXT_direct_state_access", glDisableClientStateiEXT },
-    { "glDisableIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2", glDisableIndexedEXT },
-    { "glDisableVariantClientStateEXT", "GL_EXT_vertex_shader", glDisableVariantClientStateEXT },
-    { "glDisableVertexArrayAttrib", "GL_ARB_direct_state_access GL_VERSION_4_5", glDisableVertexArrayAttrib },
-    { "glDisableVertexArrayAttribEXT", "GL_EXT_direct_state_access", glDisableVertexArrayAttribEXT },
-    { "glDisableVertexArrayEXT", "GL_EXT_direct_state_access", glDisableVertexArrayEXT },
-    { "glDisableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators", glDisableVertexAttribAPPLE },
-    { "glDisableVertexAttribArray", "GL_VERSION_2_0", glDisableVertexAttribArray },
-    { "glDisableVertexAttribArrayARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glDisableVertexAttribArrayARB },
-    { "glDisablei", "GL_VERSION_3_0", glDisablei },
-    { "glDispatchCompute", "GL_ARB_compute_shader GL_VERSION_4_3", glDispatchCompute },
-    { "glDispatchComputeGroupSizeARB", "GL_ARB_compute_variable_group_size", glDispatchComputeGroupSizeARB },
-    { "glDispatchComputeIndirect", "GL_ARB_compute_shader GL_VERSION_4_3", glDispatchComputeIndirect },
-    { "glDrawArraysEXT", "GL_EXT_vertex_array", glDrawArraysEXT },
-    { "glDrawArraysIndirect", "GL_ARB_draw_indirect GL_VERSION_4_0", glDrawArraysIndirect },
-    { "glDrawArraysInstanced", "GL_VERSION_3_1", glDrawArraysInstanced },
-    { "glDrawArraysInstancedARB", "GL_ARB_draw_instanced", glDrawArraysInstancedARB },
-    { "glDrawArraysInstancedBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2", glDrawArraysInstancedBaseInstance },
-    { "glDrawArraysInstancedEXT", "GL_EXT_draw_instanced", glDrawArraysInstancedEXT },
-    { "glDrawBufferRegion", "GL_KTX_buffer_region", glDrawBufferRegion },
-    { "glDrawBuffers", "GL_VERSION_2_0", glDrawBuffers },
-    { "glDrawBuffersARB", "GL_ARB_draw_buffers", glDrawBuffersARB },
-    { "glDrawBuffersATI", "GL_ATI_draw_buffers", glDrawBuffersATI },
-    { "glDrawCommandsAddressNV", "GL_NV_command_list", glDrawCommandsAddressNV },
-    { "glDrawCommandsNV", "GL_NV_command_list", glDrawCommandsNV },
-    { "glDrawCommandsStatesAddressNV", "GL_NV_command_list", glDrawCommandsStatesAddressNV },
-    { "glDrawCommandsStatesNV", "GL_NV_command_list", glDrawCommandsStatesNV },
-    { "glDrawElementArrayAPPLE", "GL_APPLE_element_array", glDrawElementArrayAPPLE },
-    { "glDrawElementArrayATI", "GL_ATI_element_array", glDrawElementArrayATI },
-    { "glDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2", glDrawElementsBaseVertex },
-    { "glDrawElementsIndirect", "GL_ARB_draw_indirect GL_VERSION_4_0", glDrawElementsIndirect },
-    { "glDrawElementsInstanced", "GL_VERSION_3_1", glDrawElementsInstanced },
-    { "glDrawElementsInstancedARB", "GL_ARB_draw_instanced", glDrawElementsInstancedARB },
-    { "glDrawElementsInstancedBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2", glDrawElementsInstancedBaseInstance },
-    { "glDrawElementsInstancedBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2", glDrawElementsInstancedBaseVertex },
-    { "glDrawElementsInstancedBaseVertexBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2", glDrawElementsInstancedBaseVertexBaseInstance },
-    { "glDrawElementsInstancedEXT", "GL_EXT_draw_instanced", glDrawElementsInstancedEXT },
-    { "glDrawMeshArraysSUN", "GL_SUN_mesh_array", glDrawMeshArraysSUN },
-    { "glDrawMeshTasksIndirectNV", "GL_NV_mesh_shader", glDrawMeshTasksIndirectNV },
-    { "glDrawMeshTasksNV", "GL_NV_mesh_shader", glDrawMeshTasksNV },
-    { "glDrawRangeElementArrayAPPLE", "GL_APPLE_element_array", glDrawRangeElementArrayAPPLE },
-    { "glDrawRangeElementArrayATI", "GL_ATI_element_array", glDrawRangeElementArrayATI },
-    { "glDrawRangeElements", "GL_VERSION_1_2", glDrawRangeElements },
-    { "glDrawRangeElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2", glDrawRangeElementsBaseVertex },
-    { "glDrawRangeElementsEXT", "GL_EXT_draw_range_elements", glDrawRangeElementsEXT },
-    { "glDrawTextureNV", "GL_NV_draw_texture", glDrawTextureNV },
-    { "glDrawTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glDrawTransformFeedback },
-    { "glDrawTransformFeedbackInstanced", "GL_ARB_transform_feedback_instanced GL_VERSION_4_2", glDrawTransformFeedbackInstanced },
-    { "glDrawTransformFeedbackNV", "GL_NV_transform_feedback2", glDrawTransformFeedbackNV },
-    { "glDrawTransformFeedbackStream", "GL_ARB_transform_feedback3 GL_VERSION_4_0", glDrawTransformFeedbackStream },
-    { "glDrawTransformFeedbackStreamInstanced", "GL_ARB_transform_feedback_instanced GL_VERSION_4_2", glDrawTransformFeedbackStreamInstanced },
-    { "glDrawVkImageNV", "GL_NV_draw_vulkan_image", glDrawVkImageNV },
-    { "glEGLImageTargetTexStorageEXT", "GL_EXT_EGL_image_storage", glEGLImageTargetTexStorageEXT },
-    { "glEGLImageTargetTextureStorageEXT", "GL_EXT_EGL_image_storage", glEGLImageTargetTextureStorageEXT },
-    { "glEdgeFlagFormatNV", "GL_NV_vertex_buffer_unified_memory", glEdgeFlagFormatNV },
-    { "glEdgeFlagPointerEXT", "GL_EXT_vertex_array", glEdgeFlagPointerEXT },
-    { "glEdgeFlagPointerListIBM", "GL_IBM_vertex_array_lists", glEdgeFlagPointerListIBM },
-    { "glElementPointerAPPLE", "GL_APPLE_element_array", glElementPointerAPPLE },
-    { "glElementPointerATI", "GL_ATI_element_array", glElementPointerATI },
-    { "glEnableClientStateIndexedEXT", "GL_EXT_direct_state_access", glEnableClientStateIndexedEXT },
-    { "glEnableClientStateiEXT", "GL_EXT_direct_state_access", glEnableClientStateiEXT },
-    { "glEnableIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2", glEnableIndexedEXT },
-    { "glEnableVariantClientStateEXT", "GL_EXT_vertex_shader", glEnableVariantClientStateEXT },
-    { "glEnableVertexArrayAttrib", "GL_ARB_direct_state_access GL_VERSION_4_5", glEnableVertexArrayAttrib },
-    { "glEnableVertexArrayAttribEXT", "GL_EXT_direct_state_access", glEnableVertexArrayAttribEXT },
-    { "glEnableVertexArrayEXT", "GL_EXT_direct_state_access", glEnableVertexArrayEXT },
-    { "glEnableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators", glEnableVertexAttribAPPLE },
-    { "glEnableVertexAttribArray", "GL_VERSION_2_0", glEnableVertexAttribArray },
-    { "glEnableVertexAttribArrayARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glEnableVertexAttribArrayARB },
-    { "glEnablei", "GL_VERSION_3_0", glEnablei },
-    { "glEndConditionalRender", "GL_VERSION_3_0", glEndConditionalRender },
-    { "glEndConditionalRenderNV", "GL_NV_conditional_render", glEndConditionalRenderNV },
-    { "glEndConditionalRenderNVX", "GL_NVX_conditional_render", glEndConditionalRenderNVX },
-    { "glEndFragmentShaderATI", "GL_ATI_fragment_shader", glEndFragmentShaderATI },
-    { "glEndOcclusionQueryNV", "GL_NV_occlusion_query", glEndOcclusionQueryNV },
-    { "glEndPerfMonitorAMD", "GL_AMD_performance_monitor", glEndPerfMonitorAMD },
-    { "glEndPerfQueryINTEL", "GL_INTEL_performance_query", glEndPerfQueryINTEL },
-    { "glEndQuery", "GL_VERSION_1_5", glEndQuery },
-    { "glEndQueryARB", "GL_ARB_occlusion_query", glEndQueryARB },
-    { "glEndQueryIndexed", "GL_ARB_transform_feedback3 GL_VERSION_4_0", glEndQueryIndexed },
-    { "glEndTransformFeedback", "GL_VERSION_3_0", glEndTransformFeedback },
-    { "glEndTransformFeedbackEXT", "GL_EXT_transform_feedback", glEndTransformFeedbackEXT },
-    { "glEndTransformFeedbackNV", "GL_NV_transform_feedback", glEndTransformFeedbackNV },
-    { "glEndVertexShaderEXT", "GL_EXT_vertex_shader", glEndVertexShaderEXT },
-    { "glEndVideoCaptureNV", "GL_NV_video_capture", glEndVideoCaptureNV },
-    { "glEvalCoord1xOES", "GL_OES_fixed_point", glEvalCoord1xOES },
-    { "glEvalCoord1xvOES", "GL_OES_fixed_point", glEvalCoord1xvOES },
-    { "glEvalCoord2xOES", "GL_OES_fixed_point", glEvalCoord2xOES },
-    { "glEvalCoord2xvOES", "GL_OES_fixed_point", glEvalCoord2xvOES },
-    { "glEvalMapsNV", "GL_NV_evaluators", glEvalMapsNV },
-    { "glEvaluateDepthValuesARB", "GL_ARB_sample_locations", glEvaluateDepthValuesARB },
-    { "glExecuteProgramNV", "GL_NV_vertex_program", glExecuteProgramNV },
-    { "glExtractComponentEXT", "GL_EXT_vertex_shader", glExtractComponentEXT },
-    { "glFeedbackBufferxOES", "GL_OES_fixed_point", glFeedbackBufferxOES },
-    { "glFenceSync", "GL_ARB_sync GL_VERSION_3_2", glFenceSync },
-    { "glFinalCombinerInputNV", "GL_NV_register_combiners", glFinalCombinerInputNV },
-    { "glFinishAsyncSGIX", "GL_SGIX_async", glFinishAsyncSGIX },
-    { "glFinishFenceAPPLE", "GL_APPLE_fence", glFinishFenceAPPLE },
-    { "glFinishFenceNV", "GL_NV_fence", glFinishFenceNV },
-    { "glFinishObjectAPPLE", "GL_APPLE_fence", glFinishObjectAPPLE },
-    { "glFinishTextureSUNX", "GL_SUNX_constant_data", glFinishTextureSUNX },
-    { "glFlushMappedBufferRange", "GL_ARB_map_buffer_range GL_VERSION_3_0", glFlushMappedBufferRange },
-    { "glFlushMappedBufferRangeAPPLE", "GL_APPLE_flush_buffer_range", glFlushMappedBufferRangeAPPLE },
-    { "glFlushMappedNamedBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5", glFlushMappedNamedBufferRange },
-    { "glFlushMappedNamedBufferRangeEXT", "GL_EXT_direct_state_access", glFlushMappedNamedBufferRangeEXT },
-    { "glFlushPixelDataRangeNV", "GL_NV_pixel_data_range", glFlushPixelDataRangeNV },
-    { "glFlushRasterSGIX", "GL_SGIX_flush_raster", glFlushRasterSGIX },
-    { "glFlushStaticDataIBM", "GL_IBM_static_data", glFlushStaticDataIBM },
-    { "glFlushVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range", glFlushVertexArrayRangeAPPLE },
-    { "glFlushVertexArrayRangeNV", "GL_NV_vertex_array_range", glFlushVertexArrayRangeNV },
-    { "glFogCoordFormatNV", "GL_NV_vertex_buffer_unified_memory", glFogCoordFormatNV },
-    { "glFogCoordPointer", "GL_VERSION_1_4", glFogCoordPointer },
-    { "glFogCoordPointerEXT", "GL_EXT_fog_coord", glFogCoordPointerEXT },
-    { "glFogCoordPointerListIBM", "GL_IBM_vertex_array_lists", glFogCoordPointerListIBM },
-    { "glFogCoordd", "GL_VERSION_1_4", glFogCoordd },
-    { "glFogCoorddEXT", "GL_EXT_fog_coord", glFogCoorddEXT },
-    { "glFogCoorddv", "GL_VERSION_1_4", glFogCoorddv },
-    { "glFogCoorddvEXT", "GL_EXT_fog_coord", glFogCoorddvEXT },
-    { "glFogCoordf", "GL_VERSION_1_4", glFogCoordf },
-    { "glFogCoordfEXT", "GL_EXT_fog_coord", glFogCoordfEXT },
-    { "glFogCoordfv", "GL_VERSION_1_4", glFogCoordfv },
-    { "glFogCoordfvEXT", "GL_EXT_fog_coord", glFogCoordfvEXT },
-    { "glFogCoordhNV", "GL_NV_half_float", glFogCoordhNV },
-    { "glFogCoordhvNV", "GL_NV_half_float", glFogCoordhvNV },
-    { "glFogFuncSGIS", "GL_SGIS_fog_function", glFogFuncSGIS },
-    { "glFogxOES", "GL_OES_fixed_point", glFogxOES },
-    { "glFogxvOES", "GL_OES_fixed_point", glFogxvOES },
-    { "glFragmentColorMaterialSGIX", "GL_SGIX_fragment_lighting", glFragmentColorMaterialSGIX },
-    { "glFragmentCoverageColorNV", "GL_NV_fragment_coverage_to_color", glFragmentCoverageColorNV },
-    { "glFragmentLightModelfSGIX", "GL_SGIX_fragment_lighting", glFragmentLightModelfSGIX },
-    { "glFragmentLightModelfvSGIX", "GL_SGIX_fragment_lighting", glFragmentLightModelfvSGIX },
-    { "glFragmentLightModeliSGIX", "GL_SGIX_fragment_lighting", glFragmentLightModeliSGIX },
-    { "glFragmentLightModelivSGIX", "GL_SGIX_fragment_lighting", glFragmentLightModelivSGIX },
-    { "glFragmentLightfSGIX", "GL_SGIX_fragment_lighting", glFragmentLightfSGIX },
-    { "glFragmentLightfvSGIX", "GL_SGIX_fragment_lighting", glFragmentLightfvSGIX },
-    { "glFragmentLightiSGIX", "GL_SGIX_fragment_lighting", glFragmentLightiSGIX },
-    { "glFragmentLightivSGIX", "GL_SGIX_fragment_lighting", glFragmentLightivSGIX },
-    { "glFragmentMaterialfSGIX", "GL_SGIX_fragment_lighting", glFragmentMaterialfSGIX },
-    { "glFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting", glFragmentMaterialfvSGIX },
-    { "glFragmentMaterialiSGIX", "GL_SGIX_fragment_lighting", glFragmentMaterialiSGIX },
-    { "glFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting", glFragmentMaterialivSGIX },
-    { "glFrameTerminatorGREMEDY", "GL_GREMEDY_frame_terminator", glFrameTerminatorGREMEDY },
-    { "glFrameZoomSGIX", "GL_SGIX_framezoom", glFrameZoomSGIX },
-    { "glFramebufferDrawBufferEXT", "GL_EXT_direct_state_access", glFramebufferDrawBufferEXT },
-    { "glFramebufferDrawBuffersEXT", "GL_EXT_direct_state_access", glFramebufferDrawBuffersEXT },
-    { "glFramebufferFetchBarrierEXT", "GL_EXT_shader_framebuffer_fetch_non_coherent", glFramebufferFetchBarrierEXT },
-    { "glFramebufferParameteri", "GL_ARB_framebuffer_no_attachments GL_VERSION_4_3", glFramebufferParameteri },
-    { "glFramebufferParameteriMESA", "GL_MESA_framebuffer_flip_y", glFramebufferParameteriMESA },
-    { "glFramebufferReadBufferEXT", "GL_EXT_direct_state_access", glFramebufferReadBufferEXT },
-    { "glFramebufferRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glFramebufferRenderbuffer },
-    { "glFramebufferRenderbufferEXT", "GL_EXT_framebuffer_object", glFramebufferRenderbufferEXT },
-    { "glFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations", glFramebufferSampleLocationsfvARB },
-    { "glFramebufferSampleLocationsfvNV", "GL_NV_sample_locations", glFramebufferSampleLocationsfvNV },
-    { "glFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions", glFramebufferSamplePositionsfvAMD },
-    { "glFramebufferTexture", "GL_VERSION_3_2", glFramebufferTexture },
-    { "glFramebufferTexture1D", "GL_ARB_framebuffer_object GL_VERSION_3_0", glFramebufferTexture1D },
-    { "glFramebufferTexture1DEXT", "GL_EXT_framebuffer_object", glFramebufferTexture1DEXT },
-    { "glFramebufferTexture2D", "GL_ARB_framebuffer_object GL_VERSION_3_0", glFramebufferTexture2D },
-    { "glFramebufferTexture2DEXT", "GL_EXT_framebuffer_object", glFramebufferTexture2DEXT },
-    { "glFramebufferTexture3D", "GL_ARB_framebuffer_object GL_VERSION_3_0", glFramebufferTexture3D },
-    { "glFramebufferTexture3DEXT", "GL_EXT_framebuffer_object", glFramebufferTexture3DEXT },
-    { "glFramebufferTextureARB", "GL_ARB_geometry_shader4", glFramebufferTextureARB },
-    { "glFramebufferTextureEXT", "GL_NV_geometry_program4", glFramebufferTextureEXT },
-    { "glFramebufferTextureFaceARB", "GL_ARB_geometry_shader4", glFramebufferTextureFaceARB },
-    { "glFramebufferTextureFaceEXT", "GL_NV_geometry_program4", glFramebufferTextureFaceEXT },
-    { "glFramebufferTextureLayer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glFramebufferTextureLayer },
-    { "glFramebufferTextureLayerARB", "GL_ARB_geometry_shader4", glFramebufferTextureLayerARB },
-    { "glFramebufferTextureLayerEXT", "GL_EXT_texture_array GL_NV_geometry_program4", glFramebufferTextureLayerEXT },
-    { "glFramebufferTextureMultiviewOVR", "GL_OVR_multiview", glFramebufferTextureMultiviewOVR },
-    { "glFreeObjectBufferATI", "GL_ATI_vertex_array_object", glFreeObjectBufferATI },
-    { "glFrustumfOES", "GL_OES_single_precision", glFrustumfOES },
-    { "glFrustumxOES", "GL_OES_fixed_point", glFrustumxOES },
-    { "glGenAsyncMarkersSGIX", "GL_SGIX_async", glGenAsyncMarkersSGIX },
-    { "glGenBuffers", "GL_VERSION_1_5", glGenBuffers },
-    { "glGenBuffersARB", "GL_ARB_vertex_buffer_object", glGenBuffersARB },
-    { "glGenFencesAPPLE", "GL_APPLE_fence", glGenFencesAPPLE },
-    { "glGenFencesNV", "GL_NV_fence", glGenFencesNV },
-    { "glGenFragmentShadersATI", "GL_ATI_fragment_shader", glGenFragmentShadersATI },
-    { "glGenFramebuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0", glGenFramebuffers },
-    { "glGenFramebuffersEXT", "GL_EXT_framebuffer_object", glGenFramebuffersEXT },
-    { "glGenNamesAMD", "GL_AMD_name_gen_delete", glGenNamesAMD },
-    { "glGenOcclusionQueriesNV", "GL_NV_occlusion_query", glGenOcclusionQueriesNV },
-    { "glGenPathsNV", "GL_NV_path_rendering", glGenPathsNV },
-    { "glGenPerfMonitorsAMD", "GL_AMD_performance_monitor", glGenPerfMonitorsAMD },
-    { "glGenProgramPipelines", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glGenProgramPipelines },
-    { "glGenProgramsARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGenProgramsARB },
-    { "glGenProgramsNV", "GL_NV_vertex_program", glGenProgramsNV },
-    { "glGenQueries", "GL_VERSION_1_5", glGenQueries },
-    { "glGenQueriesARB", "GL_ARB_occlusion_query", glGenQueriesARB },
-    { "glGenQueryResourceTagNV", "GL_NV_query_resource_tag", glGenQueryResourceTagNV },
-    { "glGenRenderbuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0", glGenRenderbuffers },
-    { "glGenRenderbuffersEXT", "GL_EXT_framebuffer_object", glGenRenderbuffersEXT },
-    { "glGenSamplers", "GL_ARB_sampler_objects GL_VERSION_3_3", glGenSamplers },
-    { "glGenSemaphoresEXT", "GL_EXT_semaphore", glGenSemaphoresEXT },
-    { "glGenSymbolsEXT", "GL_EXT_vertex_shader", glGenSymbolsEXT },
-    { "glGenTexturesEXT", "GL_EXT_texture_object", glGenTexturesEXT },
-    { "glGenTransformFeedbacks", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glGenTransformFeedbacks },
-    { "glGenTransformFeedbacksNV", "GL_NV_transform_feedback2", glGenTransformFeedbacksNV },
-    { "glGenVertexArrays", "GL_ARB_vertex_array_object GL_VERSION_3_0", glGenVertexArrays },
-    { "glGenVertexArraysAPPLE", "GL_APPLE_vertex_array_object", glGenVertexArraysAPPLE },
-    { "glGenVertexShadersEXT", "GL_EXT_vertex_shader", glGenVertexShadersEXT },
-    { "glGenerateMipmap", "GL_ARB_framebuffer_object GL_VERSION_3_0", glGenerateMipmap },
-    { "glGenerateMipmapEXT", "GL_EXT_framebuffer_object", glGenerateMipmapEXT },
-    { "glGenerateMultiTexMipmapEXT", "GL_EXT_direct_state_access", glGenerateMultiTexMipmapEXT },
-    { "glGenerateTextureMipmap", "GL_ARB_direct_state_access GL_VERSION_4_5", glGenerateTextureMipmap },
-    { "glGenerateTextureMipmapEXT", "GL_EXT_direct_state_access", glGenerateTextureMipmapEXT },
-    { "glGetActiveAtomicCounterBufferiv", "GL_ARB_shader_atomic_counters GL_VERSION_4_2", glGetActiveAtomicCounterBufferiv },
-    { "glGetActiveAttrib", "GL_VERSION_2_0", glGetActiveAttrib },
-    { "glGetActiveAttribARB", "GL_ARB_vertex_shader", glGetActiveAttribARB },
-    { "glGetActiveSubroutineName", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetActiveSubroutineName },
-    { "glGetActiveSubroutineUniformName", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetActiveSubroutineUniformName },
-    { "glGetActiveSubroutineUniformiv", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetActiveSubroutineUniformiv },
-    { "glGetActiveUniform", "GL_VERSION_2_0", glGetActiveUniform },
-    { "glGetActiveUniformARB", "GL_ARB_shader_objects", glGetActiveUniformARB },
-    { "glGetActiveUniformBlockName", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetActiveUniformBlockName },
-    { "glGetActiveUniformBlockiv", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetActiveUniformBlockiv },
-    { "glGetActiveUniformName", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetActiveUniformName },
-    { "glGetActiveUniformsiv", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetActiveUniformsiv },
-    { "glGetActiveVaryingNV", "GL_NV_transform_feedback", glGetActiveVaryingNV },
-    { "glGetArrayObjectfvATI", "GL_ATI_vertex_array_object", glGetArrayObjectfvATI },
-    { "glGetArrayObjectivATI", "GL_ATI_vertex_array_object", glGetArrayObjectivATI },
-    { "glGetAttachedObjectsARB", "GL_ARB_shader_objects", glGetAttachedObjectsARB },
-    { "glGetAttachedShaders", "GL_VERSION_2_0", glGetAttachedShaders },
-    { "glGetAttribLocation", "GL_VERSION_2_0", glGetAttribLocation },
-    { "glGetAttribLocationARB", "GL_ARB_vertex_shader", glGetAttribLocationARB },
-    { "glGetBooleanIndexedvEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2", glGetBooleanIndexedvEXT },
-    { "glGetBooleani_v", "GL_VERSION_3_0", glGetBooleani_v },
-    { "glGetBufferParameteri64v", "GL_VERSION_3_2", glGetBufferParameteri64v },
-    { "glGetBufferParameteriv", "GL_VERSION_1_5", glGetBufferParameteriv },
-    { "glGetBufferParameterivARB", "GL_ARB_vertex_buffer_object", glGetBufferParameterivARB },
-    { "glGetBufferParameterui64vNV", "GL_NV_shader_buffer_load", glGetBufferParameterui64vNV },
-    { "glGetBufferPointerv", "GL_VERSION_1_5", glGetBufferPointerv },
-    { "glGetBufferPointervARB", "GL_ARB_vertex_buffer_object", glGetBufferPointervARB },
-    { "glGetBufferSubData", "GL_VERSION_1_5", glGetBufferSubData },
-    { "glGetBufferSubDataARB", "GL_ARB_vertex_buffer_object", glGetBufferSubDataARB },
-    { "glGetClipPlanefOES", "GL_OES_single_precision", glGetClipPlanefOES },
-    { "glGetClipPlanexOES", "GL_OES_fixed_point", glGetClipPlanexOES },
-    { "glGetColorTable", "GL_ARB_imaging", glGetColorTable },
-    { "glGetColorTableEXT", "GL_EXT_paletted_texture", glGetColorTableEXT },
-    { "glGetColorTableParameterfv", "GL_ARB_imaging", glGetColorTableParameterfv },
-    { "glGetColorTableParameterfvEXT", "GL_EXT_paletted_texture", glGetColorTableParameterfvEXT },
-    { "glGetColorTableParameterfvSGI", "GL_SGI_color_table", glGetColorTableParameterfvSGI },
-    { "glGetColorTableParameteriv", "GL_ARB_imaging", glGetColorTableParameteriv },
-    { "glGetColorTableParameterivEXT", "GL_EXT_paletted_texture", glGetColorTableParameterivEXT },
-    { "glGetColorTableParameterivSGI", "GL_SGI_color_table", glGetColorTableParameterivSGI },
-    { "glGetColorTableSGI", "GL_SGI_color_table", glGetColorTableSGI },
-    { "glGetCombinerInputParameterfvNV", "GL_NV_register_combiners", glGetCombinerInputParameterfvNV },
-    { "glGetCombinerInputParameterivNV", "GL_NV_register_combiners", glGetCombinerInputParameterivNV },
-    { "glGetCombinerOutputParameterfvNV", "GL_NV_register_combiners", glGetCombinerOutputParameterfvNV },
-    { "glGetCombinerOutputParameterivNV", "GL_NV_register_combiners", glGetCombinerOutputParameterivNV },
-    { "glGetCombinerStageParameterfvNV", "GL_NV_register_combiners2", glGetCombinerStageParameterfvNV },
-    { "glGetCommandHeaderNV", "GL_NV_command_list", glGetCommandHeaderNV },
-    { "glGetCompressedMultiTexImageEXT", "GL_EXT_direct_state_access", glGetCompressedMultiTexImageEXT },
-    { "glGetCompressedTexImage", "GL_VERSION_1_3", glGetCompressedTexImage },
-    { "glGetCompressedTexImageARB", "GL_ARB_texture_compression", glGetCompressedTexImageARB },
-    { "glGetCompressedTextureImage", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetCompressedTextureImage },
-    { "glGetCompressedTextureImageEXT", "GL_EXT_direct_state_access", glGetCompressedTextureImageEXT },
-    { "glGetCompressedTextureSubImage", "GL_ARB_get_texture_sub_image GL_VERSION_4_5", glGetCompressedTextureSubImage },
-    { "glGetConvolutionFilter", "GL_ARB_imaging", glGetConvolutionFilter },
-    { "glGetConvolutionFilterEXT", "GL_EXT_convolution", glGetConvolutionFilterEXT },
-    { "glGetConvolutionParameterfv", "GL_ARB_imaging", glGetConvolutionParameterfv },
-    { "glGetConvolutionParameterfvEXT", "GL_EXT_convolution", glGetConvolutionParameterfvEXT },
-    { "glGetConvolutionParameteriv", "GL_ARB_imaging", glGetConvolutionParameteriv },
-    { "glGetConvolutionParameterivEXT", "GL_EXT_convolution", glGetConvolutionParameterivEXT },
-    { "glGetConvolutionParameterxvOES", "GL_OES_fixed_point", glGetConvolutionParameterxvOES },
-    { "glGetCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples", glGetCoverageModulationTableNV },
-    { "glGetDebugMessageLog", "GL_KHR_debug GL_VERSION_4_3", glGetDebugMessageLog },
-    { "glGetDebugMessageLogAMD", "GL_AMD_debug_output", glGetDebugMessageLogAMD },
-    { "glGetDebugMessageLogARB", "GL_ARB_debug_output", glGetDebugMessageLogARB },
-    { "glGetDetailTexFuncSGIS", "GL_SGIS_detail_texture", glGetDetailTexFuncSGIS },
-    { "glGetDoubleIndexedvEXT", "GL_EXT_direct_state_access", glGetDoubleIndexedvEXT },
-    { "glGetDoublei_v", "GL_ARB_viewport_array GL_VERSION_4_1", glGetDoublei_v },
-    { "glGetDoublei_vEXT", "GL_EXT_direct_state_access", glGetDoublei_vEXT },
-    { "glGetFenceivNV", "GL_NV_fence", glGetFenceivNV },
-    { "glGetFinalCombinerInputParameterfvNV", "GL_NV_register_combiners", glGetFinalCombinerInputParameterfvNV },
-    { "glGetFinalCombinerInputParameterivNV", "GL_NV_register_combiners", glGetFinalCombinerInputParameterivNV },
-    { "glGetFirstPerfQueryIdINTEL", "GL_INTEL_performance_query", glGetFirstPerfQueryIdINTEL },
-    { "glGetFixedvOES", "GL_OES_fixed_point", glGetFixedvOES },
-    { "glGetFloatIndexedvEXT", "GL_EXT_direct_state_access", glGetFloatIndexedvEXT },
-    { "glGetFloati_v", "GL_ARB_viewport_array GL_VERSION_4_1", glGetFloati_v },
-    { "glGetFloati_vEXT", "GL_EXT_direct_state_access", glGetFloati_vEXT },
-    { "glGetFogFuncSGIS", "GL_SGIS_fog_function", glGetFogFuncSGIS },
-    { "glGetFragDataIndex", "GL_ARB_blend_func_extended GL_VERSION_3_3", glGetFragDataIndex },
-    { "glGetFragDataLocation", "GL_VERSION_3_0", glGetFragDataLocation },
-    { "glGetFragDataLocationEXT", "GL_EXT_gpu_shader4", glGetFragDataLocationEXT },
-    { "glGetFragmentLightfvSGIX", "GL_SGIX_fragment_lighting", glGetFragmentLightfvSGIX },
-    { "glGetFragmentLightivSGIX", "GL_SGIX_fragment_lighting", glGetFragmentLightivSGIX },
-    { "glGetFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting", glGetFragmentMaterialfvSGIX },
-    { "glGetFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting", glGetFragmentMaterialivSGIX },
-    { "glGetFramebufferAttachmentParameteriv", "GL_ARB_framebuffer_object GL_VERSION_3_0", glGetFramebufferAttachmentParameteriv },
-    { "glGetFramebufferAttachmentParameterivEXT", "GL_EXT_framebuffer_object", glGetFramebufferAttachmentParameterivEXT },
-    { "glGetFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions", glGetFramebufferParameterfvAMD },
-    { "glGetFramebufferParameteriv", "GL_ARB_framebuffer_no_attachments GL_VERSION_4_3", glGetFramebufferParameteriv },
-    { "glGetFramebufferParameterivEXT", "GL_EXT_direct_state_access", glGetFramebufferParameterivEXT },
-    { "glGetFramebufferParameterivMESA", "GL_MESA_framebuffer_flip_y", glGetFramebufferParameterivMESA },
-    { "glGetGraphicsResetStatus", "GL_KHR_robustness GL_VERSION_4_5", glGetGraphicsResetStatus },
-    { "glGetGraphicsResetStatusARB", "GL_ARB_robustness", glGetGraphicsResetStatusARB },
-    { "glGetHandleARB", "GL_ARB_shader_objects", glGetHandleARB },
-    { "glGetHistogram", "GL_ARB_imaging", glGetHistogram },
-    { "glGetHistogramEXT", "GL_EXT_histogram", glGetHistogramEXT },
-    { "glGetHistogramParameterfv", "GL_ARB_imaging", glGetHistogramParameterfv },
-    { "glGetHistogramParameterfvEXT", "GL_EXT_histogram", glGetHistogramParameterfvEXT },
-    { "glGetHistogramParameteriv", "GL_ARB_imaging", glGetHistogramParameteriv },
-    { "glGetHistogramParameterivEXT", "GL_EXT_histogram", glGetHistogramParameterivEXT },
-    { "glGetHistogramParameterxvOES", "GL_OES_fixed_point", glGetHistogramParameterxvOES },
-    { "glGetImageHandleARB", "GL_ARB_bindless_texture", glGetImageHandleARB },
-    { "glGetImageHandleNV", "GL_NV_bindless_texture", glGetImageHandleNV },
-    { "glGetImageTransformParameterfvHP", "GL_HP_image_transform", glGetImageTransformParameterfvHP },
-    { "glGetImageTransformParameterivHP", "GL_HP_image_transform", glGetImageTransformParameterivHP },
-    { "glGetInfoLogARB", "GL_ARB_shader_objects", glGetInfoLogARB },
-    { "glGetInstrumentsSGIX", "GL_SGIX_instruments", glGetInstrumentsSGIX },
-    { "glGetInteger64i_v", "GL_VERSION_3_2", glGetInteger64i_v },
-    { "glGetInteger64v", "GL_ARB_sync GL_VERSION_3_2", glGetInteger64v },
-    { "glGetIntegerIndexedvEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2", glGetIntegerIndexedvEXT },
-    { "glGetIntegeri_v", "GL_ARB_uniform_buffer_object GL_VERSION_3_0", glGetIntegeri_v },
-    { "glGetIntegerui64i_vNV", "GL_NV_vertex_buffer_unified_memory", glGetIntegerui64i_vNV },
-    { "glGetIntegerui64vNV", "GL_NV_shader_buffer_load", glGetIntegerui64vNV },
-    { "glGetInternalformatSampleivNV", "GL_NV_internalformat_sample_query", glGetInternalformatSampleivNV },
-    { "glGetInternalformati64v", "GL_ARB_internalformat_query2 GL_VERSION_4_3", glGetInternalformati64v },
-    { "glGetInternalformativ", "GL_ARB_internalformat_query GL_VERSION_4_2", glGetInternalformativ },
-    { "glGetInvariantBooleanvEXT", "GL_EXT_vertex_shader", glGetInvariantBooleanvEXT },
-    { "glGetInvariantFloatvEXT", "GL_EXT_vertex_shader", glGetInvariantFloatvEXT },
-    { "glGetInvariantIntegervEXT", "GL_EXT_vertex_shader", glGetInvariantIntegervEXT },
-    { "glGetLightxOES", "GL_OES_fixed_point", glGetLightxOES },
-    { "glGetListParameterfvSGIX", "GL_SGIX_list_priority", glGetListParameterfvSGIX },
-    { "glGetListParameterivSGIX", "GL_SGIX_list_priority", glGetListParameterivSGIX },
-    { "glGetLocalConstantBooleanvEXT", "GL_EXT_vertex_shader", glGetLocalConstantBooleanvEXT },
-    { "glGetLocalConstantFloatvEXT", "GL_EXT_vertex_shader", glGetLocalConstantFloatvEXT },
-    { "glGetLocalConstantIntegervEXT", "GL_EXT_vertex_shader", glGetLocalConstantIntegervEXT },
-    { "glGetMapAttribParameterfvNV", "GL_NV_evaluators", glGetMapAttribParameterfvNV },
-    { "glGetMapAttribParameterivNV", "GL_NV_evaluators", glGetMapAttribParameterivNV },
-    { "glGetMapControlPointsNV", "GL_NV_evaluators", glGetMapControlPointsNV },
-    { "glGetMapParameterfvNV", "GL_NV_evaluators", glGetMapParameterfvNV },
-    { "glGetMapParameterivNV", "GL_NV_evaluators", glGetMapParameterivNV },
-    { "glGetMapxvOES", "GL_OES_fixed_point", glGetMapxvOES },
-    { "glGetMaterialxOES", "GL_OES_fixed_point", glGetMaterialxOES },
-    { "glGetMemoryObjectDetachedResourcesuivNV", "GL_NV_memory_attachment", glGetMemoryObjectDetachedResourcesuivNV },
-    { "glGetMemoryObjectParameterivEXT", "GL_EXT_memory_object", glGetMemoryObjectParameterivEXT },
-    { "glGetMinmax", "GL_ARB_imaging", glGetMinmax },
-    { "glGetMinmaxEXT", "GL_EXT_histogram", glGetMinmaxEXT },
-    { "glGetMinmaxParameterfv", "GL_ARB_imaging", glGetMinmaxParameterfv },
-    { "glGetMinmaxParameterfvEXT", "GL_EXT_histogram", glGetMinmaxParameterfvEXT },
-    { "glGetMinmaxParameteriv", "GL_ARB_imaging", glGetMinmaxParameteriv },
-    { "glGetMinmaxParameterivEXT", "GL_EXT_histogram", glGetMinmaxParameterivEXT },
-    { "glGetMultiTexEnvfvEXT", "GL_EXT_direct_state_access", glGetMultiTexEnvfvEXT },
-    { "glGetMultiTexEnvivEXT", "GL_EXT_direct_state_access", glGetMultiTexEnvivEXT },
-    { "glGetMultiTexGendvEXT", "GL_EXT_direct_state_access", glGetMultiTexGendvEXT },
-    { "glGetMultiTexGenfvEXT", "GL_EXT_direct_state_access", glGetMultiTexGenfvEXT },
-    { "glGetMultiTexGenivEXT", "GL_EXT_direct_state_access", glGetMultiTexGenivEXT },
-    { "glGetMultiTexImageEXT", "GL_EXT_direct_state_access", glGetMultiTexImageEXT },
-    { "glGetMultiTexLevelParameterfvEXT", "GL_EXT_direct_state_access", glGetMultiTexLevelParameterfvEXT },
-    { "glGetMultiTexLevelParameterivEXT", "GL_EXT_direct_state_access", glGetMultiTexLevelParameterivEXT },
-    { "glGetMultiTexParameterIivEXT", "GL_EXT_direct_state_access", glGetMultiTexParameterIivEXT },
-    { "glGetMultiTexParameterIuivEXT", "GL_EXT_direct_state_access", glGetMultiTexParameterIuivEXT },
-    { "glGetMultiTexParameterfvEXT", "GL_EXT_direct_state_access", glGetMultiTexParameterfvEXT },
-    { "glGetMultiTexParameterivEXT", "GL_EXT_direct_state_access", glGetMultiTexParameterivEXT },
-    { "glGetMultisamplefv", "GL_ARB_texture_multisample GL_VERSION_3_2", glGetMultisamplefv },
-    { "glGetMultisamplefvNV", "GL_NV_explicit_multisample", glGetMultisamplefvNV },
-    { "glGetNamedBufferParameteri64v", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedBufferParameteri64v },
-    { "glGetNamedBufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedBufferParameteriv },
-    { "glGetNamedBufferParameterivEXT", "GL_EXT_direct_state_access", glGetNamedBufferParameterivEXT },
-    { "glGetNamedBufferParameterui64vNV", "GL_NV_shader_buffer_load", glGetNamedBufferParameterui64vNV },
-    { "glGetNamedBufferPointerv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedBufferPointerv },
-    { "glGetNamedBufferPointervEXT", "GL_EXT_direct_state_access", glGetNamedBufferPointervEXT },
-    { "glGetNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedBufferSubData },
-    { "glGetNamedBufferSubDataEXT", "GL_EXT_direct_state_access", glGetNamedBufferSubDataEXT },
-    { "glGetNamedFramebufferAttachmentParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedFramebufferAttachmentParameteriv },
-    { "glGetNamedFramebufferAttachmentParameterivEXT", "GL_EXT_direct_state_access", glGetNamedFramebufferAttachmentParameterivEXT },
-    { "glGetNamedFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions", glGetNamedFramebufferParameterfvAMD },
-    { "glGetNamedFramebufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedFramebufferParameteriv },
-    { "glGetNamedFramebufferParameterivEXT", "GL_EXT_direct_state_access", glGetNamedFramebufferParameterivEXT },
-    { "glGetNamedProgramLocalParameterIivEXT", "GL_EXT_direct_state_access", glGetNamedProgramLocalParameterIivEXT },
-    { "glGetNamedProgramLocalParameterIuivEXT", "GL_EXT_direct_state_access", glGetNamedProgramLocalParameterIuivEXT },
-    { "glGetNamedProgramLocalParameterdvEXT", "GL_EXT_direct_state_access", glGetNamedProgramLocalParameterdvEXT },
-    { "glGetNamedProgramLocalParameterfvEXT", "GL_EXT_direct_state_access", glGetNamedProgramLocalParameterfvEXT },
-    { "glGetNamedProgramStringEXT", "GL_EXT_direct_state_access", glGetNamedProgramStringEXT },
-    { "glGetNamedProgramivEXT", "GL_EXT_direct_state_access", glGetNamedProgramivEXT },
-    { "glGetNamedRenderbufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetNamedRenderbufferParameteriv },
-    { "glGetNamedRenderbufferParameterivEXT", "GL_EXT_direct_state_access", glGetNamedRenderbufferParameterivEXT },
-    { "glGetNamedStringARB", "GL_ARB_shading_language_include", glGetNamedStringARB },
-    { "glGetNamedStringivARB", "GL_ARB_shading_language_include", glGetNamedStringivARB },
-    { "glGetNextPerfQueryIdINTEL", "GL_INTEL_performance_query", glGetNextPerfQueryIdINTEL },
-    { "glGetObjectBufferfvATI", "GL_ATI_vertex_array_object", glGetObjectBufferfvATI },
-    { "glGetObjectBufferivATI", "GL_ATI_vertex_array_object", glGetObjectBufferivATI },
-    { "glGetObjectLabel", "GL_KHR_debug GL_VERSION_4_3", glGetObjectLabel },
-    { "glGetObjectLabelEXT", "GL_EXT_debug_label", glGetObjectLabelEXT },
-    { "glGetObjectParameterfvARB", "GL_ARB_shader_objects", glGetObjectParameterfvARB },
-    { "glGetObjectParameterivAPPLE", "GL_APPLE_object_purgeable", glGetObjectParameterivAPPLE },
-    { "glGetObjectParameterivARB", "GL_ARB_shader_objects", glGetObjectParameterivARB },
-    { "glGetObjectPtrLabel", "GL_KHR_debug GL_VERSION_4_3", glGetObjectPtrLabel },
-    { "glGetOcclusionQueryivNV", "GL_NV_occlusion_query", glGetOcclusionQueryivNV },
-    { "glGetOcclusionQueryuivNV", "GL_NV_occlusion_query", glGetOcclusionQueryuivNV },
-    { "glGetPathColorGenfvNV", "GL_NV_path_rendering", glGetPathColorGenfvNV },
-    { "glGetPathColorGenivNV", "GL_NV_path_rendering", glGetPathColorGenivNV },
-    { "glGetPathCommandsNV", "GL_NV_path_rendering", glGetPathCommandsNV },
-    { "glGetPathCoordsNV", "GL_NV_path_rendering", glGetPathCoordsNV },
-    { "glGetPathDashArrayNV", "GL_NV_path_rendering", glGetPathDashArrayNV },
-    { "glGetPathLengthNV", "GL_NV_path_rendering", glGetPathLengthNV },
-    { "glGetPathMetricRangeNV", "GL_NV_path_rendering", glGetPathMetricRangeNV },
-    { "glGetPathMetricsNV", "GL_NV_path_rendering", glGetPathMetricsNV },
-    { "glGetPathParameterfvNV", "GL_NV_path_rendering", glGetPathParameterfvNV },
-    { "glGetPathParameterivNV", "GL_NV_path_rendering", glGetPathParameterivNV },
-    { "glGetPathSpacingNV", "GL_NV_path_rendering", glGetPathSpacingNV },
-    { "glGetPathTexGenfvNV", "GL_NV_path_rendering", glGetPathTexGenfvNV },
-    { "glGetPathTexGenivNV", "GL_NV_path_rendering", glGetPathTexGenivNV },
-    { "glGetPerfCounterInfoINTEL", "GL_INTEL_performance_query", glGetPerfCounterInfoINTEL },
-    { "glGetPerfMonitorCounterDataAMD", "GL_AMD_performance_monitor", glGetPerfMonitorCounterDataAMD },
-    { "glGetPerfMonitorCounterInfoAMD", "GL_AMD_performance_monitor", glGetPerfMonitorCounterInfoAMD },
-    { "glGetPerfMonitorCounterStringAMD", "GL_AMD_performance_monitor", glGetPerfMonitorCounterStringAMD },
-    { "glGetPerfMonitorCountersAMD", "GL_AMD_performance_monitor", glGetPerfMonitorCountersAMD },
-    { "glGetPerfMonitorGroupStringAMD", "GL_AMD_performance_monitor", glGetPerfMonitorGroupStringAMD },
-    { "glGetPerfMonitorGroupsAMD", "GL_AMD_performance_monitor", glGetPerfMonitorGroupsAMD },
-    { "glGetPerfQueryDataINTEL", "GL_INTEL_performance_query", glGetPerfQueryDataINTEL },
-    { "glGetPerfQueryIdByNameINTEL", "GL_INTEL_performance_query", glGetPerfQueryIdByNameINTEL },
-    { "glGetPerfQueryInfoINTEL", "GL_INTEL_performance_query", glGetPerfQueryInfoINTEL },
-    { "glGetPixelMapxv", "GL_OES_fixed_point", glGetPixelMapxv },
-    { "glGetPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture", glGetPixelTexGenParameterfvSGIS },
-    { "glGetPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture", glGetPixelTexGenParameterivSGIS },
-    { "glGetPixelTransformParameterfvEXT", "GL_EXT_pixel_transform", glGetPixelTransformParameterfvEXT },
-    { "glGetPixelTransformParameterivEXT", "GL_EXT_pixel_transform", glGetPixelTransformParameterivEXT },
-    { "glGetPointerIndexedvEXT", "GL_EXT_direct_state_access", glGetPointerIndexedvEXT },
-    { "glGetPointeri_vEXT", "GL_EXT_direct_state_access", glGetPointeri_vEXT },
-    { "glGetPointervEXT", "GL_EXT_vertex_array", glGetPointervEXT },
-    { "glGetProgramBinary", "GL_ARB_get_program_binary GL_VERSION_4_1", glGetProgramBinary },
-    { "glGetProgramEnvParameterIivNV", "GL_NV_gpu_program4", glGetProgramEnvParameterIivNV },
-    { "glGetProgramEnvParameterIuivNV", "GL_NV_gpu_program4", glGetProgramEnvParameterIuivNV },
-    { "glGetProgramEnvParameterdvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramEnvParameterdvARB },
-    { "glGetProgramEnvParameterfvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramEnvParameterfvARB },
-    { "glGetProgramInfoLog", "GL_VERSION_2_0", glGetProgramInfoLog },
-    { "glGetProgramInterfaceiv", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramInterfaceiv },
-    { "glGetProgramLocalParameterIivNV", "GL_NV_gpu_program4", glGetProgramLocalParameterIivNV },
-    { "glGetProgramLocalParameterIuivNV", "GL_NV_gpu_program4", glGetProgramLocalParameterIuivNV },
-    { "glGetProgramLocalParameterdvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramLocalParameterdvARB },
-    { "glGetProgramLocalParameterfvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramLocalParameterfvARB },
-    { "glGetProgramNamedParameterdvNV", "GL_NV_fragment_program", glGetProgramNamedParameterdvNV },
-    { "glGetProgramNamedParameterfvNV", "GL_NV_fragment_program", glGetProgramNamedParameterfvNV },
-    { "glGetProgramParameterdvNV", "GL_NV_vertex_program", glGetProgramParameterdvNV },
-    { "glGetProgramParameterfvNV", "GL_NV_vertex_program", glGetProgramParameterfvNV },
-    { "glGetProgramPipelineInfoLog", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glGetProgramPipelineInfoLog },
-    { "glGetProgramPipelineiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glGetProgramPipelineiv },
-    { "glGetProgramResourceIndex", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramResourceIndex },
-    { "glGetProgramResourceLocation", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramResourceLocation },
-    { "glGetProgramResourceLocationIndex", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramResourceLocationIndex },
-    { "glGetProgramResourceName", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramResourceName },
-    { "glGetProgramResourcefvNV", "GL_NV_path_rendering", glGetProgramResourcefvNV },
-    { "glGetProgramResourceiv", "GL_ARB_program_interface_query GL_VERSION_4_3", glGetProgramResourceiv },
-    { "glGetProgramStageiv", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetProgramStageiv },
-    { "glGetProgramStringARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramStringARB },
-    { "glGetProgramStringNV", "GL_NV_vertex_program", glGetProgramStringNV },
-    { "glGetProgramSubroutineParameteruivNV", "GL_NV_gpu_program5", glGetProgramSubroutineParameteruivNV },
-    { "glGetProgramiv", "GL_VERSION_2_0", glGetProgramiv },
-    { "glGetProgramivARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glGetProgramivARB },
-    { "glGetProgramivNV", "GL_NV_vertex_program", glGetProgramivNV },
-    { "glGetQueryBufferObjecti64v", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetQueryBufferObjecti64v },
-    { "glGetQueryBufferObjectiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetQueryBufferObjectiv },
-    { "glGetQueryBufferObjectui64v", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetQueryBufferObjectui64v },
-    { "glGetQueryBufferObjectuiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetQueryBufferObjectuiv },
-    { "glGetQueryIndexediv", "GL_ARB_transform_feedback3 GL_VERSION_4_0", glGetQueryIndexediv },
-    { "glGetQueryObjecti64v", "GL_ARB_timer_query GL_VERSION_3_3", glGetQueryObjecti64v },
-    { "glGetQueryObjecti64vEXT", "GL_EXT_timer_query", glGetQueryObjecti64vEXT },
-    { "glGetQueryObjectiv", "GL_VERSION_1_5", glGetQueryObjectiv },
-    { "glGetQueryObjectivARB", "GL_ARB_occlusion_query", glGetQueryObjectivARB },
-    { "glGetQueryObjectui64v", "GL_ARB_timer_query GL_VERSION_3_3", glGetQueryObjectui64v },
-    { "glGetQueryObjectui64vEXT", "GL_EXT_timer_query", glGetQueryObjectui64vEXT },
-    { "glGetQueryObjectuiv", "GL_VERSION_1_5", glGetQueryObjectuiv },
-    { "glGetQueryObjectuivARB", "GL_ARB_occlusion_query", glGetQueryObjectuivARB },
-    { "glGetQueryiv", "GL_VERSION_1_5", glGetQueryiv },
-    { "glGetQueryivARB", "GL_ARB_occlusion_query", glGetQueryivARB },
-    { "glGetRenderbufferParameteriv", "GL_ARB_framebuffer_object GL_VERSION_3_0", glGetRenderbufferParameteriv },
-    { "glGetRenderbufferParameterivEXT", "GL_EXT_framebuffer_object", glGetRenderbufferParameterivEXT },
-    { "glGetSamplerParameterIiv", "GL_ARB_sampler_objects GL_VERSION_3_3", glGetSamplerParameterIiv },
-    { "glGetSamplerParameterIuiv", "GL_ARB_sampler_objects GL_VERSION_3_3", glGetSamplerParameterIuiv },
-    { "glGetSamplerParameterfv", "GL_ARB_sampler_objects GL_VERSION_3_3", glGetSamplerParameterfv },
-    { "glGetSamplerParameteriv", "GL_ARB_sampler_objects GL_VERSION_3_3", glGetSamplerParameteriv },
-    { "glGetSemaphoreParameterui64vEXT", "GL_EXT_semaphore", glGetSemaphoreParameterui64vEXT },
-    { "glGetSeparableFilter", "GL_ARB_imaging", glGetSeparableFilter },
-    { "glGetSeparableFilterEXT", "GL_EXT_convolution", glGetSeparableFilterEXT },
-    { "glGetShaderInfoLog", "GL_VERSION_2_0", glGetShaderInfoLog },
-    { "glGetShaderPrecisionFormat", "GL_ARB_ES2_compatibility GL_VERSION_4_1", glGetShaderPrecisionFormat },
-    { "glGetShaderSource", "GL_VERSION_2_0", glGetShaderSource },
-    { "glGetShaderSourceARB", "GL_ARB_shader_objects", glGetShaderSourceARB },
-    { "glGetShaderiv", "GL_VERSION_2_0", glGetShaderiv },
-    { "glGetShadingRateImagePaletteNV", "GL_NV_shading_rate_image", glGetShadingRateImagePaletteNV },
-    { "glGetShadingRateSampleLocationivNV", "GL_NV_shading_rate_image", glGetShadingRateSampleLocationivNV },
-    { "glGetSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture", glGetSharpenTexFuncSGIS },
-    { "glGetStageIndexNV", "GL_NV_command_list", glGetStageIndexNV },
-    { "glGetStringi", "GL_VERSION_3_0", glGetStringi },
-    { "glGetSubroutineIndex", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetSubroutineIndex },
-    { "glGetSubroutineUniformLocation", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetSubroutineUniformLocation },
-    { "glGetSynciv", "GL_ARB_sync GL_VERSION_3_2", glGetSynciv },
-    { "glGetTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap", glGetTexBumpParameterfvATI },
-    { "glGetTexBumpParameterivATI", "GL_ATI_envmap_bumpmap", glGetTexBumpParameterivATI },
-    { "glGetTexEnvxvOES", "GL_OES_fixed_point", glGetTexEnvxvOES },
-    { "glGetTexFilterFuncSGIS", "GL_SGIS_texture_filter4", glGetTexFilterFuncSGIS },
-    { "glGetTexGenxvOES", "GL_OES_fixed_point", glGetTexGenxvOES },
-    { "glGetTexLevelParameterxvOES", "GL_OES_fixed_point", glGetTexLevelParameterxvOES },
-    { "glGetTexParameterIiv", "GL_VERSION_3_0", glGetTexParameterIiv },
-    { "glGetTexParameterIivEXT", "GL_EXT_texture_integer", glGetTexParameterIivEXT },
-    { "glGetTexParameterIuiv", "GL_VERSION_3_0", glGetTexParameterIuiv },
-    { "glGetTexParameterIuivEXT", "GL_EXT_texture_integer", glGetTexParameterIuivEXT },
-    { "glGetTexParameterPointervAPPLE", "GL_APPLE_texture_range", glGetTexParameterPointervAPPLE },
-    { "glGetTexParameterxvOES", "GL_OES_fixed_point", glGetTexParameterxvOES },
-    { "glGetTextureHandleARB", "GL_ARB_bindless_texture", glGetTextureHandleARB },
-    { "glGetTextureHandleNV", "GL_NV_bindless_texture", glGetTextureHandleNV },
-    { "glGetTextureImage", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureImage },
-    { "glGetTextureImageEXT", "GL_EXT_direct_state_access", glGetTextureImageEXT },
-    { "glGetTextureLevelParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureLevelParameterfv },
-    { "glGetTextureLevelParameterfvEXT", "GL_EXT_direct_state_access", glGetTextureLevelParameterfvEXT },
-    { "glGetTextureLevelParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureLevelParameteriv },
-    { "glGetTextureLevelParameterivEXT", "GL_EXT_direct_state_access", glGetTextureLevelParameterivEXT },
-    { "glGetTextureParameterIiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureParameterIiv },
-    { "glGetTextureParameterIivEXT", "GL_EXT_direct_state_access", glGetTextureParameterIivEXT },
-    { "glGetTextureParameterIuiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureParameterIuiv },
-    { "glGetTextureParameterIuivEXT", "GL_EXT_direct_state_access", glGetTextureParameterIuivEXT },
-    { "glGetTextureParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureParameterfv },
-    { "glGetTextureParameterfvEXT", "GL_EXT_direct_state_access", glGetTextureParameterfvEXT },
-    { "glGetTextureParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTextureParameteriv },
-    { "glGetTextureParameterivEXT", "GL_EXT_direct_state_access", glGetTextureParameterivEXT },
-    { "glGetTextureSamplerHandleARB", "GL_ARB_bindless_texture", glGetTextureSamplerHandleARB },
-    { "glGetTextureSamplerHandleNV", "GL_NV_bindless_texture", glGetTextureSamplerHandleNV },
-    { "glGetTextureSubImage", "GL_ARB_get_texture_sub_image GL_VERSION_4_5", glGetTextureSubImage },
-    { "glGetTrackMatrixivNV", "GL_NV_vertex_program", glGetTrackMatrixivNV },
-    { "glGetTransformFeedbackVarying", "GL_VERSION_3_0", glGetTransformFeedbackVarying },
-    { "glGetTransformFeedbackVaryingEXT", "GL_EXT_transform_feedback", glGetTransformFeedbackVaryingEXT },
-    { "glGetTransformFeedbackVaryingNV", "GL_NV_transform_feedback", glGetTransformFeedbackVaryingNV },
-    { "glGetTransformFeedbacki64_v", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTransformFeedbacki64_v },
-    { "glGetTransformFeedbacki_v", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTransformFeedbacki_v },
-    { "glGetTransformFeedbackiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetTransformFeedbackiv },
-    { "glGetUniformBlockIndex", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetUniformBlockIndex },
-    { "glGetUniformBufferSizeEXT", "GL_EXT_bindable_uniform", glGetUniformBufferSizeEXT },
-    { "glGetUniformIndices", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glGetUniformIndices },
-    { "glGetUniformLocation", "GL_VERSION_2_0", glGetUniformLocation },
-    { "glGetUniformLocationARB", "GL_ARB_shader_objects", glGetUniformLocationARB },
-    { "glGetUniformOffsetEXT", "GL_EXT_bindable_uniform", glGetUniformOffsetEXT },
-    { "glGetUniformSubroutineuiv", "GL_ARB_shader_subroutine GL_VERSION_4_0", glGetUniformSubroutineuiv },
-    { "glGetUniformdv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glGetUniformdv },
-    { "glGetUniformfv", "GL_VERSION_2_0", glGetUniformfv },
-    { "glGetUniformfvARB", "GL_ARB_shader_objects", glGetUniformfvARB },
-    { "glGetUniformi64vARB", "GL_ARB_gpu_shader_int64", glGetUniformi64vARB },
-    { "glGetUniformi64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glGetUniformi64vNV },
-    { "glGetUniformiv", "GL_VERSION_2_0", glGetUniformiv },
-    { "glGetUniformivARB", "GL_ARB_shader_objects", glGetUniformivARB },
-    { "glGetUniformui64vARB", "GL_ARB_gpu_shader_int64", glGetUniformui64vARB },
-    { "glGetUniformui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_shader_buffer_load", glGetUniformui64vNV },
-    { "glGetUniformuiv", "GL_VERSION_3_0", glGetUniformuiv },
-    { "glGetUniformuivEXT", "GL_EXT_gpu_shader4", glGetUniformuivEXT },
-    { "glGetUnsignedBytei_vEXT", "GL_EXT_memory_object GL_EXT_semaphore", glGetUnsignedBytei_vEXT },
-    { "glGetUnsignedBytevEXT", "GL_EXT_memory_object GL_EXT_semaphore", glGetUnsignedBytevEXT },
-    { "glGetVariantArrayObjectfvATI", "GL_ATI_vertex_array_object", glGetVariantArrayObjectfvATI },
-    { "glGetVariantArrayObjectivATI", "GL_ATI_vertex_array_object", glGetVariantArrayObjectivATI },
-    { "glGetVariantBooleanvEXT", "GL_EXT_vertex_shader", glGetVariantBooleanvEXT },
-    { "glGetVariantFloatvEXT", "GL_EXT_vertex_shader", glGetVariantFloatvEXT },
-    { "glGetVariantIntegervEXT", "GL_EXT_vertex_shader", glGetVariantIntegervEXT },
-    { "glGetVariantPointervEXT", "GL_EXT_vertex_shader", glGetVariantPointervEXT },
-    { "glGetVaryingLocationNV", "GL_NV_transform_feedback", glGetVaryingLocationNV },
-    { "glGetVertexArrayIndexed64iv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetVertexArrayIndexed64iv },
-    { "glGetVertexArrayIndexediv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetVertexArrayIndexediv },
-    { "glGetVertexArrayIntegeri_vEXT", "GL_EXT_direct_state_access", glGetVertexArrayIntegeri_vEXT },
-    { "glGetVertexArrayIntegervEXT", "GL_EXT_direct_state_access", glGetVertexArrayIntegervEXT },
-    { "glGetVertexArrayPointeri_vEXT", "GL_EXT_direct_state_access", glGetVertexArrayPointeri_vEXT },
-    { "glGetVertexArrayPointervEXT", "GL_EXT_direct_state_access", glGetVertexArrayPointervEXT },
-    { "glGetVertexArrayiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glGetVertexArrayiv },
-    { "glGetVertexAttribArrayObjectfvATI", "GL_ATI_vertex_attrib_array_object", glGetVertexAttribArrayObjectfvATI },
-    { "glGetVertexAttribArrayObjectivATI", "GL_ATI_vertex_attrib_array_object", glGetVertexAttribArrayObjectivATI },
-    { "glGetVertexAttribIiv", "GL_VERSION_3_0", glGetVertexAttribIiv },
-    { "glGetVertexAttribIivEXT", "GL_NV_vertex_program4", glGetVertexAttribIivEXT },
-    { "glGetVertexAttribIuiv", "GL_VERSION_3_0", glGetVertexAttribIuiv },
-    { "glGetVertexAttribIuivEXT", "GL_NV_vertex_program4", glGetVertexAttribIuivEXT },
-    { "glGetVertexAttribLdv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glGetVertexAttribLdv },
-    { "glGetVertexAttribLdvEXT", "GL_EXT_vertex_attrib_64bit", glGetVertexAttribLdvEXT },
-    { "glGetVertexAttribLi64vNV", "GL_NV_vertex_attrib_integer_64bit", glGetVertexAttribLi64vNV },
-    { "glGetVertexAttribLui64vARB", "GL_ARB_bindless_texture", glGetVertexAttribLui64vARB },
-    { "glGetVertexAttribLui64vNV", "GL_NV_vertex_attrib_integer_64bit", glGetVertexAttribLui64vNV },
-    { "glGetVertexAttribPointerv", "GL_VERSION_2_0", glGetVertexAttribPointerv },
-    { "glGetVertexAttribPointervARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glGetVertexAttribPointervARB },
-    { "glGetVertexAttribPointervNV", "GL_NV_vertex_program", glGetVertexAttribPointervNV },
-    { "glGetVertexAttribdv", "GL_VERSION_2_0", glGetVertexAttribdv },
-    { "glGetVertexAttribdvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glGetVertexAttribdvARB },
-    { "glGetVertexAttribdvNV", "GL_NV_vertex_program", glGetVertexAttribdvNV },
-    { "glGetVertexAttribfv", "GL_VERSION_2_0", glGetVertexAttribfv },
-    { "glGetVertexAttribfvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glGetVertexAttribfvARB },
-    { "glGetVertexAttribfvNV", "GL_NV_vertex_program", glGetVertexAttribfvNV },
-    { "glGetVertexAttribiv", "GL_VERSION_2_0", glGetVertexAttribiv },
-    { "glGetVertexAttribivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glGetVertexAttribivARB },
-    { "glGetVertexAttribivNV", "GL_NV_vertex_program", glGetVertexAttribivNV },
-    { "glGetVideoCaptureStreamdvNV", "GL_NV_video_capture", glGetVideoCaptureStreamdvNV },
-    { "glGetVideoCaptureStreamfvNV", "GL_NV_video_capture", glGetVideoCaptureStreamfvNV },
-    { "glGetVideoCaptureStreamivNV", "GL_NV_video_capture", glGetVideoCaptureStreamivNV },
-    { "glGetVideoCaptureivNV", "GL_NV_video_capture", glGetVideoCaptureivNV },
-    { "glGetVideoi64vNV", "GL_NV_present_video", glGetVideoi64vNV },
-    { "glGetVideoivNV", "GL_NV_present_video", glGetVideoivNV },
-    { "glGetVideoui64vNV", "GL_NV_present_video", glGetVideoui64vNV },
-    { "glGetVideouivNV", "GL_NV_present_video", glGetVideouivNV },
-    { "glGetVkProcAddrNV", "GL_NV_draw_vulkan_image", glGetVkProcAddrNV },
-    { "glGetnColorTable", "GL_VERSION_4_5", glGetnColorTable },
-    { "glGetnColorTableARB", "GL_ARB_robustness", glGetnColorTableARB },
-    { "glGetnCompressedTexImage", "GL_VERSION_4_5", glGetnCompressedTexImage },
-    { "glGetnCompressedTexImageARB", "GL_ARB_robustness", glGetnCompressedTexImageARB },
-    { "glGetnConvolutionFilter", "GL_VERSION_4_5", glGetnConvolutionFilter },
-    { "glGetnConvolutionFilterARB", "GL_ARB_robustness", glGetnConvolutionFilterARB },
-    { "glGetnHistogram", "GL_VERSION_4_5", glGetnHistogram },
-    { "glGetnHistogramARB", "GL_ARB_robustness", glGetnHistogramARB },
-    { "glGetnMapdv", "GL_VERSION_4_5", glGetnMapdv },
-    { "glGetnMapdvARB", "GL_ARB_robustness", glGetnMapdvARB },
-    { "glGetnMapfv", "GL_VERSION_4_5", glGetnMapfv },
-    { "glGetnMapfvARB", "GL_ARB_robustness", glGetnMapfvARB },
-    { "glGetnMapiv", "GL_VERSION_4_5", glGetnMapiv },
-    { "glGetnMapivARB", "GL_ARB_robustness", glGetnMapivARB },
-    { "glGetnMinmax", "GL_VERSION_4_5", glGetnMinmax },
-    { "glGetnMinmaxARB", "GL_ARB_robustness", glGetnMinmaxARB },
-    { "glGetnPixelMapfv", "GL_VERSION_4_5", glGetnPixelMapfv },
-    { "glGetnPixelMapfvARB", "GL_ARB_robustness", glGetnPixelMapfvARB },
-    { "glGetnPixelMapuiv", "GL_VERSION_4_5", glGetnPixelMapuiv },
-    { "glGetnPixelMapuivARB", "GL_ARB_robustness", glGetnPixelMapuivARB },
-    { "glGetnPixelMapusv", "GL_VERSION_4_5", glGetnPixelMapusv },
-    { "glGetnPixelMapusvARB", "GL_ARB_robustness", glGetnPixelMapusvARB },
-    { "glGetnPolygonStipple", "GL_VERSION_4_5", glGetnPolygonStipple },
-    { "glGetnPolygonStippleARB", "GL_ARB_robustness", glGetnPolygonStippleARB },
-    { "glGetnSeparableFilter", "GL_VERSION_4_5", glGetnSeparableFilter },
-    { "glGetnSeparableFilterARB", "GL_ARB_robustness", glGetnSeparableFilterARB },
-    { "glGetnTexImage", "GL_VERSION_4_5", glGetnTexImage },
-    { "glGetnTexImageARB", "GL_ARB_robustness", glGetnTexImageARB },
-    { "glGetnUniformdv", "GL_VERSION_4_5", glGetnUniformdv },
-    { "glGetnUniformdvARB", "GL_ARB_robustness", glGetnUniformdvARB },
-    { "glGetnUniformfv", "GL_KHR_robustness GL_VERSION_4_5", glGetnUniformfv },
-    { "glGetnUniformfvARB", "GL_ARB_robustness", glGetnUniformfvARB },
-    { "glGetnUniformi64vARB", "GL_ARB_gpu_shader_int64", glGetnUniformi64vARB },
-    { "glGetnUniformiv", "GL_KHR_robustness GL_VERSION_4_5", glGetnUniformiv },
-    { "glGetnUniformivARB", "GL_ARB_robustness", glGetnUniformivARB },
-    { "glGetnUniformui64vARB", "GL_ARB_gpu_shader_int64", glGetnUniformui64vARB },
-    { "glGetnUniformuiv", "GL_KHR_robustness GL_VERSION_4_5", glGetnUniformuiv },
-    { "glGetnUniformuivARB", "GL_ARB_robustness", glGetnUniformuivARB },
-    { "glGlobalAlphaFactorbSUN", "GL_SUN_global_alpha", glGlobalAlphaFactorbSUN },
-    { "glGlobalAlphaFactordSUN", "GL_SUN_global_alpha", glGlobalAlphaFactordSUN },
-    { "glGlobalAlphaFactorfSUN", "GL_SUN_global_alpha", glGlobalAlphaFactorfSUN },
-    { "glGlobalAlphaFactoriSUN", "GL_SUN_global_alpha", glGlobalAlphaFactoriSUN },
-    { "glGlobalAlphaFactorsSUN", "GL_SUN_global_alpha", glGlobalAlphaFactorsSUN },
-    { "glGlobalAlphaFactorubSUN", "GL_SUN_global_alpha", glGlobalAlphaFactorubSUN },
-    { "glGlobalAlphaFactoruiSUN", "GL_SUN_global_alpha", glGlobalAlphaFactoruiSUN },
-    { "glGlobalAlphaFactorusSUN", "GL_SUN_global_alpha", glGlobalAlphaFactorusSUN },
-    { "glHintPGI", "GL_PGI_misc_hints", glHintPGI },
-    { "glHistogram", "GL_ARB_imaging", glHistogram },
-    { "glHistogramEXT", "GL_EXT_histogram", glHistogramEXT },
-    { "glIglooInterfaceSGIX", "GL_SGIX_igloo_interface", glIglooInterfaceSGIX },
-    { "glImageTransformParameterfHP", "GL_HP_image_transform", glImageTransformParameterfHP },
-    { "glImageTransformParameterfvHP", "GL_HP_image_transform", glImageTransformParameterfvHP },
-    { "glImageTransformParameteriHP", "GL_HP_image_transform", glImageTransformParameteriHP },
-    { "glImageTransformParameterivHP", "GL_HP_image_transform", glImageTransformParameterivHP },
-    { "glImportMemoryFdEXT", "GL_EXT_memory_object_fd", glImportMemoryFdEXT },
-    { "glImportMemoryWin32HandleEXT", "GL_EXT_memory_object_win32", glImportMemoryWin32HandleEXT },
-    { "glImportMemoryWin32NameEXT", "GL_EXT_memory_object_win32", glImportMemoryWin32NameEXT },
-    { "glImportSemaphoreFdEXT", "GL_EXT_semaphore_fd", glImportSemaphoreFdEXT },
-    { "glImportSemaphoreWin32HandleEXT", "GL_EXT_semaphore_win32", glImportSemaphoreWin32HandleEXT },
-    { "glImportSemaphoreWin32NameEXT", "GL_EXT_semaphore_win32", glImportSemaphoreWin32NameEXT },
-    { "glImportSyncEXT", "GL_EXT_x11_sync_object", glImportSyncEXT },
-    { "glIndexFormatNV", "GL_NV_vertex_buffer_unified_memory", glIndexFormatNV },
-    { "glIndexFuncEXT", "GL_EXT_index_func", glIndexFuncEXT },
-    { "glIndexMaterialEXT", "GL_EXT_index_material", glIndexMaterialEXT },
-    { "glIndexPointerEXT", "GL_EXT_vertex_array", glIndexPointerEXT },
-    { "glIndexPointerListIBM", "GL_IBM_vertex_array_lists", glIndexPointerListIBM },
-    { "glIndexxOES", "GL_OES_fixed_point", glIndexxOES },
-    { "glIndexxvOES", "GL_OES_fixed_point", glIndexxvOES },
-    { "glInsertComponentEXT", "GL_EXT_vertex_shader", glInsertComponentEXT },
-    { "glInsertEventMarkerEXT", "GL_EXT_debug_marker", glInsertEventMarkerEXT },
-    { "glInstrumentsBufferSGIX", "GL_SGIX_instruments", glInstrumentsBufferSGIX },
-    { "glInterpolatePathsNV", "GL_NV_path_rendering", glInterpolatePathsNV },
-    { "glInvalidateBufferData", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateBufferData },
-    { "glInvalidateBufferSubData", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateBufferSubData },
-    { "glInvalidateFramebuffer", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateFramebuffer },
-    { "glInvalidateNamedFramebufferData", "GL_ARB_direct_state_access GL_VERSION_4_5", glInvalidateNamedFramebufferData },
-    { "glInvalidateNamedFramebufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5", glInvalidateNamedFramebufferSubData },
-    { "glInvalidateSubFramebuffer", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateSubFramebuffer },
-    { "glInvalidateTexImage", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateTexImage },
-    { "glInvalidateTexSubImage", "GL_ARB_invalidate_subdata GL_VERSION_4_3", glInvalidateTexSubImage },
-    { "glIsAsyncMarkerSGIX", "GL_SGIX_async", glIsAsyncMarkerSGIX },
-    { "glIsBuffer", "GL_VERSION_1_5", glIsBuffer },
-    { "glIsBufferARB", "GL_ARB_vertex_buffer_object", glIsBufferARB },
-    { "glIsBufferResidentNV", "GL_NV_shader_buffer_load", glIsBufferResidentNV },
-    { "glIsCommandListNV", "GL_NV_command_list", glIsCommandListNV },
-    { "glIsEnabledIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2", glIsEnabledIndexedEXT },
-    { "glIsEnabledi", "GL_VERSION_3_0", glIsEnabledi },
-    { "glIsFenceAPPLE", "GL_APPLE_fence", glIsFenceAPPLE },
-    { "glIsFenceNV", "GL_NV_fence", glIsFenceNV },
-    { "glIsFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glIsFramebuffer },
-    { "glIsFramebufferEXT", "GL_EXT_framebuffer_object", glIsFramebufferEXT },
-    { "glIsImageHandleResidentARB", "GL_ARB_bindless_texture", glIsImageHandleResidentARB },
-    { "glIsImageHandleResidentNV", "GL_NV_bindless_texture", glIsImageHandleResidentNV },
-    { "glIsMemoryObjectEXT", "GL_EXT_memory_object", glIsMemoryObjectEXT },
-    { "glIsNameAMD", "GL_AMD_name_gen_delete", glIsNameAMD },
-    { "glIsNamedBufferResidentNV", "GL_NV_shader_buffer_load", glIsNamedBufferResidentNV },
-    { "glIsNamedStringARB", "GL_ARB_shading_language_include", glIsNamedStringARB },
-    { "glIsObjectBufferATI", "GL_ATI_vertex_array_object", glIsObjectBufferATI },
-    { "glIsOcclusionQueryNV", "GL_NV_occlusion_query", glIsOcclusionQueryNV },
-    { "glIsPathNV", "GL_NV_path_rendering", glIsPathNV },
-    { "glIsPointInFillPathNV", "GL_NV_path_rendering", glIsPointInFillPathNV },
-    { "glIsPointInStrokePathNV", "GL_NV_path_rendering", glIsPointInStrokePathNV },
-    { "glIsProgram", "GL_VERSION_2_0", glIsProgram },
-    { "glIsProgramARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glIsProgramARB },
-    { "glIsProgramNV", "GL_NV_vertex_program", glIsProgramNV },
-    { "glIsProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glIsProgramPipeline },
-    { "glIsQuery", "GL_VERSION_1_5", glIsQuery },
-    { "glIsQueryARB", "GL_ARB_occlusion_query", glIsQueryARB },
-    { "glIsRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0", glIsRenderbuffer },
-    { "glIsRenderbufferEXT", "GL_EXT_framebuffer_object", glIsRenderbufferEXT },
-    { "glIsSampler", "GL_ARB_sampler_objects GL_VERSION_3_3", glIsSampler },
-    { "glIsSemaphoreEXT", "GL_EXT_semaphore", glIsSemaphoreEXT },
-    { "glIsShader", "GL_VERSION_2_0", glIsShader },
-    { "glIsStateNV", "GL_NV_command_list", glIsStateNV },
-    { "glIsSync", "GL_ARB_sync GL_VERSION_3_2", glIsSync },
-    { "glIsTextureEXT", "GL_EXT_texture_object", glIsTextureEXT },
-    { "glIsTextureHandleResidentARB", "GL_ARB_bindless_texture", glIsTextureHandleResidentARB },
-    { "glIsTextureHandleResidentNV", "GL_NV_bindless_texture", glIsTextureHandleResidentNV },
-    { "glIsTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glIsTransformFeedback },
-    { "glIsTransformFeedbackNV", "GL_NV_transform_feedback2", glIsTransformFeedbackNV },
-    { "glIsVariantEnabledEXT", "GL_EXT_vertex_shader", glIsVariantEnabledEXT },
-    { "glIsVertexArray", "GL_ARB_vertex_array_object GL_VERSION_3_0", glIsVertexArray },
-    { "glIsVertexArrayAPPLE", "GL_APPLE_vertex_array_object", glIsVertexArrayAPPLE },
-    { "glIsVertexAttribEnabledAPPLE", "GL_APPLE_vertex_program_evaluators", glIsVertexAttribEnabledAPPLE },
-    { "glLGPUCopyImageSubDataNVX", "GL_NVX_linked_gpu_multicast", glLGPUCopyImageSubDataNVX },
-    { "glLGPUInterlockNVX", "GL_NVX_linked_gpu_multicast", glLGPUInterlockNVX },
-    { "glLGPUNamedBufferSubDataNVX", "GL_NVX_linked_gpu_multicast", glLGPUNamedBufferSubDataNVX },
-    { "glLabelObjectEXT", "GL_EXT_debug_label", glLabelObjectEXT },
-    { "glLightEnviSGIX", "GL_SGIX_fragment_lighting", glLightEnviSGIX },
-    { "glLightModelxOES", "GL_OES_fixed_point", glLightModelxOES },
-    { "glLightModelxvOES", "GL_OES_fixed_point", glLightModelxvOES },
-    { "glLightxOES", "GL_OES_fixed_point", glLightxOES },
-    { "glLightxvOES", "GL_OES_fixed_point", glLightxvOES },
-    { "glLineWidthxOES", "GL_OES_fixed_point", glLineWidthxOES },
-    { "glLinkProgram", "GL_VERSION_2_0", glLinkProgram },
-    { "glLinkProgramARB", "GL_ARB_shader_objects", glLinkProgramARB },
-    { "glListDrawCommandsStatesClientNV", "GL_NV_command_list", glListDrawCommandsStatesClientNV },
-    { "glListParameterfSGIX", "GL_SGIX_list_priority", glListParameterfSGIX },
-    { "glListParameterfvSGIX", "GL_SGIX_list_priority", glListParameterfvSGIX },
-    { "glListParameteriSGIX", "GL_SGIX_list_priority", glListParameteriSGIX },
-    { "glListParameterivSGIX", "GL_SGIX_list_priority", glListParameterivSGIX },
-    { "glLoadIdentityDeformationMapSGIX", "GL_SGIX_polynomial_ffd", glLoadIdentityDeformationMapSGIX },
-    { "glLoadMatrixxOES", "GL_OES_fixed_point", glLoadMatrixxOES },
-    { "glLoadProgramNV", "GL_NV_vertex_program", glLoadProgramNV },
-    { "glLoadTransposeMatrixd", "GL_VERSION_1_3", glLoadTransposeMatrixd },
-    { "glLoadTransposeMatrixdARB", "GL_ARB_transpose_matrix", glLoadTransposeMatrixdARB },
-    { "glLoadTransposeMatrixf", "GL_VERSION_1_3", glLoadTransposeMatrixf },
-    { "glLoadTransposeMatrixfARB", "GL_ARB_transpose_matrix", glLoadTransposeMatrixfARB },
-    { "glLoadTransposeMatrixxOES", "GL_OES_fixed_point", glLoadTransposeMatrixxOES },
-    { "glLockArraysEXT", "GL_EXT_compiled_vertex_array", glLockArraysEXT },
-    { "glMTexCoord2fSGIS", "GL_SGIS_multitexture", glMTexCoord2fSGIS },
-    { "glMTexCoord2fvSGIS", "GL_SGIS_multitexture", glMTexCoord2fvSGIS },
-    { "glMakeBufferNonResidentNV", "GL_NV_shader_buffer_load", glMakeBufferNonResidentNV },
-    { "glMakeBufferResidentNV", "GL_NV_shader_buffer_load", glMakeBufferResidentNV },
-    { "glMakeImageHandleNonResidentARB", "GL_ARB_bindless_texture", glMakeImageHandleNonResidentARB },
-    { "glMakeImageHandleNonResidentNV", "GL_NV_bindless_texture", glMakeImageHandleNonResidentNV },
-    { "glMakeImageHandleResidentARB", "GL_ARB_bindless_texture", glMakeImageHandleResidentARB },
-    { "glMakeImageHandleResidentNV", "GL_NV_bindless_texture", glMakeImageHandleResidentNV },
-    { "glMakeNamedBufferNonResidentNV", "GL_NV_shader_buffer_load", glMakeNamedBufferNonResidentNV },
-    { "glMakeNamedBufferResidentNV", "GL_NV_shader_buffer_load", glMakeNamedBufferResidentNV },
-    { "glMakeTextureHandleNonResidentARB", "GL_ARB_bindless_texture", glMakeTextureHandleNonResidentARB },
-    { "glMakeTextureHandleNonResidentNV", "GL_NV_bindless_texture", glMakeTextureHandleNonResidentNV },
-    { "glMakeTextureHandleResidentARB", "GL_ARB_bindless_texture", glMakeTextureHandleResidentARB },
-    { "glMakeTextureHandleResidentNV", "GL_NV_bindless_texture", glMakeTextureHandleResidentNV },
-    { "glMap1xOES", "GL_OES_fixed_point", glMap1xOES },
-    { "glMap2xOES", "GL_OES_fixed_point", glMap2xOES },
-    { "glMapBuffer", "GL_VERSION_1_5", glMapBuffer },
-    { "glMapBufferARB", "GL_ARB_vertex_buffer_object", glMapBufferARB },
-    { "glMapBufferRange", "GL_ARB_map_buffer_range GL_VERSION_3_0", glMapBufferRange },
-    { "glMapControlPointsNV", "GL_NV_evaluators", glMapControlPointsNV },
-    { "glMapGrid1xOES", "GL_OES_fixed_point", glMapGrid1xOES },
-    { "glMapGrid2xOES", "GL_OES_fixed_point", glMapGrid2xOES },
-    { "glMapNamedBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glMapNamedBuffer },
-    { "glMapNamedBufferEXT", "GL_EXT_direct_state_access", glMapNamedBufferEXT },
-    { "glMapNamedBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5", glMapNamedBufferRange },
-    { "glMapNamedBufferRangeEXT", "GL_EXT_direct_state_access", glMapNamedBufferRangeEXT },
-    { "glMapObjectBufferATI", "GL_ATI_map_object_buffer", glMapObjectBufferATI },
-    { "glMapParameterfvNV", "GL_NV_evaluators", glMapParameterfvNV },
-    { "glMapParameterivNV", "GL_NV_evaluators", glMapParameterivNV },
-    { "glMapTexture2DINTEL", "GL_INTEL_map_texture", glMapTexture2DINTEL },
-    { "glMapVertexAttrib1dAPPLE", "GL_APPLE_vertex_program_evaluators", glMapVertexAttrib1dAPPLE },
-    { "glMapVertexAttrib1fAPPLE", "GL_APPLE_vertex_program_evaluators", glMapVertexAttrib1fAPPLE },
-    { "glMapVertexAttrib2dAPPLE", "GL_APPLE_vertex_program_evaluators", glMapVertexAttrib2dAPPLE },
-    { "glMapVertexAttrib2fAPPLE", "GL_APPLE_vertex_program_evaluators", glMapVertexAttrib2fAPPLE },
-    { "glMaterialxOES", "GL_OES_fixed_point", glMaterialxOES },
-    { "glMaterialxvOES", "GL_OES_fixed_point", glMaterialxvOES },
-    { "glMatrixFrustumEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixFrustumEXT },
-    { "glMatrixIndexPointerARB", "GL_ARB_matrix_palette", glMatrixIndexPointerARB },
-    { "glMatrixIndexubvARB", "GL_ARB_matrix_palette", glMatrixIndexubvARB },
-    { "glMatrixIndexuivARB", "GL_ARB_matrix_palette", glMatrixIndexuivARB },
-    { "glMatrixIndexusvARB", "GL_ARB_matrix_palette", glMatrixIndexusvARB },
-    { "glMatrixLoad3x2fNV", "GL_NV_path_rendering", glMatrixLoad3x2fNV },
-    { "glMatrixLoad3x3fNV", "GL_NV_path_rendering", glMatrixLoad3x3fNV },
-    { "glMatrixLoadIdentityEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixLoadIdentityEXT },
-    { "glMatrixLoadTranspose3x3fNV", "GL_NV_path_rendering", glMatrixLoadTranspose3x3fNV },
-    { "glMatrixLoadTransposedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixLoadTransposedEXT },
-    { "glMatrixLoadTransposefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixLoadTransposefEXT },
-    { "glMatrixLoaddEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixLoaddEXT },
-    { "glMatrixLoadfEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixLoadfEXT },
-    { "glMatrixMult3x2fNV", "GL_NV_path_rendering", glMatrixMult3x2fNV },
-    { "glMatrixMult3x3fNV", "GL_NV_path_rendering", glMatrixMult3x3fNV },
-    { "glMatrixMultTranspose3x3fNV", "GL_NV_path_rendering", glMatrixMultTranspose3x3fNV },
-    { "glMatrixMultTransposedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixMultTransposedEXT },
-    { "glMatrixMultTransposefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixMultTransposefEXT },
-    { "glMatrixMultdEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixMultdEXT },
-    { "glMatrixMultfEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixMultfEXT },
-    { "glMatrixOrthoEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixOrthoEXT },
-    { "glMatrixPopEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixPopEXT },
-    { "glMatrixPushEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixPushEXT },
-    { "glMatrixRotatedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixRotatedEXT },
-    { "glMatrixRotatefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixRotatefEXT },
-    { "glMatrixScaledEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixScaledEXT },
-    { "glMatrixScalefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixScalefEXT },
-    { "glMatrixTranslatedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixTranslatedEXT },
-    { "glMatrixTranslatefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering", glMatrixTranslatefEXT },
-    { "glMaxShaderCompilerThreadsARB", "GL_ARB_parallel_shader_compile", glMaxShaderCompilerThreadsARB },
-    { "glMaxShaderCompilerThreadsKHR", "GL_KHR_parallel_shader_compile", glMaxShaderCompilerThreadsKHR },
-    { "glMemoryBarrier", "GL_ARB_shader_image_load_store GL_VERSION_4_2", glMemoryBarrier },
-    { "glMemoryBarrierByRegion", "GL_ARB_ES3_1_compatibility GL_VERSION_4_5", glMemoryBarrierByRegion },
-    { "glMemoryBarrierEXT", "GL_EXT_shader_image_load_store", glMemoryBarrierEXT },
-    { "glMemoryObjectParameterivEXT", "GL_EXT_memory_object", glMemoryObjectParameterivEXT },
-    { "glMinSampleShading", "GL_VERSION_4_0", glMinSampleShading },
-    { "glMinSampleShadingARB", "GL_ARB_sample_shading", glMinSampleShadingARB },
-    { "glMinmax", "GL_ARB_imaging", glMinmax },
-    { "glMinmaxEXT", "GL_EXT_histogram", glMinmaxEXT },
-    { "glMultMatrixxOES", "GL_OES_fixed_point", glMultMatrixxOES },
-    { "glMultTransposeMatrixd", "GL_VERSION_1_3", glMultTransposeMatrixd },
-    { "glMultTransposeMatrixdARB", "GL_ARB_transpose_matrix", glMultTransposeMatrixdARB },
-    { "glMultTransposeMatrixf", "GL_VERSION_1_3", glMultTransposeMatrixf },
-    { "glMultTransposeMatrixfARB", "GL_ARB_transpose_matrix", glMultTransposeMatrixfARB },
-    { "glMultTransposeMatrixxOES", "GL_OES_fixed_point", glMultTransposeMatrixxOES },
-    { "glMultiDrawArrays", "GL_VERSION_1_4", glMultiDrawArrays },
-    { "glMultiDrawArraysEXT", "GL_EXT_multi_draw_arrays", glMultiDrawArraysEXT },
-    { "glMultiDrawArraysIndirect", "GL_ARB_multi_draw_indirect GL_VERSION_4_3", glMultiDrawArraysIndirect },
-    { "glMultiDrawArraysIndirectAMD", "GL_AMD_multi_draw_indirect", glMultiDrawArraysIndirectAMD },
-    { "glMultiDrawArraysIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count", glMultiDrawArraysIndirectBindlessCountNV },
-    { "glMultiDrawArraysIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect", glMultiDrawArraysIndirectBindlessNV },
-    { "glMultiDrawArraysIndirectCount", "GL_VERSION_4_6", glMultiDrawArraysIndirectCount },
-    { "glMultiDrawArraysIndirectCountARB", "GL_ARB_indirect_parameters", glMultiDrawArraysIndirectCountARB },
-    { "glMultiDrawElementArrayAPPLE", "GL_APPLE_element_array", glMultiDrawElementArrayAPPLE },
-    { "glMultiDrawElements", "GL_VERSION_1_4", glMultiDrawElements },
-    { "glMultiDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2", glMultiDrawElementsBaseVertex },
-    { "glMultiDrawElementsEXT", "GL_EXT_multi_draw_arrays", glMultiDrawElementsEXT },
-    { "glMultiDrawElementsIndirect", "GL_ARB_multi_draw_indirect GL_VERSION_4_3", glMultiDrawElementsIndirect },
-    { "glMultiDrawElementsIndirectAMD", "GL_AMD_multi_draw_indirect", glMultiDrawElementsIndirectAMD },
-    { "glMultiDrawElementsIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count", glMultiDrawElementsIndirectBindlessCountNV },
-    { "glMultiDrawElementsIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect", glMultiDrawElementsIndirectBindlessNV },
-    { "glMultiDrawElementsIndirectCount", "GL_VERSION_4_6", glMultiDrawElementsIndirectCount },
-    { "glMultiDrawElementsIndirectCountARB", "GL_ARB_indirect_parameters", glMultiDrawElementsIndirectCountARB },
-    { "glMultiDrawMeshTasksIndirectCountNV", "GL_NV_mesh_shader", glMultiDrawMeshTasksIndirectCountNV },
-    { "glMultiDrawMeshTasksIndirectNV", "GL_NV_mesh_shader", glMultiDrawMeshTasksIndirectNV },
-    { "glMultiDrawRangeElementArrayAPPLE", "GL_APPLE_element_array", glMultiDrawRangeElementArrayAPPLE },
-    { "glMultiModeDrawArraysIBM", "GL_IBM_multimode_draw_arrays", glMultiModeDrawArraysIBM },
-    { "glMultiModeDrawElementsIBM", "GL_IBM_multimode_draw_arrays", glMultiModeDrawElementsIBM },
-    { "glMultiTexBufferEXT", "GL_EXT_direct_state_access", glMultiTexBufferEXT },
-    { "glMultiTexCoord1bOES", "GL_OES_byte_coordinates", glMultiTexCoord1bOES },
-    { "glMultiTexCoord1bvOES", "GL_OES_byte_coordinates", glMultiTexCoord1bvOES },
-    { "glMultiTexCoord1d", "GL_VERSION_1_3", glMultiTexCoord1d },
-    { "glMultiTexCoord1dARB", "GL_ARB_multitexture", glMultiTexCoord1dARB },
-    { "glMultiTexCoord1dSGIS", "GL_SGIS_multitexture", glMultiTexCoord1dSGIS },
-    { "glMultiTexCoord1dv", "GL_VERSION_1_3", glMultiTexCoord1dv },
-    { "glMultiTexCoord1dvARB", "GL_ARB_multitexture", glMultiTexCoord1dvARB },
-    { "glMultiTexCoord1dvSGIS", "GL_SGIS_multitexture", glMultiTexCoord1dvSGIS },
-    { "glMultiTexCoord1f", "GL_VERSION_1_3", glMultiTexCoord1f },
-    { "glMultiTexCoord1fARB", "GL_ARB_multitexture", glMultiTexCoord1fARB },
-    { "glMultiTexCoord1fSGIS", "GL_SGIS_multitexture", glMultiTexCoord1fSGIS },
-    { "glMultiTexCoord1fv", "GL_VERSION_1_3", glMultiTexCoord1fv },
-    { "glMultiTexCoord1fvARB", "GL_ARB_multitexture", glMultiTexCoord1fvARB },
-    { "glMultiTexCoord1fvSGIS", "GL_SGIS_multitexture", glMultiTexCoord1fvSGIS },
-    { "glMultiTexCoord1hNV", "GL_NV_half_float", glMultiTexCoord1hNV },
-    { "glMultiTexCoord1hvNV", "GL_NV_half_float", glMultiTexCoord1hvNV },
-    { "glMultiTexCoord1i", "GL_VERSION_1_3", glMultiTexCoord1i },
-    { "glMultiTexCoord1iARB", "GL_ARB_multitexture", glMultiTexCoord1iARB },
-    { "glMultiTexCoord1iSGIS", "GL_SGIS_multitexture", glMultiTexCoord1iSGIS },
-    { "glMultiTexCoord1iv", "GL_VERSION_1_3", glMultiTexCoord1iv },
-    { "glMultiTexCoord1ivARB", "GL_ARB_multitexture", glMultiTexCoord1ivARB },
-    { "glMultiTexCoord1ivSGIS", "GL_SGIS_multitexture", glMultiTexCoord1ivSGIS },
-    { "glMultiTexCoord1s", "GL_VERSION_1_3", glMultiTexCoord1s },
-    { "glMultiTexCoord1sARB", "GL_ARB_multitexture", glMultiTexCoord1sARB },
-    { "glMultiTexCoord1sSGIS", "GL_SGIS_multitexture", glMultiTexCoord1sSGIS },
-    { "glMultiTexCoord1sv", "GL_VERSION_1_3", glMultiTexCoord1sv },
-    { "glMultiTexCoord1svARB", "GL_ARB_multitexture", glMultiTexCoord1svARB },
-    { "glMultiTexCoord1svSGIS", "GL_SGIS_multitexture", glMultiTexCoord1svSGIS },
-    { "glMultiTexCoord1xOES", "GL_OES_fixed_point", glMultiTexCoord1xOES },
-    { "glMultiTexCoord1xvOES", "GL_OES_fixed_point", glMultiTexCoord1xvOES },
-    { "glMultiTexCoord2bOES", "GL_OES_byte_coordinates", glMultiTexCoord2bOES },
-    { "glMultiTexCoord2bvOES", "GL_OES_byte_coordinates", glMultiTexCoord2bvOES },
-    { "glMultiTexCoord2d", "GL_VERSION_1_3", glMultiTexCoord2d },
-    { "glMultiTexCoord2dARB", "GL_ARB_multitexture", glMultiTexCoord2dARB },
-    { "glMultiTexCoord2dSGIS", "GL_SGIS_multitexture", glMultiTexCoord2dSGIS },
-    { "glMultiTexCoord2dv", "GL_VERSION_1_3", glMultiTexCoord2dv },
-    { "glMultiTexCoord2dvARB", "GL_ARB_multitexture", glMultiTexCoord2dvARB },
-    { "glMultiTexCoord2dvSGIS", "GL_SGIS_multitexture", glMultiTexCoord2dvSGIS },
-    { "glMultiTexCoord2f", "GL_VERSION_1_3", glMultiTexCoord2f },
-    { "glMultiTexCoord2fARB", "GL_ARB_multitexture", glMultiTexCoord2fARB },
-    { "glMultiTexCoord2fSGIS", "GL_SGIS_multitexture", glMultiTexCoord2fSGIS },
-    { "glMultiTexCoord2fv", "GL_VERSION_1_3", glMultiTexCoord2fv },
-    { "glMultiTexCoord2fvARB", "GL_ARB_multitexture", glMultiTexCoord2fvARB },
-    { "glMultiTexCoord2fvSGIS", "GL_SGIS_multitexture", glMultiTexCoord2fvSGIS },
-    { "glMultiTexCoord2hNV", "GL_NV_half_float", glMultiTexCoord2hNV },
-    { "glMultiTexCoord2hvNV", "GL_NV_half_float", glMultiTexCoord2hvNV },
-    { "glMultiTexCoord2i", "GL_VERSION_1_3", glMultiTexCoord2i },
-    { "glMultiTexCoord2iARB", "GL_ARB_multitexture", glMultiTexCoord2iARB },
-    { "glMultiTexCoord2iSGIS", "GL_SGIS_multitexture", glMultiTexCoord2iSGIS },
-    { "glMultiTexCoord2iv", "GL_VERSION_1_3", glMultiTexCoord2iv },
-    { "glMultiTexCoord2ivARB", "GL_ARB_multitexture", glMultiTexCoord2ivARB },
-    { "glMultiTexCoord2ivSGIS", "GL_SGIS_multitexture", glMultiTexCoord2ivSGIS },
-    { "glMultiTexCoord2s", "GL_VERSION_1_3", glMultiTexCoord2s },
-    { "glMultiTexCoord2sARB", "GL_ARB_multitexture", glMultiTexCoord2sARB },
-    { "glMultiTexCoord2sSGIS", "GL_SGIS_multitexture", glMultiTexCoord2sSGIS },
-    { "glMultiTexCoord2sv", "GL_VERSION_1_3", glMultiTexCoord2sv },
-    { "glMultiTexCoord2svARB", "GL_ARB_multitexture", glMultiTexCoord2svARB },
-    { "glMultiTexCoord2svSGIS", "GL_SGIS_multitexture", glMultiTexCoord2svSGIS },
-    { "glMultiTexCoord2xOES", "GL_OES_fixed_point", glMultiTexCoord2xOES },
-    { "glMultiTexCoord2xvOES", "GL_OES_fixed_point", glMultiTexCoord2xvOES },
-    { "glMultiTexCoord3bOES", "GL_OES_byte_coordinates", glMultiTexCoord3bOES },
-    { "glMultiTexCoord3bvOES", "GL_OES_byte_coordinates", glMultiTexCoord3bvOES },
-    { "glMultiTexCoord3d", "GL_VERSION_1_3", glMultiTexCoord3d },
-    { "glMultiTexCoord3dARB", "GL_ARB_multitexture", glMultiTexCoord3dARB },
-    { "glMultiTexCoord3dSGIS", "GL_SGIS_multitexture", glMultiTexCoord3dSGIS },
-    { "glMultiTexCoord3dv", "GL_VERSION_1_3", glMultiTexCoord3dv },
-    { "glMultiTexCoord3dvARB", "GL_ARB_multitexture", glMultiTexCoord3dvARB },
-    { "glMultiTexCoord3dvSGIS", "GL_SGIS_multitexture", glMultiTexCoord3dvSGIS },
-    { "glMultiTexCoord3f", "GL_VERSION_1_3", glMultiTexCoord3f },
-    { "glMultiTexCoord3fARB", "GL_ARB_multitexture", glMultiTexCoord3fARB },
-    { "glMultiTexCoord3fSGIS", "GL_SGIS_multitexture", glMultiTexCoord3fSGIS },
-    { "glMultiTexCoord3fv", "GL_VERSION_1_3", glMultiTexCoord3fv },
-    { "glMultiTexCoord3fvARB", "GL_ARB_multitexture", glMultiTexCoord3fvARB },
-    { "glMultiTexCoord3fvSGIS", "GL_SGIS_multitexture", glMultiTexCoord3fvSGIS },
-    { "glMultiTexCoord3hNV", "GL_NV_half_float", glMultiTexCoord3hNV },
-    { "glMultiTexCoord3hvNV", "GL_NV_half_float", glMultiTexCoord3hvNV },
-    { "glMultiTexCoord3i", "GL_VERSION_1_3", glMultiTexCoord3i },
-    { "glMultiTexCoord3iARB", "GL_ARB_multitexture", glMultiTexCoord3iARB },
-    { "glMultiTexCoord3iSGIS", "GL_SGIS_multitexture", glMultiTexCoord3iSGIS },
-    { "glMultiTexCoord3iv", "GL_VERSION_1_3", glMultiTexCoord3iv },
-    { "glMultiTexCoord3ivARB", "GL_ARB_multitexture", glMultiTexCoord3ivARB },
-    { "glMultiTexCoord3ivSGIS", "GL_SGIS_multitexture", glMultiTexCoord3ivSGIS },
-    { "glMultiTexCoord3s", "GL_VERSION_1_3", glMultiTexCoord3s },
-    { "glMultiTexCoord3sARB", "GL_ARB_multitexture", glMultiTexCoord3sARB },
-    { "glMultiTexCoord3sSGIS", "GL_SGIS_multitexture", glMultiTexCoord3sSGIS },
-    { "glMultiTexCoord3sv", "GL_VERSION_1_3", glMultiTexCoord3sv },
-    { "glMultiTexCoord3svARB", "GL_ARB_multitexture", glMultiTexCoord3svARB },
-    { "glMultiTexCoord3svSGIS", "GL_SGIS_multitexture", glMultiTexCoord3svSGIS },
-    { "glMultiTexCoord3xOES", "GL_OES_fixed_point", glMultiTexCoord3xOES },
-    { "glMultiTexCoord3xvOES", "GL_OES_fixed_point", glMultiTexCoord3xvOES },
-    { "glMultiTexCoord4bOES", "GL_OES_byte_coordinates", glMultiTexCoord4bOES },
-    { "glMultiTexCoord4bvOES", "GL_OES_byte_coordinates", glMultiTexCoord4bvOES },
-    { "glMultiTexCoord4d", "GL_VERSION_1_3", glMultiTexCoord4d },
-    { "glMultiTexCoord4dARB", "GL_ARB_multitexture", glMultiTexCoord4dARB },
-    { "glMultiTexCoord4dSGIS", "GL_SGIS_multitexture", glMultiTexCoord4dSGIS },
-    { "glMultiTexCoord4dv", "GL_VERSION_1_3", glMultiTexCoord4dv },
-    { "glMultiTexCoord4dvARB", "GL_ARB_multitexture", glMultiTexCoord4dvARB },
-    { "glMultiTexCoord4dvSGIS", "GL_SGIS_multitexture", glMultiTexCoord4dvSGIS },
-    { "glMultiTexCoord4f", "GL_VERSION_1_3", glMultiTexCoord4f },
-    { "glMultiTexCoord4fARB", "GL_ARB_multitexture", glMultiTexCoord4fARB },
-    { "glMultiTexCoord4fSGIS", "GL_SGIS_multitexture", glMultiTexCoord4fSGIS },
-    { "glMultiTexCoord4fv", "GL_VERSION_1_3", glMultiTexCoord4fv },
-    { "glMultiTexCoord4fvARB", "GL_ARB_multitexture", glMultiTexCoord4fvARB },
-    { "glMultiTexCoord4fvSGIS", "GL_SGIS_multitexture", glMultiTexCoord4fvSGIS },
-    { "glMultiTexCoord4hNV", "GL_NV_half_float", glMultiTexCoord4hNV },
-    { "glMultiTexCoord4hvNV", "GL_NV_half_float", glMultiTexCoord4hvNV },
-    { "glMultiTexCoord4i", "GL_VERSION_1_3", glMultiTexCoord4i },
-    { "glMultiTexCoord4iARB", "GL_ARB_multitexture", glMultiTexCoord4iARB },
-    { "glMultiTexCoord4iSGIS", "GL_SGIS_multitexture", glMultiTexCoord4iSGIS },
-    { "glMultiTexCoord4iv", "GL_VERSION_1_3", glMultiTexCoord4iv },
-    { "glMultiTexCoord4ivARB", "GL_ARB_multitexture", glMultiTexCoord4ivARB },
-    { "glMultiTexCoord4ivSGIS", "GL_SGIS_multitexture", glMultiTexCoord4ivSGIS },
-    { "glMultiTexCoord4s", "GL_VERSION_1_3", glMultiTexCoord4s },
-    { "glMultiTexCoord4sARB", "GL_ARB_multitexture", glMultiTexCoord4sARB },
-    { "glMultiTexCoord4sSGIS", "GL_SGIS_multitexture", glMultiTexCoord4sSGIS },
-    { "glMultiTexCoord4sv", "GL_VERSION_1_3", glMultiTexCoord4sv },
-    { "glMultiTexCoord4svARB", "GL_ARB_multitexture", glMultiTexCoord4svARB },
-    { "glMultiTexCoord4svSGIS", "GL_SGIS_multitexture", glMultiTexCoord4svSGIS },
-    { "glMultiTexCoord4xOES", "GL_OES_fixed_point", glMultiTexCoord4xOES },
-    { "glMultiTexCoord4xvOES", "GL_OES_fixed_point", glMultiTexCoord4xvOES },
-    { "glMultiTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP1ui },
-    { "glMultiTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP1uiv },
-    { "glMultiTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP2ui },
-    { "glMultiTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP2uiv },
-    { "glMultiTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP3ui },
-    { "glMultiTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP3uiv },
-    { "glMultiTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP4ui },
-    { "glMultiTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glMultiTexCoordP4uiv },
-    { "glMultiTexCoordPointerEXT", "GL_EXT_direct_state_access", glMultiTexCoordPointerEXT },
-    { "glMultiTexCoordPointerSGIS", "GL_SGIS_multitexture", glMultiTexCoordPointerSGIS },
-    { "glMultiTexEnvfEXT", "GL_EXT_direct_state_access", glMultiTexEnvfEXT },
-    { "glMultiTexEnvfvEXT", "GL_EXT_direct_state_access", glMultiTexEnvfvEXT },
-    { "glMultiTexEnviEXT", "GL_EXT_direct_state_access", glMultiTexEnviEXT },
-    { "glMultiTexEnvivEXT", "GL_EXT_direct_state_access", glMultiTexEnvivEXT },
-    { "glMultiTexGendEXT", "GL_EXT_direct_state_access", glMultiTexGendEXT },
-    { "glMultiTexGendvEXT", "GL_EXT_direct_state_access", glMultiTexGendvEXT },
-    { "glMultiTexGenfEXT", "GL_EXT_direct_state_access", glMultiTexGenfEXT },
-    { "glMultiTexGenfvEXT", "GL_EXT_direct_state_access", glMultiTexGenfvEXT },
-    { "glMultiTexGeniEXT", "GL_EXT_direct_state_access", glMultiTexGeniEXT },
-    { "glMultiTexGenivEXT", "GL_EXT_direct_state_access", glMultiTexGenivEXT },
-    { "glMultiTexImage1DEXT", "GL_EXT_direct_state_access", glMultiTexImage1DEXT },
-    { "glMultiTexImage2DEXT", "GL_EXT_direct_state_access", glMultiTexImage2DEXT },
-    { "glMultiTexImage3DEXT", "GL_EXT_direct_state_access", glMultiTexImage3DEXT },
-    { "glMultiTexParameterIivEXT", "GL_EXT_direct_state_access", glMultiTexParameterIivEXT },
-    { "glMultiTexParameterIuivEXT", "GL_EXT_direct_state_access", glMultiTexParameterIuivEXT },
-    { "glMultiTexParameterfEXT", "GL_EXT_direct_state_access", glMultiTexParameterfEXT },
-    { "glMultiTexParameterfvEXT", "GL_EXT_direct_state_access", glMultiTexParameterfvEXT },
-    { "glMultiTexParameteriEXT", "GL_EXT_direct_state_access", glMultiTexParameteriEXT },
-    { "glMultiTexParameterivEXT", "GL_EXT_direct_state_access", glMultiTexParameterivEXT },
-    { "glMultiTexRenderbufferEXT", "GL_EXT_direct_state_access", glMultiTexRenderbufferEXT },
-    { "glMultiTexSubImage1DEXT", "GL_EXT_direct_state_access", glMultiTexSubImage1DEXT },
-    { "glMultiTexSubImage2DEXT", "GL_EXT_direct_state_access", glMultiTexSubImage2DEXT },
-    { "glMultiTexSubImage3DEXT", "GL_EXT_direct_state_access", glMultiTexSubImage3DEXT },
-    { "glMulticastBarrierNV", "GL_NV_gpu_multicast", glMulticastBarrierNV },
-    { "glMulticastBlitFramebufferNV", "GL_NV_gpu_multicast", glMulticastBlitFramebufferNV },
-    { "glMulticastBufferSubDataNV", "GL_NV_gpu_multicast", glMulticastBufferSubDataNV },
-    { "glMulticastCopyBufferSubDataNV", "GL_NV_gpu_multicast", glMulticastCopyBufferSubDataNV },
-    { "glMulticastCopyImageSubDataNV", "GL_NV_gpu_multicast", glMulticastCopyImageSubDataNV },
-    { "glMulticastFramebufferSampleLocationsfvNV", "GL_NV_gpu_multicast", glMulticastFramebufferSampleLocationsfvNV },
-    { "glMulticastGetQueryObjecti64vNV", "GL_NV_gpu_multicast", glMulticastGetQueryObjecti64vNV },
-    { "glMulticastGetQueryObjectivNV", "GL_NV_gpu_multicast", glMulticastGetQueryObjectivNV },
-    { "glMulticastGetQueryObjectui64vNV", "GL_NV_gpu_multicast", glMulticastGetQueryObjectui64vNV },
-    { "glMulticastGetQueryObjectuivNV", "GL_NV_gpu_multicast", glMulticastGetQueryObjectuivNV },
-    { "glMulticastScissorArrayvNVX", "GL_NVX_gpu_multicast2", glMulticastScissorArrayvNVX },
-    { "glMulticastViewportArrayvNVX", "GL_NVX_gpu_multicast2", glMulticastViewportArrayvNVX },
-    { "glMulticastViewportPositionWScaleNVX", "GL_NVX_gpu_multicast2", glMulticastViewportPositionWScaleNVX },
-    { "glMulticastWaitSyncNV", "GL_NV_gpu_multicast", glMulticastWaitSyncNV },
-    { "glNamedBufferAttachMemoryNV", "GL_NV_memory_attachment", glNamedBufferAttachMemoryNV },
-    { "glNamedBufferData", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedBufferData },
-    { "glNamedBufferDataEXT", "GL_EXT_direct_state_access", glNamedBufferDataEXT },
-    { "glNamedBufferPageCommitmentARB", "GL_ARB_sparse_buffer", glNamedBufferPageCommitmentARB },
-    { "glNamedBufferPageCommitmentEXT", "GL_ARB_sparse_buffer", glNamedBufferPageCommitmentEXT },
-    { "glNamedBufferStorage", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedBufferStorage },
-    { "glNamedBufferStorageEXT", "GL_EXT_direct_state_access", glNamedBufferStorageEXT },
-    { "glNamedBufferStorageExternalEXT", "GL_EXT_external_buffer", glNamedBufferStorageExternalEXT },
-    { "glNamedBufferStorageMemEXT", "GL_EXT_memory_object", glNamedBufferStorageMemEXT },
-    { "glNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedBufferSubData },
-    { "glNamedBufferSubDataEXT", "GL_EXT_direct_state_access", glNamedBufferSubDataEXT },
-    { "glNamedCopyBufferSubDataEXT", "GL_EXT_direct_state_access", glNamedCopyBufferSubDataEXT },
-    { "glNamedFramebufferDrawBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferDrawBuffer },
-    { "glNamedFramebufferDrawBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferDrawBuffers },
-    { "glNamedFramebufferParameteri", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferParameteri },
-    { "glNamedFramebufferParameteriEXT", "GL_EXT_direct_state_access", glNamedFramebufferParameteriEXT },
-    { "glNamedFramebufferReadBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferReadBuffer },
-    { "glNamedFramebufferRenderbuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferRenderbuffer },
-    { "glNamedFramebufferRenderbufferEXT", "GL_EXT_direct_state_access", glNamedFramebufferRenderbufferEXT },
-    { "glNamedFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations", glNamedFramebufferSampleLocationsfvARB },
-    { "glNamedFramebufferSampleLocationsfvNV", "GL_NV_sample_locations", glNamedFramebufferSampleLocationsfvNV },
-    { "glNamedFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions", glNamedFramebufferSamplePositionsfvAMD },
-    { "glNamedFramebufferTexture", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferTexture },
-    { "glNamedFramebufferTexture1DEXT", "GL_EXT_direct_state_access", glNamedFramebufferTexture1DEXT },
-    { "glNamedFramebufferTexture2DEXT", "GL_EXT_direct_state_access", glNamedFramebufferTexture2DEXT },
-    { "glNamedFramebufferTexture3DEXT", "GL_EXT_direct_state_access", glNamedFramebufferTexture3DEXT },
-    { "glNamedFramebufferTextureEXT", "GL_EXT_direct_state_access", glNamedFramebufferTextureEXT },
-    { "glNamedFramebufferTextureFaceEXT", "GL_EXT_direct_state_access", glNamedFramebufferTextureFaceEXT },
-    { "glNamedFramebufferTextureLayer", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedFramebufferTextureLayer },
-    { "glNamedFramebufferTextureLayerEXT", "GL_EXT_direct_state_access", glNamedFramebufferTextureLayerEXT },
-    { "glNamedProgramLocalParameter4dEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameter4dEXT },
-    { "glNamedProgramLocalParameter4dvEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameter4dvEXT },
-    { "glNamedProgramLocalParameter4fEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameter4fEXT },
-    { "glNamedProgramLocalParameter4fvEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameter4fvEXT },
-    { "glNamedProgramLocalParameterI4iEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameterI4iEXT },
-    { "glNamedProgramLocalParameterI4ivEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameterI4ivEXT },
-    { "glNamedProgramLocalParameterI4uiEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameterI4uiEXT },
-    { "glNamedProgramLocalParameterI4uivEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameterI4uivEXT },
-    { "glNamedProgramLocalParameters4fvEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParameters4fvEXT },
-    { "glNamedProgramLocalParametersI4ivEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParametersI4ivEXT },
-    { "glNamedProgramLocalParametersI4uivEXT", "GL_EXT_direct_state_access", glNamedProgramLocalParametersI4uivEXT },
-    { "glNamedProgramStringEXT", "GL_EXT_direct_state_access", glNamedProgramStringEXT },
-    { "glNamedRenderbufferStorage", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedRenderbufferStorage },
-    { "glNamedRenderbufferStorageEXT", "GL_EXT_direct_state_access", glNamedRenderbufferStorageEXT },
-    { "glNamedRenderbufferStorageMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5", glNamedRenderbufferStorageMultisample },
-    { "glNamedRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced", glNamedRenderbufferStorageMultisampleAdvancedAMD },
-    { "glNamedRenderbufferStorageMultisampleCoverageEXT", "GL_EXT_direct_state_access", glNamedRenderbufferStorageMultisampleCoverageEXT },
-    { "glNamedRenderbufferStorageMultisampleEXT", "GL_EXT_direct_state_access", glNamedRenderbufferStorageMultisampleEXT },
-    { "glNamedStringARB", "GL_ARB_shading_language_include", glNamedStringARB },
-    { "glNewBufferRegion", "GL_KTX_buffer_region", glNewBufferRegion },
-    { "glNewObjectBufferATI", "GL_ATI_vertex_array_object", glNewObjectBufferATI },
-    { "glNormal3fVertex3fSUN", "GL_SUN_vertex", glNormal3fVertex3fSUN },
-    { "glNormal3fVertex3fvSUN", "GL_SUN_vertex", glNormal3fVertex3fvSUN },
-    { "glNormal3hNV", "GL_NV_half_float", glNormal3hNV },
-    { "glNormal3hvNV", "GL_NV_half_float", glNormal3hvNV },
-    { "glNormal3xOES", "GL_OES_fixed_point", glNormal3xOES },
-    { "glNormal3xvOES", "GL_OES_fixed_point", glNormal3xvOES },
-    { "glNormalFormatNV", "GL_NV_vertex_buffer_unified_memory", glNormalFormatNV },
-    { "glNormalP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glNormalP3ui },
-    { "glNormalP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glNormalP3uiv },
-    { "glNormalPointerEXT", "GL_EXT_vertex_array", glNormalPointerEXT },
-    { "glNormalPointerListIBM", "GL_IBM_vertex_array_lists", glNormalPointerListIBM },
-    { "glNormalPointervINTEL", "GL_INTEL_parallel_arrays", glNormalPointervINTEL },
-    { "glNormalStream3bATI", "GL_ATI_vertex_streams", glNormalStream3bATI },
-    { "glNormalStream3bvATI", "GL_ATI_vertex_streams", glNormalStream3bvATI },
-    { "glNormalStream3dATI", "GL_ATI_vertex_streams", glNormalStream3dATI },
-    { "glNormalStream3dvATI", "GL_ATI_vertex_streams", glNormalStream3dvATI },
-    { "glNormalStream3fATI", "GL_ATI_vertex_streams", glNormalStream3fATI },
-    { "glNormalStream3fvATI", "GL_ATI_vertex_streams", glNormalStream3fvATI },
-    { "glNormalStream3iATI", "GL_ATI_vertex_streams", glNormalStream3iATI },
-    { "glNormalStream3ivATI", "GL_ATI_vertex_streams", glNormalStream3ivATI },
-    { "glNormalStream3sATI", "GL_ATI_vertex_streams", glNormalStream3sATI },
-    { "glNormalStream3svATI", "GL_ATI_vertex_streams", glNormalStream3svATI },
-    { "glObjectLabel", "GL_KHR_debug GL_VERSION_4_3", glObjectLabel },
-    { "glObjectPtrLabel", "GL_KHR_debug GL_VERSION_4_3", glObjectPtrLabel },
-    { "glObjectPurgeableAPPLE", "GL_APPLE_object_purgeable", glObjectPurgeableAPPLE },
-    { "glObjectUnpurgeableAPPLE", "GL_APPLE_object_purgeable", glObjectUnpurgeableAPPLE },
-    { "glOrthofOES", "GL_OES_single_precision", glOrthofOES },
-    { "glOrthoxOES", "GL_OES_fixed_point", glOrthoxOES },
-    { "glPNTrianglesfATI", "GL_ATI_pn_triangles", glPNTrianglesfATI },
-    { "glPNTrianglesiATI", "GL_ATI_pn_triangles", glPNTrianglesiATI },
-    { "glPassTexCoordATI", "GL_ATI_fragment_shader", glPassTexCoordATI },
-    { "glPassThroughxOES", "GL_OES_fixed_point", glPassThroughxOES },
-    { "glPatchParameterfv", "GL_ARB_tessellation_shader GL_VERSION_4_0", glPatchParameterfv },
-    { "glPatchParameteri", "GL_ARB_tessellation_shader GL_VERSION_4_0", glPatchParameteri },
-    { "glPathColorGenNV", "GL_NV_path_rendering", glPathColorGenNV },
-    { "glPathCommandsNV", "GL_NV_path_rendering", glPathCommandsNV },
-    { "glPathCoordsNV", "GL_NV_path_rendering", glPathCoordsNV },
-    { "glPathCoverDepthFuncNV", "GL_NV_path_rendering", glPathCoverDepthFuncNV },
-    { "glPathDashArrayNV", "GL_NV_path_rendering", glPathDashArrayNV },
-    { "glPathFogGenNV", "GL_NV_path_rendering", glPathFogGenNV },
-    { "glPathGlyphIndexArrayNV", "GL_NV_path_rendering", glPathGlyphIndexArrayNV },
-    { "glPathGlyphIndexRangeNV", "GL_NV_path_rendering", glPathGlyphIndexRangeNV },
-    { "glPathGlyphRangeNV", "GL_NV_path_rendering", glPathGlyphRangeNV },
-    { "glPathGlyphsNV", "GL_NV_path_rendering", glPathGlyphsNV },
-    { "glPathMemoryGlyphIndexArrayNV", "GL_NV_path_rendering", glPathMemoryGlyphIndexArrayNV },
-    { "glPathParameterfNV", "GL_NV_path_rendering", glPathParameterfNV },
-    { "glPathParameterfvNV", "GL_NV_path_rendering", glPathParameterfvNV },
-    { "glPathParameteriNV", "GL_NV_path_rendering", glPathParameteriNV },
-    { "glPathParameterivNV", "GL_NV_path_rendering", glPathParameterivNV },
-    { "glPathStencilDepthOffsetNV", "GL_NV_path_rendering", glPathStencilDepthOffsetNV },
-    { "glPathStencilFuncNV", "GL_NV_path_rendering", glPathStencilFuncNV },
-    { "glPathStringNV", "GL_NV_path_rendering", glPathStringNV },
-    { "glPathSubCommandsNV", "GL_NV_path_rendering", glPathSubCommandsNV },
-    { "glPathSubCoordsNV", "GL_NV_path_rendering", glPathSubCoordsNV },
-    { "glPathTexGenNV", "GL_NV_path_rendering", glPathTexGenNV },
-    { "glPauseTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glPauseTransformFeedback },
-    { "glPauseTransformFeedbackNV", "GL_NV_transform_feedback2", glPauseTransformFeedbackNV },
-    { "glPixelDataRangeNV", "GL_NV_pixel_data_range", glPixelDataRangeNV },
-    { "glPixelMapx", "GL_OES_fixed_point", glPixelMapx },
-    { "glPixelStorex", "GL_OES_fixed_point", glPixelStorex },
-    { "glPixelTexGenParameterfSGIS", "GL_SGIS_pixel_texture", glPixelTexGenParameterfSGIS },
-    { "glPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture", glPixelTexGenParameterfvSGIS },
-    { "glPixelTexGenParameteriSGIS", "GL_SGIS_pixel_texture", glPixelTexGenParameteriSGIS },
-    { "glPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture", glPixelTexGenParameterivSGIS },
-    { "glPixelTexGenSGIX", "GL_SGIX_pixel_texture", glPixelTexGenSGIX },
-    { "glPixelTransferxOES", "GL_OES_fixed_point", glPixelTransferxOES },
-    { "glPixelTransformParameterfEXT", "GL_EXT_pixel_transform", glPixelTransformParameterfEXT },
-    { "glPixelTransformParameterfvEXT", "GL_EXT_pixel_transform", glPixelTransformParameterfvEXT },
-    { "glPixelTransformParameteriEXT", "GL_EXT_pixel_transform", glPixelTransformParameteriEXT },
-    { "glPixelTransformParameterivEXT", "GL_EXT_pixel_transform", glPixelTransformParameterivEXT },
-    { "glPixelZoomxOES", "GL_OES_fixed_point", glPixelZoomxOES },
-    { "glPointAlongPathNV", "GL_NV_path_rendering", glPointAlongPathNV },
-    { "glPointParameterf", "GL_VERSION_1_4", glPointParameterf },
-    { "glPointParameterfARB", "GL_ARB_point_parameters", glPointParameterfARB },
-    { "glPointParameterfEXT", "GL_EXT_point_parameters", glPointParameterfEXT },
-    { "glPointParameterfSGIS", "GL_SGIS_point_parameters", glPointParameterfSGIS },
-    { "glPointParameterfv", "GL_VERSION_1_4", glPointParameterfv },
-    { "glPointParameterfvARB", "GL_ARB_point_parameters", glPointParameterfvARB },
-    { "glPointParameterfvEXT", "GL_EXT_point_parameters", glPointParameterfvEXT },
-    { "glPointParameterfvSGIS", "GL_SGIS_point_parameters", glPointParameterfvSGIS },
-    { "glPointParameteri", "GL_VERSION_1_4", glPointParameteri },
-    { "glPointParameteriNV", "GL_NV_point_sprite", glPointParameteriNV },
-    { "glPointParameteriv", "GL_VERSION_1_4", glPointParameteriv },
-    { "glPointParameterivNV", "GL_NV_point_sprite", glPointParameterivNV },
-    { "glPointParameterxvOES", "GL_OES_fixed_point", glPointParameterxvOES },
-    { "glPointSizexOES", "GL_OES_fixed_point", glPointSizexOES },
-    { "glPollAsyncSGIX", "GL_SGIX_async", glPollAsyncSGIX },
-    { "glPollInstrumentsSGIX", "GL_SGIX_instruments", glPollInstrumentsSGIX },
-    { "glPolygonOffsetClamp", "GL_ARB_polygon_offset_clamp GL_VERSION_4_6", glPolygonOffsetClamp },
-    { "glPolygonOffsetClampEXT", "GL_EXT_polygon_offset_clamp", glPolygonOffsetClampEXT },
-    { "glPolygonOffsetEXT", "GL_EXT_polygon_offset", glPolygonOffsetEXT },
-    { "glPolygonOffsetxOES", "GL_OES_fixed_point", glPolygonOffsetxOES },
-    { "glPopDebugGroup", "GL_KHR_debug GL_VERSION_4_3", glPopDebugGroup },
-    { "glPopGroupMarkerEXT", "GL_EXT_debug_marker", glPopGroupMarkerEXT },
-    { "glPresentFrameDualFillNV", "GL_NV_present_video", glPresentFrameDualFillNV },
-    { "glPresentFrameKeyedNV", "GL_NV_present_video", glPresentFrameKeyedNV },
-    { "glPrimitiveBoundingBoxARB", "GL_ARB_ES3_2_compatibility", glPrimitiveBoundingBoxARB },
-    { "glPrimitiveRestartIndex", "GL_VERSION_3_1", glPrimitiveRestartIndex },
-    { "glPrimitiveRestartIndexNV", "GL_NV_primitive_restart", glPrimitiveRestartIndexNV },
-    { "glPrimitiveRestartNV", "GL_NV_primitive_restart", glPrimitiveRestartNV },
-    { "glPrioritizeTexturesEXT", "GL_EXT_texture_object", glPrioritizeTexturesEXT },
-    { "glPrioritizeTexturesxOES", "GL_OES_fixed_point", glPrioritizeTexturesxOES },
-    { "glProgramBinary", "GL_ARB_get_program_binary GL_VERSION_4_1", glProgramBinary },
-    { "glProgramBufferParametersIivNV", "GL_NV_parameter_buffer_object", glProgramBufferParametersIivNV },
-    { "glProgramBufferParametersIuivNV", "GL_NV_parameter_buffer_object", glProgramBufferParametersIuivNV },
-    { "glProgramBufferParametersfvNV", "GL_NV_parameter_buffer_object", glProgramBufferParametersfvNV },
-    { "glProgramEnvParameter4dARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramEnvParameter4dARB },
-    { "glProgramEnvParameter4dvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramEnvParameter4dvARB },
-    { "glProgramEnvParameter4fARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramEnvParameter4fARB },
-    { "glProgramEnvParameter4fvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramEnvParameter4fvARB },
-    { "glProgramEnvParameterI4iNV", "GL_NV_gpu_program4", glProgramEnvParameterI4iNV },
-    { "glProgramEnvParameterI4ivNV", "GL_NV_gpu_program4", glProgramEnvParameterI4ivNV },
-    { "glProgramEnvParameterI4uiNV", "GL_NV_gpu_program4", glProgramEnvParameterI4uiNV },
-    { "glProgramEnvParameterI4uivNV", "GL_NV_gpu_program4", glProgramEnvParameterI4uivNV },
-    { "glProgramEnvParameters4fvEXT", "GL_EXT_gpu_program_parameters", glProgramEnvParameters4fvEXT },
-    { "glProgramEnvParametersI4ivNV", "GL_NV_gpu_program4", glProgramEnvParametersI4ivNV },
-    { "glProgramEnvParametersI4uivNV", "GL_NV_gpu_program4", glProgramEnvParametersI4uivNV },
-    { "glProgramLocalParameter4dARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramLocalParameter4dARB },
-    { "glProgramLocalParameter4dvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramLocalParameter4dvARB },
-    { "glProgramLocalParameter4fARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramLocalParameter4fARB },
-    { "glProgramLocalParameter4fvARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramLocalParameter4fvARB },
-    { "glProgramLocalParameterI4iNV", "GL_NV_gpu_program4", glProgramLocalParameterI4iNV },
-    { "glProgramLocalParameterI4ivNV", "GL_NV_gpu_program4", glProgramLocalParameterI4ivNV },
-    { "glProgramLocalParameterI4uiNV", "GL_NV_gpu_program4", glProgramLocalParameterI4uiNV },
-    { "glProgramLocalParameterI4uivNV", "GL_NV_gpu_program4", glProgramLocalParameterI4uivNV },
-    { "glProgramLocalParameters4fvEXT", "GL_EXT_gpu_program_parameters", glProgramLocalParameters4fvEXT },
-    { "glProgramLocalParametersI4ivNV", "GL_NV_gpu_program4", glProgramLocalParametersI4ivNV },
-    { "glProgramLocalParametersI4uivNV", "GL_NV_gpu_program4", glProgramLocalParametersI4uivNV },
-    { "glProgramNamedParameter4dNV", "GL_NV_fragment_program", glProgramNamedParameter4dNV },
-    { "glProgramNamedParameter4dvNV", "GL_NV_fragment_program", glProgramNamedParameter4dvNV },
-    { "glProgramNamedParameter4fNV", "GL_NV_fragment_program", glProgramNamedParameter4fNV },
-    { "glProgramNamedParameter4fvNV", "GL_NV_fragment_program", glProgramNamedParameter4fvNV },
-    { "glProgramParameter4dNV", "GL_NV_vertex_program", glProgramParameter4dNV },
-    { "glProgramParameter4dvNV", "GL_NV_vertex_program", glProgramParameter4dvNV },
-    { "glProgramParameter4fNV", "GL_NV_vertex_program", glProgramParameter4fNV },
-    { "glProgramParameter4fvNV", "GL_NV_vertex_program", glProgramParameter4fvNV },
-    { "glProgramParameteri", "GL_ARB_get_program_binary GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramParameteri },
-    { "glProgramParameteriARB", "GL_ARB_geometry_shader4", glProgramParameteriARB },
-    { "glProgramParameteriEXT", "GL_EXT_geometry_shader4", glProgramParameteriEXT },
-    { "glProgramParameters4dvNV", "GL_NV_vertex_program", glProgramParameters4dvNV },
-    { "glProgramParameters4fvNV", "GL_NV_vertex_program", glProgramParameters4fvNV },
-    { "glProgramPathFragmentInputGenNV", "GL_NV_path_rendering", glProgramPathFragmentInputGenNV },
-    { "glProgramStringARB", "GL_ARB_fragment_program GL_ARB_vertex_program", glProgramStringARB },
-    { "glProgramSubroutineParametersuivNV", "GL_NV_gpu_program5", glProgramSubroutineParametersuivNV },
-    { "glProgramUniform1d", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1d },
-    { "glProgramUniform1dEXT", "GL_EXT_direct_state_access", glProgramUniform1dEXT },
-    { "glProgramUniform1dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1dv },
-    { "glProgramUniform1dvEXT", "GL_EXT_direct_state_access", glProgramUniform1dvEXT },
-    { "glProgramUniform1f", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1f },
-    { "glProgramUniform1fEXT", "GL_EXT_direct_state_access", glProgramUniform1fEXT },
-    { "glProgramUniform1fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1fv },
-    { "glProgramUniform1fvEXT", "GL_EXT_direct_state_access", glProgramUniform1fvEXT },
-    { "glProgramUniform1i", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1i },
-    { "glProgramUniform1i64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform1i64ARB },
-    { "glProgramUniform1i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform1i64NV },
-    { "glProgramUniform1i64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform1i64vARB },
-    { "glProgramUniform1i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform1i64vNV },
-    { "glProgramUniform1iEXT", "GL_EXT_direct_state_access", glProgramUniform1iEXT },
-    { "glProgramUniform1iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1iv },
-    { "glProgramUniform1ivEXT", "GL_EXT_direct_state_access", glProgramUniform1ivEXT },
-    { "glProgramUniform1ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1ui },
-    { "glProgramUniform1ui64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform1ui64ARB },
-    { "glProgramUniform1ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform1ui64NV },
-    { "glProgramUniform1ui64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform1ui64vARB },
-    { "glProgramUniform1ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform1ui64vNV },
-    { "glProgramUniform1uiEXT", "GL_EXT_direct_state_access", glProgramUniform1uiEXT },
-    { "glProgramUniform1uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform1uiv },
-    { "glProgramUniform1uivEXT", "GL_EXT_direct_state_access", glProgramUniform1uivEXT },
-    { "glProgramUniform2d", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2d },
-    { "glProgramUniform2dEXT", "GL_EXT_direct_state_access", glProgramUniform2dEXT },
-    { "glProgramUniform2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2dv },
-    { "glProgramUniform2dvEXT", "GL_EXT_direct_state_access", glProgramUniform2dvEXT },
-    { "glProgramUniform2f", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2f },
-    { "glProgramUniform2fEXT", "GL_EXT_direct_state_access", glProgramUniform2fEXT },
-    { "glProgramUniform2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2fv },
-    { "glProgramUniform2fvEXT", "GL_EXT_direct_state_access", glProgramUniform2fvEXT },
-    { "glProgramUniform2i", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2i },
-    { "glProgramUniform2i64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform2i64ARB },
-    { "glProgramUniform2i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform2i64NV },
-    { "glProgramUniform2i64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform2i64vARB },
-    { "glProgramUniform2i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform2i64vNV },
-    { "glProgramUniform2iEXT", "GL_EXT_direct_state_access", glProgramUniform2iEXT },
-    { "glProgramUniform2iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2iv },
-    { "glProgramUniform2ivEXT", "GL_EXT_direct_state_access", glProgramUniform2ivEXT },
-    { "glProgramUniform2ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2ui },
-    { "glProgramUniform2ui64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform2ui64ARB },
-    { "glProgramUniform2ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform2ui64NV },
-    { "glProgramUniform2ui64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform2ui64vARB },
-    { "glProgramUniform2ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform2ui64vNV },
-    { "glProgramUniform2uiEXT", "GL_EXT_direct_state_access", glProgramUniform2uiEXT },
-    { "glProgramUniform2uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform2uiv },
-    { "glProgramUniform2uivEXT", "GL_EXT_direct_state_access", glProgramUniform2uivEXT },
-    { "glProgramUniform3d", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3d },
-    { "glProgramUniform3dEXT", "GL_EXT_direct_state_access", glProgramUniform3dEXT },
-    { "glProgramUniform3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3dv },
-    { "glProgramUniform3dvEXT", "GL_EXT_direct_state_access", glProgramUniform3dvEXT },
-    { "glProgramUniform3f", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3f },
-    { "glProgramUniform3fEXT", "GL_EXT_direct_state_access", glProgramUniform3fEXT },
-    { "glProgramUniform3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3fv },
-    { "glProgramUniform3fvEXT", "GL_EXT_direct_state_access", glProgramUniform3fvEXT },
-    { "glProgramUniform3i", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3i },
-    { "glProgramUniform3i64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform3i64ARB },
-    { "glProgramUniform3i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform3i64NV },
-    { "glProgramUniform3i64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform3i64vARB },
-    { "glProgramUniform3i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform3i64vNV },
-    { "glProgramUniform3iEXT", "GL_EXT_direct_state_access", glProgramUniform3iEXT },
-    { "glProgramUniform3iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3iv },
-    { "glProgramUniform3ivEXT", "GL_EXT_direct_state_access", glProgramUniform3ivEXT },
-    { "glProgramUniform3ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3ui },
-    { "glProgramUniform3ui64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform3ui64ARB },
-    { "glProgramUniform3ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform3ui64NV },
-    { "glProgramUniform3ui64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform3ui64vARB },
-    { "glProgramUniform3ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform3ui64vNV },
-    { "glProgramUniform3uiEXT", "GL_EXT_direct_state_access", glProgramUniform3uiEXT },
-    { "glProgramUniform3uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform3uiv },
-    { "glProgramUniform3uivEXT", "GL_EXT_direct_state_access", glProgramUniform3uivEXT },
-    { "glProgramUniform4d", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4d },
-    { "glProgramUniform4dEXT", "GL_EXT_direct_state_access", glProgramUniform4dEXT },
-    { "glProgramUniform4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4dv },
-    { "glProgramUniform4dvEXT", "GL_EXT_direct_state_access", glProgramUniform4dvEXT },
-    { "glProgramUniform4f", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4f },
-    { "glProgramUniform4fEXT", "GL_EXT_direct_state_access", glProgramUniform4fEXT },
-    { "glProgramUniform4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4fv },
-    { "glProgramUniform4fvEXT", "GL_EXT_direct_state_access", glProgramUniform4fvEXT },
-    { "glProgramUniform4i", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4i },
-    { "glProgramUniform4i64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform4i64ARB },
-    { "glProgramUniform4i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform4i64NV },
-    { "glProgramUniform4i64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform4i64vARB },
-    { "glProgramUniform4i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform4i64vNV },
-    { "glProgramUniform4iEXT", "GL_EXT_direct_state_access", glProgramUniform4iEXT },
-    { "glProgramUniform4iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4iv },
-    { "glProgramUniform4ivEXT", "GL_EXT_direct_state_access", glProgramUniform4ivEXT },
-    { "glProgramUniform4ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4ui },
-    { "glProgramUniform4ui64ARB", "GL_ARB_gpu_shader_int64", glProgramUniform4ui64ARB },
-    { "glProgramUniform4ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform4ui64NV },
-    { "glProgramUniform4ui64vARB", "GL_ARB_gpu_shader_int64", glProgramUniform4ui64vARB },
-    { "glProgramUniform4ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glProgramUniform4ui64vNV },
-    { "glProgramUniform4uiEXT", "GL_EXT_direct_state_access", glProgramUniform4uiEXT },
-    { "glProgramUniform4uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniform4uiv },
-    { "glProgramUniform4uivEXT", "GL_EXT_direct_state_access", glProgramUniform4uivEXT },
-    { "glProgramUniformHandleui64ARB", "GL_ARB_bindless_texture", glProgramUniformHandleui64ARB },
-    { "glProgramUniformHandleui64NV", "GL_NV_bindless_texture", glProgramUniformHandleui64NV },
-    { "glProgramUniformHandleui64vARB", "GL_ARB_bindless_texture", glProgramUniformHandleui64vARB },
-    { "glProgramUniformHandleui64vNV", "GL_NV_bindless_texture", glProgramUniformHandleui64vNV },
-    { "glProgramUniformMatrix2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2dv },
-    { "glProgramUniformMatrix2dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2dvEXT },
-    { "glProgramUniformMatrix2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2fv },
-    { "glProgramUniformMatrix2fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2fvEXT },
-    { "glProgramUniformMatrix2x3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2x3dv },
-    { "glProgramUniformMatrix2x3dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2x3dvEXT },
-    { "glProgramUniformMatrix2x3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2x3fv },
-    { "glProgramUniformMatrix2x3fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2x3fvEXT },
-    { "glProgramUniformMatrix2x4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2x4dv },
-    { "glProgramUniformMatrix2x4dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2x4dvEXT },
-    { "glProgramUniformMatrix2x4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix2x4fv },
-    { "glProgramUniformMatrix2x4fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix2x4fvEXT },
-    { "glProgramUniformMatrix3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3dv },
-    { "glProgramUniformMatrix3dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3dvEXT },
-    { "glProgramUniformMatrix3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3fv },
-    { "glProgramUniformMatrix3fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3fvEXT },
-    { "glProgramUniformMatrix3x2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3x2dv },
-    { "glProgramUniformMatrix3x2dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3x2dvEXT },
-    { "glProgramUniformMatrix3x2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3x2fv },
-    { "glProgramUniformMatrix3x2fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3x2fvEXT },
-    { "glProgramUniformMatrix3x4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3x4dv },
-    { "glProgramUniformMatrix3x4dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3x4dvEXT },
-    { "glProgramUniformMatrix3x4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix3x4fv },
-    { "glProgramUniformMatrix3x4fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix3x4fvEXT },
-    { "glProgramUniformMatrix4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4dv },
-    { "glProgramUniformMatrix4dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4dvEXT },
-    { "glProgramUniformMatrix4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4fv },
-    { "glProgramUniformMatrix4fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4fvEXT },
-    { "glProgramUniformMatrix4x2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4x2dv },
-    { "glProgramUniformMatrix4x2dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4x2dvEXT },
-    { "glProgramUniformMatrix4x2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4x2fv },
-    { "glProgramUniformMatrix4x2fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4x2fvEXT },
-    { "glProgramUniformMatrix4x3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4x3dv },
-    { "glProgramUniformMatrix4x3dvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4x3dvEXT },
-    { "glProgramUniformMatrix4x3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glProgramUniformMatrix4x3fv },
-    { "glProgramUniformMatrix4x3fvEXT", "GL_EXT_direct_state_access", glProgramUniformMatrix4x3fvEXT },
-    { "glProgramUniformui64NV", "GL_NV_shader_buffer_load", glProgramUniformui64NV },
-    { "glProgramUniformui64vNV", "GL_NV_shader_buffer_load", glProgramUniformui64vNV },
-    { "glProgramVertexLimitNV", "GL_NV_geometry_program4", glProgramVertexLimitNV },
-    { "glProvokingVertex", "GL_ARB_provoking_vertex GL_VERSION_3_2", glProvokingVertex },
-    { "glProvokingVertexEXT", "GL_EXT_provoking_vertex", glProvokingVertexEXT },
-    { "glPushClientAttribDefaultEXT", "GL_EXT_direct_state_access", glPushClientAttribDefaultEXT },
-    { "glPushDebugGroup", "GL_KHR_debug GL_VERSION_4_3", glPushDebugGroup },
-    { "glPushGroupMarkerEXT", "GL_EXT_debug_marker", glPushGroupMarkerEXT },
-    { "glQueryCounter", "GL_ARB_timer_query GL_VERSION_3_3", glQueryCounter },
-    { "glQueryMatrixxOES", "GL_OES_query_matrix", glQueryMatrixxOES },
-    { "glQueryObjectParameteruiAMD", "GL_AMD_occlusion_query_event", glQueryObjectParameteruiAMD },
-    { "glQueryResourceNV", "GL_NV_query_resource", glQueryResourceNV },
-    { "glQueryResourceTagNV", "GL_NV_query_resource_tag", glQueryResourceTagNV },
-    { "glRasterPos2xOES", "GL_OES_fixed_point", glRasterPos2xOES },
-    { "glRasterPos2xvOES", "GL_OES_fixed_point", glRasterPos2xvOES },
-    { "glRasterPos3xOES", "GL_OES_fixed_point", glRasterPos3xOES },
-    { "glRasterPos3xvOES", "GL_OES_fixed_point", glRasterPos3xvOES },
-    { "glRasterPos4xOES", "GL_OES_fixed_point", glRasterPos4xOES },
-    { "glRasterPos4xvOES", "GL_OES_fixed_point", glRasterPos4xvOES },
-    { "glRasterSamplesEXT", "GL_EXT_raster_multisample GL_NV_framebuffer_mixed_samples", glRasterSamplesEXT },
-    { "glReadBufferRegion", "GL_KTX_buffer_region", glReadBufferRegion },
-    { "glReadInstrumentsSGIX", "GL_SGIX_instruments", glReadInstrumentsSGIX },
-    { "glReadnPixels", "GL_KHR_robustness GL_VERSION_4_5", glReadnPixels },
-    { "glReadnPixelsARB", "GL_ARB_robustness", glReadnPixelsARB },
-    { "glRectxOES", "GL_OES_fixed_point", glRectxOES },
-    { "glRectxvOES", "GL_OES_fixed_point", glRectxvOES },
-    { "glReferencePlaneSGIX", "GL_SGIX_reference_plane", glReferencePlaneSGIX },
-    { "glReleaseKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex", glReleaseKeyedMutexWin32EXT },
-    { "glReleaseShaderCompiler", "GL_ARB_ES2_compatibility GL_VERSION_4_1", glReleaseShaderCompiler },
-    { "glRenderGpuMaskNV", "GL_NV_gpu_multicast", glRenderGpuMaskNV },
-    { "glRenderbufferStorage", "GL_ARB_framebuffer_object GL_VERSION_3_0", glRenderbufferStorage },
-    { "glRenderbufferStorageEXT", "GL_EXT_framebuffer_object", glRenderbufferStorageEXT },
-    { "glRenderbufferStorageMultisample", "GL_ARB_framebuffer_object GL_VERSION_3_0", glRenderbufferStorageMultisample },
-    { "glRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced", glRenderbufferStorageMultisampleAdvancedAMD },
-    { "glRenderbufferStorageMultisampleCoverageNV", "GL_NV_framebuffer_multisample_coverage", glRenderbufferStorageMultisampleCoverageNV },
-    { "glRenderbufferStorageMultisampleEXT", "GL_EXT_framebuffer_multisample", glRenderbufferStorageMultisampleEXT },
-    { "glReplacementCodePointerSUN", "GL_SUN_triangle_list", glReplacementCodePointerSUN },
-    { "glReplacementCodeubSUN", "GL_SUN_triangle_list", glReplacementCodeubSUN },
-    { "glReplacementCodeubvSUN", "GL_SUN_triangle_list", glReplacementCodeubvSUN },
-    { "glReplacementCodeuiColor3fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiColor3fVertex3fSUN },
-    { "glReplacementCodeuiColor3fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiColor3fVertex3fvSUN },
-    { "glReplacementCodeuiColor4fNormal3fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiColor4fNormal3fVertex3fSUN },
-    { "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiColor4fNormal3fVertex3fvSUN },
-    { "glReplacementCodeuiColor4ubVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiColor4ubVertex3fSUN },
-    { "glReplacementCodeuiColor4ubVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiColor4ubVertex3fvSUN },
-    { "glReplacementCodeuiNormal3fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiNormal3fVertex3fSUN },
-    { "glReplacementCodeuiNormal3fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiNormal3fVertex3fvSUN },
-    { "glReplacementCodeuiSUN", "GL_SUN_triangle_list", glReplacementCodeuiSUN },
-    { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN },
-    { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN },
-    { "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN },
-    { "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN },
-    { "glReplacementCodeuiTexCoord2fVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fVertex3fSUN },
-    { "glReplacementCodeuiTexCoord2fVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiTexCoord2fVertex3fvSUN },
-    { "glReplacementCodeuiVertex3fSUN", "GL_SUN_vertex", glReplacementCodeuiVertex3fSUN },
-    { "glReplacementCodeuiVertex3fvSUN", "GL_SUN_vertex", glReplacementCodeuiVertex3fvSUN },
-    { "glReplacementCodeuivSUN", "GL_SUN_triangle_list", glReplacementCodeuivSUN },
-    { "glReplacementCodeusSUN", "GL_SUN_triangle_list", glReplacementCodeusSUN },
-    { "glReplacementCodeusvSUN", "GL_SUN_triangle_list", glReplacementCodeusvSUN },
-    { "glRequestResidentProgramsNV", "GL_NV_vertex_program", glRequestResidentProgramsNV },
-    { "glResetHistogram", "GL_ARB_imaging", glResetHistogram },
-    { "glResetHistogramEXT", "GL_EXT_histogram", glResetHistogramEXT },
-    { "glResetMemoryObjectParameterNV", "GL_NV_memory_attachment", glResetMemoryObjectParameterNV },
-    { "glResetMinmax", "GL_ARB_imaging", glResetMinmax },
-    { "glResetMinmaxEXT", "GL_EXT_histogram", glResetMinmaxEXT },
-    { "glResizeBuffersMESA", "GL_MESA_resize_buffers", glResizeBuffersMESA },
-    { "glResolveDepthValuesNV", "GL_NV_sample_locations", glResolveDepthValuesNV },
-    { "glResumeTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0", glResumeTransformFeedback },
-    { "glResumeTransformFeedbackNV", "GL_NV_transform_feedback2", glResumeTransformFeedbackNV },
-    { "glRotatexOES", "GL_OES_fixed_point", glRotatexOES },
-    { "glSampleCoverage", "GL_VERSION_1_3", glSampleCoverage },
-    { "glSampleCoverageARB", "GL_ARB_multisample", glSampleCoverageARB },
-    { "glSampleMapATI", "GL_ATI_fragment_shader", glSampleMapATI },
-    { "glSampleMaskEXT", "GL_EXT_multisample", glSampleMaskEXT },
-    { "glSampleMaskIndexedNV", "GL_NV_explicit_multisample", glSampleMaskIndexedNV },
-    { "glSampleMaskSGIS", "GL_SGIS_multisample", glSampleMaskSGIS },
-    { "glSampleMaski", "GL_ARB_texture_multisample GL_VERSION_3_2", glSampleMaski },
-    { "glSamplePatternEXT", "GL_EXT_multisample", glSamplePatternEXT },
-    { "glSamplePatternSGIS", "GL_SGIS_multisample", glSamplePatternSGIS },
-    { "glSamplerParameterIiv", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameterIiv },
-    { "glSamplerParameterIuiv", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameterIuiv },
-    { "glSamplerParameterf", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameterf },
-    { "glSamplerParameterfv", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameterfv },
-    { "glSamplerParameteri", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameteri },
-    { "glSamplerParameteriv", "GL_ARB_sampler_objects GL_VERSION_3_3", glSamplerParameteriv },
-    { "glScalexOES", "GL_OES_fixed_point", glScalexOES },
-    { "glScissorArrayv", "GL_ARB_viewport_array GL_VERSION_4_1", glScissorArrayv },
-    { "glScissorExclusiveArrayvNV", "GL_NV_scissor_exclusive", glScissorExclusiveArrayvNV },
-    { "glScissorExclusiveNV", "GL_NV_scissor_exclusive", glScissorExclusiveNV },
-    { "glScissorIndexed", "GL_ARB_viewport_array GL_VERSION_4_1", glScissorIndexed },
-    { "glScissorIndexedv", "GL_ARB_viewport_array GL_VERSION_4_1", glScissorIndexedv },
-    { "glSecondaryColor3b", "GL_VERSION_1_4", glSecondaryColor3b },
-    { "glSecondaryColor3bEXT", "GL_EXT_secondary_color", glSecondaryColor3bEXT },
-    { "glSecondaryColor3bv", "GL_VERSION_1_4", glSecondaryColor3bv },
-    { "glSecondaryColor3bvEXT", "GL_EXT_secondary_color", glSecondaryColor3bvEXT },
-    { "glSecondaryColor3d", "GL_VERSION_1_4", glSecondaryColor3d },
-    { "glSecondaryColor3dEXT", "GL_EXT_secondary_color", glSecondaryColor3dEXT },
-    { "glSecondaryColor3dv", "GL_VERSION_1_4", glSecondaryColor3dv },
-    { "glSecondaryColor3dvEXT", "GL_EXT_secondary_color", glSecondaryColor3dvEXT },
-    { "glSecondaryColor3f", "GL_VERSION_1_4", glSecondaryColor3f },
-    { "glSecondaryColor3fEXT", "GL_EXT_secondary_color", glSecondaryColor3fEXT },
-    { "glSecondaryColor3fv", "GL_VERSION_1_4", glSecondaryColor3fv },
-    { "glSecondaryColor3fvEXT", "GL_EXT_secondary_color", glSecondaryColor3fvEXT },
-    { "glSecondaryColor3hNV", "GL_NV_half_float", glSecondaryColor3hNV },
-    { "glSecondaryColor3hvNV", "GL_NV_half_float", glSecondaryColor3hvNV },
-    { "glSecondaryColor3i", "GL_VERSION_1_4", glSecondaryColor3i },
-    { "glSecondaryColor3iEXT", "GL_EXT_secondary_color", glSecondaryColor3iEXT },
-    { "glSecondaryColor3iv", "GL_VERSION_1_4", glSecondaryColor3iv },
-    { "glSecondaryColor3ivEXT", "GL_EXT_secondary_color", glSecondaryColor3ivEXT },
-    { "glSecondaryColor3s", "GL_VERSION_1_4", glSecondaryColor3s },
-    { "glSecondaryColor3sEXT", "GL_EXT_secondary_color", glSecondaryColor3sEXT },
-    { "glSecondaryColor3sv", "GL_VERSION_1_4", glSecondaryColor3sv },
-    { "glSecondaryColor3svEXT", "GL_EXT_secondary_color", glSecondaryColor3svEXT },
-    { "glSecondaryColor3ub", "GL_VERSION_1_4", glSecondaryColor3ub },
-    { "glSecondaryColor3ubEXT", "GL_EXT_secondary_color", glSecondaryColor3ubEXT },
-    { "glSecondaryColor3ubv", "GL_VERSION_1_4", glSecondaryColor3ubv },
-    { "glSecondaryColor3ubvEXT", "GL_EXT_secondary_color", glSecondaryColor3ubvEXT },
-    { "glSecondaryColor3ui", "GL_VERSION_1_4", glSecondaryColor3ui },
-    { "glSecondaryColor3uiEXT", "GL_EXT_secondary_color", glSecondaryColor3uiEXT },
-    { "glSecondaryColor3uiv", "GL_VERSION_1_4", glSecondaryColor3uiv },
-    { "glSecondaryColor3uivEXT", "GL_EXT_secondary_color", glSecondaryColor3uivEXT },
-    { "glSecondaryColor3us", "GL_VERSION_1_4", glSecondaryColor3us },
-    { "glSecondaryColor3usEXT", "GL_EXT_secondary_color", glSecondaryColor3usEXT },
-    { "glSecondaryColor3usv", "GL_VERSION_1_4", glSecondaryColor3usv },
-    { "glSecondaryColor3usvEXT", "GL_EXT_secondary_color", glSecondaryColor3usvEXT },
-    { "glSecondaryColorFormatNV", "GL_NV_vertex_buffer_unified_memory", glSecondaryColorFormatNV },
-    { "glSecondaryColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glSecondaryColorP3ui },
-    { "glSecondaryColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glSecondaryColorP3uiv },
-    { "glSecondaryColorPointer", "GL_VERSION_1_4", glSecondaryColorPointer },
-    { "glSecondaryColorPointerEXT", "GL_EXT_secondary_color", glSecondaryColorPointerEXT },
-    { "glSecondaryColorPointerListIBM", "GL_IBM_vertex_array_lists", glSecondaryColorPointerListIBM },
-    { "glSelectPerfMonitorCountersAMD", "GL_AMD_performance_monitor", glSelectPerfMonitorCountersAMD },
-    { "glSelectTextureCoordSetSGIS", "GL_SGIS_multitexture", glSelectTextureCoordSetSGIS },
-    { "glSelectTextureSGIS", "GL_SGIS_multitexture", glSelectTextureSGIS },
-    { "glSemaphoreParameterui64vEXT", "GL_EXT_semaphore", glSemaphoreParameterui64vEXT },
-    { "glSeparableFilter2D", "GL_ARB_imaging", glSeparableFilter2D },
-    { "glSeparableFilter2DEXT", "GL_EXT_convolution", glSeparableFilter2DEXT },
-    { "glSetFenceAPPLE", "GL_APPLE_fence", glSetFenceAPPLE },
-    { "glSetFenceNV", "GL_NV_fence", glSetFenceNV },
-    { "glSetFragmentShaderConstantATI", "GL_ATI_fragment_shader", glSetFragmentShaderConstantATI },
-    { "glSetInvariantEXT", "GL_EXT_vertex_shader", glSetInvariantEXT },
-    { "glSetLocalConstantEXT", "GL_EXT_vertex_shader", glSetLocalConstantEXT },
-    { "glSetMultisamplefvAMD", "GL_AMD_sample_positions", glSetMultisamplefvAMD },
-    { "glShaderBinary", "GL_ARB_ES2_compatibility GL_VERSION_4_1", glShaderBinary },
-    { "glShaderOp1EXT", "GL_EXT_vertex_shader", glShaderOp1EXT },
-    { "glShaderOp2EXT", "GL_EXT_vertex_shader", glShaderOp2EXT },
-    { "glShaderOp3EXT", "GL_EXT_vertex_shader", glShaderOp3EXT },
-    { "glShaderSource", "GL_VERSION_2_0", glShaderSource },
-    { "glShaderSourceARB", "GL_ARB_shader_objects", glShaderSourceARB },
-    { "glShaderStorageBlockBinding", "GL_ARB_shader_storage_buffer_object GL_VERSION_4_3", glShaderStorageBlockBinding },
-    { "glShadingRateImageBarrierNV", "GL_NV_shading_rate_image GL_NV_shading_rate_image", glShadingRateImageBarrierNV },
-    { "glShadingRateImagePaletteNV", "GL_NV_shading_rate_image", glShadingRateImagePaletteNV },
-    { "glShadingRateSampleOrderCustomNV", "GL_NV_shading_rate_image", glShadingRateSampleOrderCustomNV },
-    { "glShadingRateSampleOrderNV", "GL_NV_shading_rate_image", glShadingRateSampleOrderNV },
-    { "glSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture", glSharpenTexFuncSGIS },
-    { "glSignalSemaphoreEXT", "GL_EXT_semaphore", glSignalSemaphoreEXT },
-    { "glSignalSemaphoreui64NVX", "GL_NVX_progress_fence", glSignalSemaphoreui64NVX },
-    { "glSignalVkFenceNV", "GL_NV_draw_vulkan_image", glSignalVkFenceNV },
-    { "glSignalVkSemaphoreNV", "GL_NV_draw_vulkan_image", glSignalVkSemaphoreNV },
-    { "glSpecializeShader", "GL_VERSION_4_6", glSpecializeShader },
-    { "glSpecializeShaderARB", "GL_ARB_gl_spirv", glSpecializeShaderARB },
-    { "glSpriteParameterfSGIX", "GL_SGIX_sprite", glSpriteParameterfSGIX },
-    { "glSpriteParameterfvSGIX", "GL_SGIX_sprite", glSpriteParameterfvSGIX },
-    { "glSpriteParameteriSGIX", "GL_SGIX_sprite", glSpriteParameteriSGIX },
-    { "glSpriteParameterivSGIX", "GL_SGIX_sprite", glSpriteParameterivSGIX },
-    { "glStartInstrumentsSGIX", "GL_SGIX_instruments", glStartInstrumentsSGIX },
-    { "glStateCaptureNV", "GL_NV_command_list", glStateCaptureNV },
-    { "glStencilClearTagEXT", "GL_EXT_stencil_clear_tag", glStencilClearTagEXT },
-    { "glStencilFillPathInstancedNV", "GL_NV_path_rendering", glStencilFillPathInstancedNV },
-    { "glStencilFillPathNV", "GL_NV_path_rendering", glStencilFillPathNV },
-    { "glStencilFuncSeparate", "GL_VERSION_2_0", glStencilFuncSeparate },
-    { "glStencilFuncSeparateATI", "GL_ATI_separate_stencil", glStencilFuncSeparateATI },
-    { "glStencilMaskSeparate", "GL_VERSION_2_0", glStencilMaskSeparate },
-    { "glStencilOpSeparate", "GL_VERSION_2_0", glStencilOpSeparate },
-    { "glStencilOpSeparateATI", "GL_ATI_separate_stencil", glStencilOpSeparateATI },
-    { "glStencilOpValueAMD", "GL_AMD_stencil_operation_extended", glStencilOpValueAMD },
-    { "glStencilStrokePathInstancedNV", "GL_NV_path_rendering", glStencilStrokePathInstancedNV },
-    { "glStencilStrokePathNV", "GL_NV_path_rendering", glStencilStrokePathNV },
-    { "glStencilThenCoverFillPathInstancedNV", "GL_NV_path_rendering", glStencilThenCoverFillPathInstancedNV },
-    { "glStencilThenCoverFillPathNV", "GL_NV_path_rendering", glStencilThenCoverFillPathNV },
-    { "glStencilThenCoverStrokePathInstancedNV", "GL_NV_path_rendering", glStencilThenCoverStrokePathInstancedNV },
-    { "glStencilThenCoverStrokePathNV", "GL_NV_path_rendering", glStencilThenCoverStrokePathNV },
-    { "glStopInstrumentsSGIX", "GL_SGIX_instruments", glStopInstrumentsSGIX },
-    { "glStringMarkerGREMEDY", "GL_GREMEDY_string_marker", glStringMarkerGREMEDY },
-    { "glSubpixelPrecisionBiasNV", "GL_NV_conservative_raster", glSubpixelPrecisionBiasNV },
-    { "glSwizzleEXT", "GL_EXT_vertex_shader", glSwizzleEXT },
-    { "glSyncTextureINTEL", "GL_INTEL_map_texture", glSyncTextureINTEL },
-    { "glTagSampleBufferSGIX", "GL_SGIX_tag_sample_buffer", glTagSampleBufferSGIX },
-    { "glTangent3bEXT", "GL_EXT_coordinate_frame", glTangent3bEXT },
-    { "glTangent3bvEXT", "GL_EXT_coordinate_frame", glTangent3bvEXT },
-    { "glTangent3dEXT", "GL_EXT_coordinate_frame", glTangent3dEXT },
-    { "glTangent3dvEXT", "GL_EXT_coordinate_frame", glTangent3dvEXT },
-    { "glTangent3fEXT", "GL_EXT_coordinate_frame", glTangent3fEXT },
-    { "glTangent3fvEXT", "GL_EXT_coordinate_frame", glTangent3fvEXT },
-    { "glTangent3iEXT", "GL_EXT_coordinate_frame", glTangent3iEXT },
-    { "glTangent3ivEXT", "GL_EXT_coordinate_frame", glTangent3ivEXT },
-    { "glTangent3sEXT", "GL_EXT_coordinate_frame", glTangent3sEXT },
-    { "glTangent3svEXT", "GL_EXT_coordinate_frame", glTangent3svEXT },
-    { "glTangentPointerEXT", "GL_EXT_coordinate_frame", glTangentPointerEXT },
-    { "glTbufferMask3DFX", "GL_3DFX_tbuffer", glTbufferMask3DFX },
-    { "glTessellationFactorAMD", "GL_AMD_vertex_shader_tessellator", glTessellationFactorAMD },
-    { "glTessellationModeAMD", "GL_AMD_vertex_shader_tessellator", glTessellationModeAMD },
-    { "glTestFenceAPPLE", "GL_APPLE_fence", glTestFenceAPPLE },
-    { "glTestFenceNV", "GL_NV_fence", glTestFenceNV },
-    { "glTestObjectAPPLE", "GL_APPLE_fence", glTestObjectAPPLE },
-    { "glTexAttachMemoryNV", "GL_NV_memory_attachment", glTexAttachMemoryNV },
-    { "glTexBuffer", "GL_VERSION_3_1", glTexBuffer },
-    { "glTexBufferARB", "GL_ARB_texture_buffer_object", glTexBufferARB },
-    { "glTexBufferEXT", "GL_EXT_texture_buffer_object", glTexBufferEXT },
-    { "glTexBufferRange", "GL_ARB_texture_buffer_range GL_VERSION_4_3", glTexBufferRange },
-    { "glTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap", glTexBumpParameterfvATI },
-    { "glTexBumpParameterivATI", "GL_ATI_envmap_bumpmap", glTexBumpParameterivATI },
-    { "glTexCoord1bOES", "GL_OES_byte_coordinates", glTexCoord1bOES },
-    { "glTexCoord1bvOES", "GL_OES_byte_coordinates", glTexCoord1bvOES },
-    { "glTexCoord1hNV", "GL_NV_half_float", glTexCoord1hNV },
-    { "glTexCoord1hvNV", "GL_NV_half_float", glTexCoord1hvNV },
-    { "glTexCoord1xOES", "GL_OES_fixed_point", glTexCoord1xOES },
-    { "glTexCoord1xvOES", "GL_OES_fixed_point", glTexCoord1xvOES },
-    { "glTexCoord2bOES", "GL_OES_byte_coordinates", glTexCoord2bOES },
-    { "glTexCoord2bvOES", "GL_OES_byte_coordinates", glTexCoord2bvOES },
-    { "glTexCoord2fColor3fVertex3fSUN", "GL_SUN_vertex", glTexCoord2fColor3fVertex3fSUN },
-    { "glTexCoord2fColor3fVertex3fvSUN", "GL_SUN_vertex", glTexCoord2fColor3fVertex3fvSUN },
-    { "glTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex", glTexCoord2fColor4fNormal3fVertex3fSUN },
-    { "glTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex", glTexCoord2fColor4fNormal3fVertex3fvSUN },
-    { "glTexCoord2fColor4ubVertex3fSUN", "GL_SUN_vertex", glTexCoord2fColor4ubVertex3fSUN },
-    { "glTexCoord2fColor4ubVertex3fvSUN", "GL_SUN_vertex", glTexCoord2fColor4ubVertex3fvSUN },
-    { "glTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex", glTexCoord2fNormal3fVertex3fSUN },
-    { "glTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex", glTexCoord2fNormal3fVertex3fvSUN },
-    { "glTexCoord2fVertex3fSUN", "GL_SUN_vertex", glTexCoord2fVertex3fSUN },
-    { "glTexCoord2fVertex3fvSUN", "GL_SUN_vertex", glTexCoord2fVertex3fvSUN },
-    { "glTexCoord2hNV", "GL_NV_half_float", glTexCoord2hNV },
-    { "glTexCoord2hvNV", "GL_NV_half_float", glTexCoord2hvNV },
-    { "glTexCoord2xOES", "GL_OES_fixed_point", glTexCoord2xOES },
-    { "glTexCoord2xvOES", "GL_OES_fixed_point", glTexCoord2xvOES },
-    { "glTexCoord3bOES", "GL_OES_byte_coordinates", glTexCoord3bOES },
-    { "glTexCoord3bvOES", "GL_OES_byte_coordinates", glTexCoord3bvOES },
-    { "glTexCoord3hNV", "GL_NV_half_float", glTexCoord3hNV },
-    { "glTexCoord3hvNV", "GL_NV_half_float", glTexCoord3hvNV },
-    { "glTexCoord3xOES", "GL_OES_fixed_point", glTexCoord3xOES },
-    { "glTexCoord3xvOES", "GL_OES_fixed_point", glTexCoord3xvOES },
-    { "glTexCoord4bOES", "GL_OES_byte_coordinates", glTexCoord4bOES },
-    { "glTexCoord4bvOES", "GL_OES_byte_coordinates", glTexCoord4bvOES },
-    { "glTexCoord4fColor4fNormal3fVertex4fSUN", "GL_SUN_vertex", glTexCoord4fColor4fNormal3fVertex4fSUN },
-    { "glTexCoord4fColor4fNormal3fVertex4fvSUN", "GL_SUN_vertex", glTexCoord4fColor4fNormal3fVertex4fvSUN },
-    { "glTexCoord4fVertex4fSUN", "GL_SUN_vertex", glTexCoord4fVertex4fSUN },
-    { "glTexCoord4fVertex4fvSUN", "GL_SUN_vertex", glTexCoord4fVertex4fvSUN },
-    { "glTexCoord4hNV", "GL_NV_half_float", glTexCoord4hNV },
-    { "glTexCoord4hvNV", "GL_NV_half_float", glTexCoord4hvNV },
-    { "glTexCoord4xOES", "GL_OES_fixed_point", glTexCoord4xOES },
-    { "glTexCoord4xvOES", "GL_OES_fixed_point", glTexCoord4xvOES },
-    { "glTexCoordFormatNV", "GL_NV_vertex_buffer_unified_memory", glTexCoordFormatNV },
-    { "glTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP1ui },
-    { "glTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP1uiv },
-    { "glTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP2ui },
-    { "glTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP2uiv },
-    { "glTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP3ui },
-    { "glTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP3uiv },
-    { "glTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP4ui },
-    { "glTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glTexCoordP4uiv },
-    { "glTexCoordPointerEXT", "GL_EXT_vertex_array", glTexCoordPointerEXT },
-    { "glTexCoordPointerListIBM", "GL_IBM_vertex_array_lists", glTexCoordPointerListIBM },
-    { "glTexCoordPointervINTEL", "GL_INTEL_parallel_arrays", glTexCoordPointervINTEL },
-    { "glTexEnvxOES", "GL_OES_fixed_point", glTexEnvxOES },
-    { "glTexEnvxvOES", "GL_OES_fixed_point", glTexEnvxvOES },
-    { "glTexFilterFuncSGIS", "GL_SGIS_texture_filter4", glTexFilterFuncSGIS },
-    { "glTexGenxOES", "GL_OES_fixed_point", glTexGenxOES },
-    { "glTexGenxvOES", "GL_OES_fixed_point", glTexGenxvOES },
-    { "glTexImage2DMultisample", "GL_ARB_texture_multisample GL_VERSION_3_2", glTexImage2DMultisample },
-    { "glTexImage2DMultisampleCoverageNV", "GL_NV_texture_multisample", glTexImage2DMultisampleCoverageNV },
-    { "glTexImage3D", "GL_VERSION_1_2", glTexImage3D },
-    { "glTexImage3DEXT", "GL_EXT_texture3D", glTexImage3DEXT },
-    { "glTexImage3DMultisample", "GL_ARB_texture_multisample GL_VERSION_3_2", glTexImage3DMultisample },
-    { "glTexImage3DMultisampleCoverageNV", "GL_NV_texture_multisample", glTexImage3DMultisampleCoverageNV },
-    { "glTexImage4DSGIS", "GL_SGIS_texture4D", glTexImage4DSGIS },
-    { "glTexPageCommitmentARB", "GL_ARB_sparse_texture", glTexPageCommitmentARB },
-    { "glTexParameterIiv", "GL_VERSION_3_0", glTexParameterIiv },
-    { "glTexParameterIivEXT", "GL_EXT_texture_integer", glTexParameterIivEXT },
-    { "glTexParameterIuiv", "GL_VERSION_3_0", glTexParameterIuiv },
-    { "glTexParameterIuivEXT", "GL_EXT_texture_integer", glTexParameterIuivEXT },
-    { "glTexParameterxOES", "GL_OES_fixed_point", glTexParameterxOES },
-    { "glTexParameterxvOES", "GL_OES_fixed_point", glTexParameterxvOES },
-    { "glTexRenderbufferNV", "GL_NV_explicit_multisample", glTexRenderbufferNV },
-    { "glTexStorage1D", "GL_ARB_texture_storage GL_VERSION_4_2", glTexStorage1D },
-    { "glTexStorage2D", "GL_ARB_texture_storage GL_VERSION_4_2", glTexStorage2D },
-    { "glTexStorage2DMultisample", "GL_ARB_texture_storage_multisample GL_VERSION_4_3", glTexStorage2DMultisample },
-    { "glTexStorage3D", "GL_ARB_texture_storage GL_VERSION_4_2", glTexStorage3D },
-    { "glTexStorage3DMultisample", "GL_ARB_texture_storage_multisample GL_VERSION_4_3", glTexStorage3DMultisample },
-    { "glTexStorageMem1DEXT", "GL_EXT_memory_object", glTexStorageMem1DEXT },
-    { "glTexStorageMem2DEXT", "GL_EXT_memory_object", glTexStorageMem2DEXT },
-    { "glTexStorageMem2DMultisampleEXT", "GL_EXT_memory_object", glTexStorageMem2DMultisampleEXT },
-    { "glTexStorageMem3DEXT", "GL_EXT_memory_object", glTexStorageMem3DEXT },
-    { "glTexStorageMem3DMultisampleEXT", "GL_EXT_memory_object", glTexStorageMem3DMultisampleEXT },
-    { "glTexStorageSparseAMD", "GL_AMD_sparse_texture", glTexStorageSparseAMD },
-    { "glTexSubImage1DEXT", "GL_EXT_subtexture", glTexSubImage1DEXT },
-    { "glTexSubImage2DEXT", "GL_EXT_subtexture", glTexSubImage2DEXT },
-    { "glTexSubImage3D", "GL_VERSION_1_2", glTexSubImage3D },
-    { "glTexSubImage3DEXT", "GL_EXT_texture3D", glTexSubImage3DEXT },
-    { "glTexSubImage4DSGIS", "GL_SGIS_texture4D", glTexSubImage4DSGIS },
-    { "glTextureAttachMemoryNV", "GL_NV_memory_attachment", glTextureAttachMemoryNV },
-    { "glTextureBarrier", "GL_ARB_texture_barrier GL_VERSION_4_5", glTextureBarrier },
-    { "glTextureBarrierNV", "GL_NV_texture_barrier", glTextureBarrierNV },
-    { "glTextureBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureBuffer },
-    { "glTextureBufferEXT", "GL_EXT_direct_state_access", glTextureBufferEXT },
-    { "glTextureBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureBufferRange },
-    { "glTextureBufferRangeEXT", "GL_EXT_direct_state_access", glTextureBufferRangeEXT },
-    { "glTextureColorMaskSGIS", "GL_SGIS_texture_color_mask", glTextureColorMaskSGIS },
-    { "glTextureImage1DEXT", "GL_EXT_direct_state_access", glTextureImage1DEXT },
-    { "glTextureImage2DEXT", "GL_EXT_direct_state_access", glTextureImage2DEXT },
-    { "glTextureImage2DMultisampleCoverageNV", "GL_NV_texture_multisample", glTextureImage2DMultisampleCoverageNV },
-    { "glTextureImage2DMultisampleNV", "GL_NV_texture_multisample", glTextureImage2DMultisampleNV },
-    { "glTextureImage3DEXT", "GL_EXT_direct_state_access", glTextureImage3DEXT },
-    { "glTextureImage3DMultisampleCoverageNV", "GL_NV_texture_multisample", glTextureImage3DMultisampleCoverageNV },
-    { "glTextureImage3DMultisampleNV", "GL_NV_texture_multisample", glTextureImage3DMultisampleNV },
-    { "glTextureLightEXT", "GL_EXT_light_texture", glTextureLightEXT },
-    { "glTextureMaterialEXT", "GL_EXT_light_texture", glTextureMaterialEXT },
-    { "glTextureNormalEXT", "GL_EXT_texture_perturb_normal", glTextureNormalEXT },
-    { "glTexturePageCommitmentEXT", "GL_EXT_direct_state_access", glTexturePageCommitmentEXT },
-    { "glTextureParameterIiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameterIiv },
-    { "glTextureParameterIivEXT", "GL_EXT_direct_state_access", glTextureParameterIivEXT },
-    { "glTextureParameterIuiv", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameterIuiv },
-    { "glTextureParameterIuivEXT", "GL_EXT_direct_state_access", glTextureParameterIuivEXT },
-    { "glTextureParameterf", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameterf },
-    { "glTextureParameterfEXT", "GL_EXT_direct_state_access", glTextureParameterfEXT },
-    { "glTextureParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameterfv },
-    { "glTextureParameterfvEXT", "GL_EXT_direct_state_access", glTextureParameterfvEXT },
-    { "glTextureParameteri", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameteri },
-    { "glTextureParameteriEXT", "GL_EXT_direct_state_access", glTextureParameteriEXT },
-    { "glTextureParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureParameteriv },
-    { "glTextureParameterivEXT", "GL_EXT_direct_state_access", glTextureParameterivEXT },
-    { "glTextureRangeAPPLE", "GL_APPLE_texture_range", glTextureRangeAPPLE },
-    { "glTextureRenderbufferEXT", "GL_EXT_direct_state_access", glTextureRenderbufferEXT },
-    { "glTextureStorage1D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureStorage1D },
-    { "glTextureStorage1DEXT", "GL_EXT_direct_state_access", glTextureStorage1DEXT },
-    { "glTextureStorage2D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureStorage2D },
-    { "glTextureStorage2DEXT", "GL_EXT_direct_state_access", glTextureStorage2DEXT },
-    { "glTextureStorage2DMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureStorage2DMultisample },
-    { "glTextureStorage2DMultisampleEXT", "GL_EXT_direct_state_access", glTextureStorage2DMultisampleEXT },
-    { "glTextureStorage3D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureStorage3D },
-    { "glTextureStorage3DEXT", "GL_EXT_direct_state_access", glTextureStorage3DEXT },
-    { "glTextureStorage3DMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureStorage3DMultisample },
-    { "glTextureStorage3DMultisampleEXT", "GL_EXT_direct_state_access", glTextureStorage3DMultisampleEXT },
-    { "glTextureStorageMem1DEXT", "GL_EXT_memory_object", glTextureStorageMem1DEXT },
-    { "glTextureStorageMem2DEXT", "GL_EXT_memory_object", glTextureStorageMem2DEXT },
-    { "glTextureStorageMem2DMultisampleEXT", "GL_EXT_memory_object", glTextureStorageMem2DMultisampleEXT },
-    { "glTextureStorageMem3DEXT", "GL_EXT_memory_object", glTextureStorageMem3DEXT },
-    { "glTextureStorageMem3DMultisampleEXT", "GL_EXT_memory_object", glTextureStorageMem3DMultisampleEXT },
-    { "glTextureStorageSparseAMD", "GL_AMD_sparse_texture", glTextureStorageSparseAMD },
-    { "glTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureSubImage1D },
-    { "glTextureSubImage1DEXT", "GL_EXT_direct_state_access", glTextureSubImage1DEXT },
-    { "glTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureSubImage2D },
-    { "glTextureSubImage2DEXT", "GL_EXT_direct_state_access", glTextureSubImage2DEXT },
-    { "glTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5", glTextureSubImage3D },
-    { "glTextureSubImage3DEXT", "GL_EXT_direct_state_access", glTextureSubImage3DEXT },
-    { "glTextureView", "GL_ARB_texture_view GL_VERSION_4_3", glTextureView },
-    { "glTrackMatrixNV", "GL_NV_vertex_program", glTrackMatrixNV },
-    { "glTransformFeedbackAttribsNV", "GL_NV_transform_feedback", glTransformFeedbackAttribsNV },
-    { "glTransformFeedbackBufferBase", "GL_ARB_direct_state_access GL_VERSION_4_5", glTransformFeedbackBufferBase },
-    { "glTransformFeedbackBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5", glTransformFeedbackBufferRange },
-    { "glTransformFeedbackStreamAttribsNV", "GL_NV_transform_feedback", glTransformFeedbackStreamAttribsNV },
-    { "glTransformFeedbackVaryings", "GL_VERSION_3_0", glTransformFeedbackVaryings },
-    { "glTransformFeedbackVaryingsEXT", "GL_EXT_transform_feedback", glTransformFeedbackVaryingsEXT },
-    { "glTransformFeedbackVaryingsNV", "GL_NV_transform_feedback", glTransformFeedbackVaryingsNV },
-    { "glTransformPathNV", "GL_NV_path_rendering", glTransformPathNV },
-    { "glTranslatexOES", "GL_OES_fixed_point", glTranslatexOES },
-    { "glUniform1d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform1d },
-    { "glUniform1dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform1dv },
-    { "glUniform1f", "GL_VERSION_2_0", glUniform1f },
-    { "glUniform1fARB", "GL_ARB_shader_objects", glUniform1fARB },
-    { "glUniform1fv", "GL_VERSION_2_0", glUniform1fv },
-    { "glUniform1fvARB", "GL_ARB_shader_objects", glUniform1fvARB },
-    { "glUniform1i", "GL_VERSION_2_0", glUniform1i },
-    { "glUniform1i64ARB", "GL_ARB_gpu_shader_int64", glUniform1i64ARB },
-    { "glUniform1i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform1i64NV },
-    { "glUniform1i64vARB", "GL_ARB_gpu_shader_int64", glUniform1i64vARB },
-    { "glUniform1i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform1i64vNV },
-    { "glUniform1iARB", "GL_ARB_shader_objects", glUniform1iARB },
-    { "glUniform1iv", "GL_VERSION_2_0", glUniform1iv },
-    { "glUniform1ivARB", "GL_ARB_shader_objects", glUniform1ivARB },
-    { "glUniform1ui", "GL_VERSION_3_0", glUniform1ui },
-    { "glUniform1ui64ARB", "GL_ARB_gpu_shader_int64", glUniform1ui64ARB },
-    { "glUniform1ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform1ui64NV },
-    { "glUniform1ui64vARB", "GL_ARB_gpu_shader_int64", glUniform1ui64vARB },
-    { "glUniform1ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform1ui64vNV },
-    { "glUniform1uiEXT", "GL_EXT_gpu_shader4", glUniform1uiEXT },
-    { "glUniform1uiv", "GL_VERSION_3_0", glUniform1uiv },
-    { "glUniform1uivEXT", "GL_EXT_gpu_shader4", glUniform1uivEXT },
-    { "glUniform2d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform2d },
-    { "glUniform2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform2dv },
-    { "glUniform2f", "GL_VERSION_2_0", glUniform2f },
-    { "glUniform2fARB", "GL_ARB_shader_objects", glUniform2fARB },
-    { "glUniform2fv", "GL_VERSION_2_0", glUniform2fv },
-    { "glUniform2fvARB", "GL_ARB_shader_objects", glUniform2fvARB },
-    { "glUniform2i", "GL_VERSION_2_0", glUniform2i },
-    { "glUniform2i64ARB", "GL_ARB_gpu_shader_int64", glUniform2i64ARB },
-    { "glUniform2i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform2i64NV },
-    { "glUniform2i64vARB", "GL_ARB_gpu_shader_int64", glUniform2i64vARB },
-    { "glUniform2i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform2i64vNV },
-    { "glUniform2iARB", "GL_ARB_shader_objects", glUniform2iARB },
-    { "glUniform2iv", "GL_VERSION_2_0", glUniform2iv },
-    { "glUniform2ivARB", "GL_ARB_shader_objects", glUniform2ivARB },
-    { "glUniform2ui", "GL_VERSION_3_0", glUniform2ui },
-    { "glUniform2ui64ARB", "GL_ARB_gpu_shader_int64", glUniform2ui64ARB },
-    { "glUniform2ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform2ui64NV },
-    { "glUniform2ui64vARB", "GL_ARB_gpu_shader_int64", glUniform2ui64vARB },
-    { "glUniform2ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform2ui64vNV },
-    { "glUniform2uiEXT", "GL_EXT_gpu_shader4", glUniform2uiEXT },
-    { "glUniform2uiv", "GL_VERSION_3_0", glUniform2uiv },
-    { "glUniform2uivEXT", "GL_EXT_gpu_shader4", glUniform2uivEXT },
-    { "glUniform3d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform3d },
-    { "glUniform3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform3dv },
-    { "glUniform3f", "GL_VERSION_2_0", glUniform3f },
-    { "glUniform3fARB", "GL_ARB_shader_objects", glUniform3fARB },
-    { "glUniform3fv", "GL_VERSION_2_0", glUniform3fv },
-    { "glUniform3fvARB", "GL_ARB_shader_objects", glUniform3fvARB },
-    { "glUniform3i", "GL_VERSION_2_0", glUniform3i },
-    { "glUniform3i64ARB", "GL_ARB_gpu_shader_int64", glUniform3i64ARB },
-    { "glUniform3i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform3i64NV },
-    { "glUniform3i64vARB", "GL_ARB_gpu_shader_int64", glUniform3i64vARB },
-    { "glUniform3i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform3i64vNV },
-    { "glUniform3iARB", "GL_ARB_shader_objects", glUniform3iARB },
-    { "glUniform3iv", "GL_VERSION_2_0", glUniform3iv },
-    { "glUniform3ivARB", "GL_ARB_shader_objects", glUniform3ivARB },
-    { "glUniform3ui", "GL_VERSION_3_0", glUniform3ui },
-    { "glUniform3ui64ARB", "GL_ARB_gpu_shader_int64", glUniform3ui64ARB },
-    { "glUniform3ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform3ui64NV },
-    { "glUniform3ui64vARB", "GL_ARB_gpu_shader_int64", glUniform3ui64vARB },
-    { "glUniform3ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform3ui64vNV },
-    { "glUniform3uiEXT", "GL_EXT_gpu_shader4", glUniform3uiEXT },
-    { "glUniform3uiv", "GL_VERSION_3_0", glUniform3uiv },
-    { "glUniform3uivEXT", "GL_EXT_gpu_shader4", glUniform3uivEXT },
-    { "glUniform4d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform4d },
-    { "glUniform4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniform4dv },
-    { "glUniform4f", "GL_VERSION_2_0", glUniform4f },
-    { "glUniform4fARB", "GL_ARB_shader_objects", glUniform4fARB },
-    { "glUniform4fv", "GL_VERSION_2_0", glUniform4fv },
-    { "glUniform4fvARB", "GL_ARB_shader_objects", glUniform4fvARB },
-    { "glUniform4i", "GL_VERSION_2_0", glUniform4i },
-    { "glUniform4i64ARB", "GL_ARB_gpu_shader_int64", glUniform4i64ARB },
-    { "glUniform4i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform4i64NV },
-    { "glUniform4i64vARB", "GL_ARB_gpu_shader_int64", glUniform4i64vARB },
-    { "glUniform4i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform4i64vNV },
-    { "glUniform4iARB", "GL_ARB_shader_objects", glUniform4iARB },
-    { "glUniform4iv", "GL_VERSION_2_0", glUniform4iv },
-    { "glUniform4ivARB", "GL_ARB_shader_objects", glUniform4ivARB },
-    { "glUniform4ui", "GL_VERSION_3_0", glUniform4ui },
-    { "glUniform4ui64ARB", "GL_ARB_gpu_shader_int64", glUniform4ui64ARB },
-    { "glUniform4ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform4ui64NV },
-    { "glUniform4ui64vARB", "GL_ARB_gpu_shader_int64", glUniform4ui64vARB },
-    { "glUniform4ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5", glUniform4ui64vNV },
-    { "glUniform4uiEXT", "GL_EXT_gpu_shader4", glUniform4uiEXT },
-    { "glUniform4uiv", "GL_VERSION_3_0", glUniform4uiv },
-    { "glUniform4uivEXT", "GL_EXT_gpu_shader4", glUniform4uivEXT },
-    { "glUniformBlockBinding", "GL_ARB_uniform_buffer_object GL_VERSION_3_1", glUniformBlockBinding },
-    { "glUniformBufferEXT", "GL_EXT_bindable_uniform", glUniformBufferEXT },
-    { "glUniformHandleui64ARB", "GL_ARB_bindless_texture", glUniformHandleui64ARB },
-    { "glUniformHandleui64NV", "GL_NV_bindless_texture", glUniformHandleui64NV },
-    { "glUniformHandleui64vARB", "GL_ARB_bindless_texture", glUniformHandleui64vARB },
-    { "glUniformHandleui64vNV", "GL_NV_bindless_texture", glUniformHandleui64vNV },
-    { "glUniformMatrix2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix2dv },
-    { "glUniformMatrix2fv", "GL_VERSION_2_0", glUniformMatrix2fv },
-    { "glUniformMatrix2fvARB", "GL_ARB_shader_objects", glUniformMatrix2fvARB },
-    { "glUniformMatrix2x3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix2x3dv },
-    { "glUniformMatrix2x3fv", "GL_VERSION_2_1", glUniformMatrix2x3fv },
-    { "glUniformMatrix2x4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix2x4dv },
-    { "glUniformMatrix2x4fv", "GL_VERSION_2_1", glUniformMatrix2x4fv },
-    { "glUniformMatrix3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix3dv },
-    { "glUniformMatrix3fv", "GL_VERSION_2_0", glUniformMatrix3fv },
-    { "glUniformMatrix3fvARB", "GL_ARB_shader_objects", glUniformMatrix3fvARB },
-    { "glUniformMatrix3x2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix3x2dv },
-    { "glUniformMatrix3x2fv", "GL_VERSION_2_1", glUniformMatrix3x2fv },
-    { "glUniformMatrix3x4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix3x4dv },
-    { "glUniformMatrix3x4fv", "GL_VERSION_2_1", glUniformMatrix3x4fv },
-    { "glUniformMatrix4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix4dv },
-    { "glUniformMatrix4fv", "GL_VERSION_2_0", glUniformMatrix4fv },
-    { "glUniformMatrix4fvARB", "GL_ARB_shader_objects", glUniformMatrix4fvARB },
-    { "glUniformMatrix4x2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix4x2dv },
-    { "glUniformMatrix4x2fv", "GL_VERSION_2_1", glUniformMatrix4x2fv },
-    { "glUniformMatrix4x3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0", glUniformMatrix4x3dv },
-    { "glUniformMatrix4x3fv", "GL_VERSION_2_1", glUniformMatrix4x3fv },
-    { "glUniformSubroutinesuiv", "GL_ARB_shader_subroutine GL_VERSION_4_0", glUniformSubroutinesuiv },
-    { "glUniformui64NV", "GL_NV_shader_buffer_load", glUniformui64NV },
-    { "glUniformui64vNV", "GL_NV_shader_buffer_load", glUniformui64vNV },
-    { "glUnlockArraysEXT", "GL_EXT_compiled_vertex_array", glUnlockArraysEXT },
-    { "glUnmapBuffer", "GL_VERSION_1_5", glUnmapBuffer },
-    { "glUnmapBufferARB", "GL_ARB_vertex_buffer_object", glUnmapBufferARB },
-    { "glUnmapNamedBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glUnmapNamedBuffer },
-    { "glUnmapNamedBufferEXT", "GL_EXT_direct_state_access", glUnmapNamedBufferEXT },
-    { "glUnmapObjectBufferATI", "GL_ATI_map_object_buffer", glUnmapObjectBufferATI },
-    { "glUnmapTexture2DINTEL", "GL_INTEL_map_texture", glUnmapTexture2DINTEL },
-    { "glUpdateObjectBufferATI", "GL_ATI_vertex_array_object", glUpdateObjectBufferATI },
-    { "glUploadGpuMaskNVX", "GL_NVX_gpu_multicast2", glUploadGpuMaskNVX },
-    { "glUseProgram", "GL_VERSION_2_0", glUseProgram },
-    { "glUseProgramObjectARB", "GL_ARB_shader_objects", glUseProgramObjectARB },
-    { "glUseProgramStages", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glUseProgramStages },
-    { "glUseShaderProgramEXT", "GL_EXT_separate_shader_objects", glUseShaderProgramEXT },
-    { "glVDPAUFiniNV", "GL_NV_vdpau_interop", glVDPAUFiniNV },
-    { "glVDPAUGetSurfaceivNV", "GL_NV_vdpau_interop", glVDPAUGetSurfaceivNV },
-    { "glVDPAUInitNV", "GL_NV_vdpau_interop", glVDPAUInitNV },
-    { "glVDPAUIsSurfaceNV", "GL_NV_vdpau_interop", glVDPAUIsSurfaceNV },
-    { "glVDPAUMapSurfacesNV", "GL_NV_vdpau_interop", glVDPAUMapSurfacesNV },
-    { "glVDPAURegisterOutputSurfaceNV", "GL_NV_vdpau_interop", glVDPAURegisterOutputSurfaceNV },
-    { "glVDPAURegisterVideoSurfaceNV", "GL_NV_vdpau_interop", glVDPAURegisterVideoSurfaceNV },
-    { "glVDPAURegisterVideoSurfaceWithPictureStructureNV", "GL_NV_vdpau_interop2", glVDPAURegisterVideoSurfaceWithPictureStructureNV },
-    { "glVDPAUSurfaceAccessNV", "GL_NV_vdpau_interop", glVDPAUSurfaceAccessNV },
-    { "glVDPAUUnmapSurfacesNV", "GL_NV_vdpau_interop", glVDPAUUnmapSurfacesNV },
-    { "glVDPAUUnregisterSurfaceNV", "GL_NV_vdpau_interop", glVDPAUUnregisterSurfaceNV },
-    { "glValidateProgram", "GL_VERSION_2_0", glValidateProgram },
-    { "glValidateProgramARB", "GL_ARB_shader_objects", glValidateProgramARB },
-    { "glValidateProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1", glValidateProgramPipeline },
-    { "glVariantArrayObjectATI", "GL_ATI_vertex_array_object", glVariantArrayObjectATI },
-    { "glVariantPointerEXT", "GL_EXT_vertex_shader", glVariantPointerEXT },
-    { "glVariantbvEXT", "GL_EXT_vertex_shader", glVariantbvEXT },
-    { "glVariantdvEXT", "GL_EXT_vertex_shader", glVariantdvEXT },
-    { "glVariantfvEXT", "GL_EXT_vertex_shader", glVariantfvEXT },
-    { "glVariantivEXT", "GL_EXT_vertex_shader", glVariantivEXT },
-    { "glVariantsvEXT", "GL_EXT_vertex_shader", glVariantsvEXT },
-    { "glVariantubvEXT", "GL_EXT_vertex_shader", glVariantubvEXT },
-    { "glVariantuivEXT", "GL_EXT_vertex_shader", glVariantuivEXT },
-    { "glVariantusvEXT", "GL_EXT_vertex_shader", glVariantusvEXT },
-    { "glVertex2bOES", "GL_OES_byte_coordinates", glVertex2bOES },
-    { "glVertex2bvOES", "GL_OES_byte_coordinates", glVertex2bvOES },
-    { "glVertex2hNV", "GL_NV_half_float", glVertex2hNV },
-    { "glVertex2hvNV", "GL_NV_half_float", glVertex2hvNV },
-    { "glVertex2xOES", "GL_OES_fixed_point", glVertex2xOES },
-    { "glVertex2xvOES", "GL_OES_fixed_point", glVertex2xvOES },
-    { "glVertex3bOES", "GL_OES_byte_coordinates", glVertex3bOES },
-    { "glVertex3bvOES", "GL_OES_byte_coordinates", glVertex3bvOES },
-    { "glVertex3hNV", "GL_NV_half_float", glVertex3hNV },
-    { "glVertex3hvNV", "GL_NV_half_float", glVertex3hvNV },
-    { "glVertex3xOES", "GL_OES_fixed_point", glVertex3xOES },
-    { "glVertex3xvOES", "GL_OES_fixed_point", glVertex3xvOES },
-    { "glVertex4bOES", "GL_OES_byte_coordinates", glVertex4bOES },
-    { "glVertex4bvOES", "GL_OES_byte_coordinates", glVertex4bvOES },
-    { "glVertex4hNV", "GL_NV_half_float", glVertex4hNV },
-    { "glVertex4hvNV", "GL_NV_half_float", glVertex4hvNV },
-    { "glVertex4xOES", "GL_OES_fixed_point", glVertex4xOES },
-    { "glVertex4xvOES", "GL_OES_fixed_point", glVertex4xvOES },
-    { "glVertexArrayAttribBinding", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayAttribBinding },
-    { "glVertexArrayAttribFormat", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayAttribFormat },
-    { "glVertexArrayAttribIFormat", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayAttribIFormat },
-    { "glVertexArrayAttribLFormat", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayAttribLFormat },
-    { "glVertexArrayBindVertexBufferEXT", "GL_EXT_direct_state_access", glVertexArrayBindVertexBufferEXT },
-    { "glVertexArrayBindingDivisor", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayBindingDivisor },
-    { "glVertexArrayColorOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayColorOffsetEXT },
-    { "glVertexArrayEdgeFlagOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayEdgeFlagOffsetEXT },
-    { "glVertexArrayElementBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayElementBuffer },
-    { "glVertexArrayFogCoordOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayFogCoordOffsetEXT },
-    { "glVertexArrayIndexOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayIndexOffsetEXT },
-    { "glVertexArrayMultiTexCoordOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayMultiTexCoordOffsetEXT },
-    { "glVertexArrayNormalOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayNormalOffsetEXT },
-    { "glVertexArrayParameteriAPPLE", "GL_APPLE_vertex_array_range", glVertexArrayParameteriAPPLE },
-    { "glVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range", glVertexArrayRangeAPPLE },
-    { "glVertexArrayRangeNV", "GL_NV_vertex_array_range", glVertexArrayRangeNV },
-    { "glVertexArraySecondaryColorOffsetEXT", "GL_EXT_direct_state_access", glVertexArraySecondaryColorOffsetEXT },
-    { "glVertexArrayTexCoordOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayTexCoordOffsetEXT },
-    { "glVertexArrayVertexAttribBindingEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribBindingEXT },
-    { "glVertexArrayVertexAttribDivisorEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribDivisorEXT },
-    { "glVertexArrayVertexAttribFormatEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribFormatEXT },
-    { "glVertexArrayVertexAttribIFormatEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribIFormatEXT },
-    { "glVertexArrayVertexAttribIOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribIOffsetEXT },
-    { "glVertexArrayVertexAttribLFormatEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribLFormatEXT },
-    { "glVertexArrayVertexAttribLOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribLOffsetEXT },
-    { "glVertexArrayVertexAttribOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayVertexAttribOffsetEXT },
-    { "glVertexArrayVertexBindingDivisorEXT", "GL_EXT_direct_state_access", glVertexArrayVertexBindingDivisorEXT },
-    { "glVertexArrayVertexBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayVertexBuffer },
-    { "glVertexArrayVertexBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5", glVertexArrayVertexBuffers },
-    { "glVertexArrayVertexOffsetEXT", "GL_EXT_direct_state_access", glVertexArrayVertexOffsetEXT },
-    { "glVertexAttrib1d", "GL_VERSION_2_0", glVertexAttrib1d },
-    { "glVertexAttrib1dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1dARB },
-    { "glVertexAttrib1dNV", "GL_NV_vertex_program", glVertexAttrib1dNV },
-    { "glVertexAttrib1dv", "GL_VERSION_2_0", glVertexAttrib1dv },
-    { "glVertexAttrib1dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1dvARB },
-    { "glVertexAttrib1dvNV", "GL_NV_vertex_program", glVertexAttrib1dvNV },
-    { "glVertexAttrib1f", "GL_VERSION_2_0", glVertexAttrib1f },
-    { "glVertexAttrib1fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1fARB },
-    { "glVertexAttrib1fNV", "GL_NV_vertex_program", glVertexAttrib1fNV },
-    { "glVertexAttrib1fv", "GL_VERSION_2_0", glVertexAttrib1fv },
-    { "glVertexAttrib1fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1fvARB },
-    { "glVertexAttrib1fvNV", "GL_NV_vertex_program", glVertexAttrib1fvNV },
-    { "glVertexAttrib1hNV", "GL_NV_half_float", glVertexAttrib1hNV },
-    { "glVertexAttrib1hvNV", "GL_NV_half_float", glVertexAttrib1hvNV },
-    { "glVertexAttrib1s", "GL_VERSION_2_0", glVertexAttrib1s },
-    { "glVertexAttrib1sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1sARB },
-    { "glVertexAttrib1sNV", "GL_NV_vertex_program", glVertexAttrib1sNV },
-    { "glVertexAttrib1sv", "GL_VERSION_2_0", glVertexAttrib1sv },
-    { "glVertexAttrib1svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib1svARB },
-    { "glVertexAttrib1svNV", "GL_NV_vertex_program", glVertexAttrib1svNV },
-    { "glVertexAttrib2d", "GL_VERSION_2_0", glVertexAttrib2d },
-    { "glVertexAttrib2dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2dARB },
-    { "glVertexAttrib2dNV", "GL_NV_vertex_program", glVertexAttrib2dNV },
-    { "glVertexAttrib2dv", "GL_VERSION_2_0", glVertexAttrib2dv },
-    { "glVertexAttrib2dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2dvARB },
-    { "glVertexAttrib2dvNV", "GL_NV_vertex_program", glVertexAttrib2dvNV },
-    { "glVertexAttrib2f", "GL_VERSION_2_0", glVertexAttrib2f },
-    { "glVertexAttrib2fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2fARB },
-    { "glVertexAttrib2fNV", "GL_NV_vertex_program", glVertexAttrib2fNV },
-    { "glVertexAttrib2fv", "GL_VERSION_2_0", glVertexAttrib2fv },
-    { "glVertexAttrib2fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2fvARB },
-    { "glVertexAttrib2fvNV", "GL_NV_vertex_program", glVertexAttrib2fvNV },
-    { "glVertexAttrib2hNV", "GL_NV_half_float", glVertexAttrib2hNV },
-    { "glVertexAttrib2hvNV", "GL_NV_half_float", glVertexAttrib2hvNV },
-    { "glVertexAttrib2s", "GL_VERSION_2_0", glVertexAttrib2s },
-    { "glVertexAttrib2sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2sARB },
-    { "glVertexAttrib2sNV", "GL_NV_vertex_program", glVertexAttrib2sNV },
-    { "glVertexAttrib2sv", "GL_VERSION_2_0", glVertexAttrib2sv },
-    { "glVertexAttrib2svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib2svARB },
-    { "glVertexAttrib2svNV", "GL_NV_vertex_program", glVertexAttrib2svNV },
-    { "glVertexAttrib3d", "GL_VERSION_2_0", glVertexAttrib3d },
-    { "glVertexAttrib3dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3dARB },
-    { "glVertexAttrib3dNV", "GL_NV_vertex_program", glVertexAttrib3dNV },
-    { "glVertexAttrib3dv", "GL_VERSION_2_0", glVertexAttrib3dv },
-    { "glVertexAttrib3dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3dvARB },
-    { "glVertexAttrib3dvNV", "GL_NV_vertex_program", glVertexAttrib3dvNV },
-    { "glVertexAttrib3f", "GL_VERSION_2_0", glVertexAttrib3f },
-    { "glVertexAttrib3fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3fARB },
-    { "glVertexAttrib3fNV", "GL_NV_vertex_program", glVertexAttrib3fNV },
-    { "glVertexAttrib3fv", "GL_VERSION_2_0", glVertexAttrib3fv },
-    { "glVertexAttrib3fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3fvARB },
-    { "glVertexAttrib3fvNV", "GL_NV_vertex_program", glVertexAttrib3fvNV },
-    { "glVertexAttrib3hNV", "GL_NV_half_float", glVertexAttrib3hNV },
-    { "glVertexAttrib3hvNV", "GL_NV_half_float", glVertexAttrib3hvNV },
-    { "glVertexAttrib3s", "GL_VERSION_2_0", glVertexAttrib3s },
-    { "glVertexAttrib3sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3sARB },
-    { "glVertexAttrib3sNV", "GL_NV_vertex_program", glVertexAttrib3sNV },
-    { "glVertexAttrib3sv", "GL_VERSION_2_0", glVertexAttrib3sv },
-    { "glVertexAttrib3svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib3svARB },
-    { "glVertexAttrib3svNV", "GL_NV_vertex_program", glVertexAttrib3svNV },
-    { "glVertexAttrib4Nbv", "GL_VERSION_2_0", glVertexAttrib4Nbv },
-    { "glVertexAttrib4NbvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NbvARB },
-    { "glVertexAttrib4Niv", "GL_VERSION_2_0", glVertexAttrib4Niv },
-    { "glVertexAttrib4NivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NivARB },
-    { "glVertexAttrib4Nsv", "GL_VERSION_2_0", glVertexAttrib4Nsv },
-    { "glVertexAttrib4NsvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NsvARB },
-    { "glVertexAttrib4Nub", "GL_VERSION_2_0", glVertexAttrib4Nub },
-    { "glVertexAttrib4NubARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NubARB },
-    { "glVertexAttrib4Nubv", "GL_VERSION_2_0", glVertexAttrib4Nubv },
-    { "glVertexAttrib4NubvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NubvARB },
-    { "glVertexAttrib4Nuiv", "GL_VERSION_2_0", glVertexAttrib4Nuiv },
-    { "glVertexAttrib4NuivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NuivARB },
-    { "glVertexAttrib4Nusv", "GL_VERSION_2_0", glVertexAttrib4Nusv },
-    { "glVertexAttrib4NusvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4NusvARB },
-    { "glVertexAttrib4bv", "GL_VERSION_2_0", glVertexAttrib4bv },
-    { "glVertexAttrib4bvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4bvARB },
-    { "glVertexAttrib4d", "GL_VERSION_2_0", glVertexAttrib4d },
-    { "glVertexAttrib4dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4dARB },
-    { "glVertexAttrib4dNV", "GL_NV_vertex_program", glVertexAttrib4dNV },
-    { "glVertexAttrib4dv", "GL_VERSION_2_0", glVertexAttrib4dv },
-    { "glVertexAttrib4dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4dvARB },
-    { "glVertexAttrib4dvNV", "GL_NV_vertex_program", glVertexAttrib4dvNV },
-    { "glVertexAttrib4f", "GL_VERSION_2_0", glVertexAttrib4f },
-    { "glVertexAttrib4fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4fARB },
-    { "glVertexAttrib4fNV", "GL_NV_vertex_program", glVertexAttrib4fNV },
-    { "glVertexAttrib4fv", "GL_VERSION_2_0", glVertexAttrib4fv },
-    { "glVertexAttrib4fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4fvARB },
-    { "glVertexAttrib4fvNV", "GL_NV_vertex_program", glVertexAttrib4fvNV },
-    { "glVertexAttrib4hNV", "GL_NV_half_float", glVertexAttrib4hNV },
-    { "glVertexAttrib4hvNV", "GL_NV_half_float", glVertexAttrib4hvNV },
-    { "glVertexAttrib4iv", "GL_VERSION_2_0", glVertexAttrib4iv },
-    { "glVertexAttrib4ivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4ivARB },
-    { "glVertexAttrib4s", "GL_VERSION_2_0", glVertexAttrib4s },
-    { "glVertexAttrib4sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4sARB },
-    { "glVertexAttrib4sNV", "GL_NV_vertex_program", glVertexAttrib4sNV },
-    { "glVertexAttrib4sv", "GL_VERSION_2_0", glVertexAttrib4sv },
-    { "glVertexAttrib4svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4svARB },
-    { "glVertexAttrib4svNV", "GL_NV_vertex_program", glVertexAttrib4svNV },
-    { "glVertexAttrib4ubNV", "GL_NV_vertex_program", glVertexAttrib4ubNV },
-    { "glVertexAttrib4ubv", "GL_VERSION_2_0", glVertexAttrib4ubv },
-    { "glVertexAttrib4ubvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4ubvARB },
-    { "glVertexAttrib4ubvNV", "GL_NV_vertex_program", glVertexAttrib4ubvNV },
-    { "glVertexAttrib4uiv", "GL_VERSION_2_0", glVertexAttrib4uiv },
-    { "glVertexAttrib4uivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4uivARB },
-    { "glVertexAttrib4usv", "GL_VERSION_2_0", glVertexAttrib4usv },
-    { "glVertexAttrib4usvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttrib4usvARB },
-    { "glVertexAttribArrayObjectATI", "GL_ATI_vertex_attrib_array_object", glVertexAttribArrayObjectATI },
-    { "glVertexAttribBinding", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glVertexAttribBinding },
-    { "glVertexAttribDivisor", "GL_VERSION_3_3", glVertexAttribDivisor },
-    { "glVertexAttribDivisorARB", "GL_ARB_instanced_arrays", glVertexAttribDivisorARB },
-    { "glVertexAttribFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glVertexAttribFormat },
-    { "glVertexAttribFormatNV", "GL_NV_vertex_buffer_unified_memory", glVertexAttribFormatNV },
-    { "glVertexAttribI1i", "GL_VERSION_3_0", glVertexAttribI1i },
-    { "glVertexAttribI1iEXT", "GL_NV_vertex_program4", glVertexAttribI1iEXT },
-    { "glVertexAttribI1iv", "GL_VERSION_3_0", glVertexAttribI1iv },
-    { "glVertexAttribI1ivEXT", "GL_NV_vertex_program4", glVertexAttribI1ivEXT },
-    { "glVertexAttribI1ui", "GL_VERSION_3_0", glVertexAttribI1ui },
-    { "glVertexAttribI1uiEXT", "GL_NV_vertex_program4", glVertexAttribI1uiEXT },
-    { "glVertexAttribI1uiv", "GL_VERSION_3_0", glVertexAttribI1uiv },
-    { "glVertexAttribI1uivEXT", "GL_NV_vertex_program4", glVertexAttribI1uivEXT },
-    { "glVertexAttribI2i", "GL_VERSION_3_0", glVertexAttribI2i },
-    { "glVertexAttribI2iEXT", "GL_NV_vertex_program4", glVertexAttribI2iEXT },
-    { "glVertexAttribI2iv", "GL_VERSION_3_0", glVertexAttribI2iv },
-    { "glVertexAttribI2ivEXT", "GL_NV_vertex_program4", glVertexAttribI2ivEXT },
-    { "glVertexAttribI2ui", "GL_VERSION_3_0", glVertexAttribI2ui },
-    { "glVertexAttribI2uiEXT", "GL_NV_vertex_program4", glVertexAttribI2uiEXT },
-    { "glVertexAttribI2uiv", "GL_VERSION_3_0", glVertexAttribI2uiv },
-    { "glVertexAttribI2uivEXT", "GL_NV_vertex_program4", glVertexAttribI2uivEXT },
-    { "glVertexAttribI3i", "GL_VERSION_3_0", glVertexAttribI3i },
-    { "glVertexAttribI3iEXT", "GL_NV_vertex_program4", glVertexAttribI3iEXT },
-    { "glVertexAttribI3iv", "GL_VERSION_3_0", glVertexAttribI3iv },
-    { "glVertexAttribI3ivEXT", "GL_NV_vertex_program4", glVertexAttribI3ivEXT },
-    { "glVertexAttribI3ui", "GL_VERSION_3_0", glVertexAttribI3ui },
-    { "glVertexAttribI3uiEXT", "GL_NV_vertex_program4", glVertexAttribI3uiEXT },
-    { "glVertexAttribI3uiv", "GL_VERSION_3_0", glVertexAttribI3uiv },
-    { "glVertexAttribI3uivEXT", "GL_NV_vertex_program4", glVertexAttribI3uivEXT },
-    { "glVertexAttribI4bv", "GL_VERSION_3_0", glVertexAttribI4bv },
-    { "glVertexAttribI4bvEXT", "GL_NV_vertex_program4", glVertexAttribI4bvEXT },
-    { "glVertexAttribI4i", "GL_VERSION_3_0", glVertexAttribI4i },
-    { "glVertexAttribI4iEXT", "GL_NV_vertex_program4", glVertexAttribI4iEXT },
-    { "glVertexAttribI4iv", "GL_VERSION_3_0", glVertexAttribI4iv },
-    { "glVertexAttribI4ivEXT", "GL_NV_vertex_program4", glVertexAttribI4ivEXT },
-    { "glVertexAttribI4sv", "GL_VERSION_3_0", glVertexAttribI4sv },
-    { "glVertexAttribI4svEXT", "GL_NV_vertex_program4", glVertexAttribI4svEXT },
-    { "glVertexAttribI4ubv", "GL_VERSION_3_0", glVertexAttribI4ubv },
-    { "glVertexAttribI4ubvEXT", "GL_NV_vertex_program4", glVertexAttribI4ubvEXT },
-    { "glVertexAttribI4ui", "GL_VERSION_3_0", glVertexAttribI4ui },
-    { "glVertexAttribI4uiEXT", "GL_NV_vertex_program4", glVertexAttribI4uiEXT },
-    { "glVertexAttribI4uiv", "GL_VERSION_3_0", glVertexAttribI4uiv },
-    { "glVertexAttribI4uivEXT", "GL_NV_vertex_program4", glVertexAttribI4uivEXT },
-    { "glVertexAttribI4usv", "GL_VERSION_3_0", glVertexAttribI4usv },
-    { "glVertexAttribI4usvEXT", "GL_NV_vertex_program4", glVertexAttribI4usvEXT },
-    { "glVertexAttribIFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glVertexAttribIFormat },
-    { "glVertexAttribIFormatNV", "GL_NV_vertex_buffer_unified_memory", glVertexAttribIFormatNV },
-    { "glVertexAttribIPointer", "GL_VERSION_3_0", glVertexAttribIPointer },
-    { "glVertexAttribIPointerEXT", "GL_NV_vertex_program4", glVertexAttribIPointerEXT },
-    { "glVertexAttribL1d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL1d },
-    { "glVertexAttribL1dEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL1dEXT },
-    { "glVertexAttribL1dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL1dv },
-    { "glVertexAttribL1dvEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL1dvEXT },
-    { "glVertexAttribL1i64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL1i64NV },
-    { "glVertexAttribL1i64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL1i64vNV },
-    { "glVertexAttribL1ui64ARB", "GL_ARB_bindless_texture", glVertexAttribL1ui64ARB },
-    { "glVertexAttribL1ui64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL1ui64NV },
-    { "glVertexAttribL1ui64vARB", "GL_ARB_bindless_texture", glVertexAttribL1ui64vARB },
-    { "glVertexAttribL1ui64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL1ui64vNV },
-    { "glVertexAttribL2d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL2d },
-    { "glVertexAttribL2dEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL2dEXT },
-    { "glVertexAttribL2dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL2dv },
-    { "glVertexAttribL2dvEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL2dvEXT },
-    { "glVertexAttribL2i64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL2i64NV },
-    { "glVertexAttribL2i64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL2i64vNV },
-    { "glVertexAttribL2ui64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL2ui64NV },
-    { "glVertexAttribL2ui64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL2ui64vNV },
-    { "glVertexAttribL3d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL3d },
-    { "glVertexAttribL3dEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL3dEXT },
-    { "glVertexAttribL3dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL3dv },
-    { "glVertexAttribL3dvEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL3dvEXT },
-    { "glVertexAttribL3i64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL3i64NV },
-    { "glVertexAttribL3i64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL3i64vNV },
-    { "glVertexAttribL3ui64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL3ui64NV },
-    { "glVertexAttribL3ui64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL3ui64vNV },
-    { "glVertexAttribL4d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL4d },
-    { "glVertexAttribL4dEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL4dEXT },
-    { "glVertexAttribL4dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribL4dv },
-    { "glVertexAttribL4dvEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribL4dvEXT },
-    { "glVertexAttribL4i64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL4i64NV },
-    { "glVertexAttribL4i64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL4i64vNV },
-    { "glVertexAttribL4ui64NV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL4ui64NV },
-    { "glVertexAttribL4ui64vNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribL4ui64vNV },
-    { "glVertexAttribLFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glVertexAttribLFormat },
-    { "glVertexAttribLFormatNV", "GL_NV_vertex_attrib_integer_64bit", glVertexAttribLFormatNV },
-    { "glVertexAttribLPointer", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1", glVertexAttribLPointer },
-    { "glVertexAttribLPointerEXT", "GL_EXT_vertex_attrib_64bit", glVertexAttribLPointerEXT },
-    { "glVertexAttribP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP1ui },
-    { "glVertexAttribP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP1uiv },
-    { "glVertexAttribP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP2ui },
-    { "glVertexAttribP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP2uiv },
-    { "glVertexAttribP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP3ui },
-    { "glVertexAttribP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP3uiv },
-    { "glVertexAttribP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP4ui },
-    { "glVertexAttribP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexAttribP4uiv },
-    { "glVertexAttribParameteriAMD", "GL_AMD_interleaved_elements", glVertexAttribParameteriAMD },
-    { "glVertexAttribPointer", "GL_VERSION_2_0", glVertexAttribPointer },
-    { "glVertexAttribPointerARB", "GL_ARB_vertex_program GL_ARB_vertex_shader", glVertexAttribPointerARB },
-    { "glVertexAttribPointerNV", "GL_NV_vertex_program", glVertexAttribPointerNV },
-    { "glVertexAttribs1dvNV", "GL_NV_vertex_program", glVertexAttribs1dvNV },
-    { "glVertexAttribs1fvNV", "GL_NV_vertex_program", glVertexAttribs1fvNV },
-    { "glVertexAttribs1hvNV", "GL_NV_half_float", glVertexAttribs1hvNV },
-    { "glVertexAttribs1svNV", "GL_NV_vertex_program", glVertexAttribs1svNV },
-    { "glVertexAttribs2dvNV", "GL_NV_vertex_program", glVertexAttribs2dvNV },
-    { "glVertexAttribs2fvNV", "GL_NV_vertex_program", glVertexAttribs2fvNV },
-    { "glVertexAttribs2hvNV", "GL_NV_half_float", glVertexAttribs2hvNV },
-    { "glVertexAttribs2svNV", "GL_NV_vertex_program", glVertexAttribs2svNV },
-    { "glVertexAttribs3dvNV", "GL_NV_vertex_program", glVertexAttribs3dvNV },
-    { "glVertexAttribs3fvNV", "GL_NV_vertex_program", glVertexAttribs3fvNV },
-    { "glVertexAttribs3hvNV", "GL_NV_half_float", glVertexAttribs3hvNV },
-    { "glVertexAttribs3svNV", "GL_NV_vertex_program", glVertexAttribs3svNV },
-    { "glVertexAttribs4dvNV", "GL_NV_vertex_program", glVertexAttribs4dvNV },
-    { "glVertexAttribs4fvNV", "GL_NV_vertex_program", glVertexAttribs4fvNV },
-    { "glVertexAttribs4hvNV", "GL_NV_half_float", glVertexAttribs4hvNV },
-    { "glVertexAttribs4svNV", "GL_NV_vertex_program", glVertexAttribs4svNV },
-    { "glVertexAttribs4ubvNV", "GL_NV_vertex_program", glVertexAttribs4ubvNV },
-    { "glVertexBindingDivisor", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3", glVertexBindingDivisor },
-    { "glVertexBlendARB", "GL_ARB_vertex_blend", glVertexBlendARB },
-    { "glVertexBlendEnvfATI", "GL_ATI_vertex_streams", glVertexBlendEnvfATI },
-    { "glVertexBlendEnviATI", "GL_ATI_vertex_streams", glVertexBlendEnviATI },
-    { "glVertexFormatNV", "GL_NV_vertex_buffer_unified_memory", glVertexFormatNV },
-    { "glVertexP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP2ui },
-    { "glVertexP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP2uiv },
-    { "glVertexP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP3ui },
-    { "glVertexP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP3uiv },
-    { "glVertexP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP4ui },
-    { "glVertexP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3", glVertexP4uiv },
-    { "glVertexPointerEXT", "GL_EXT_vertex_array", glVertexPointerEXT },
-    { "glVertexPointerListIBM", "GL_IBM_vertex_array_lists", glVertexPointerListIBM },
-    { "glVertexPointervINTEL", "GL_INTEL_parallel_arrays", glVertexPointervINTEL },
-    { "glVertexStream1dATI", "GL_ATI_vertex_streams", glVertexStream1dATI },
-    { "glVertexStream1dvATI", "GL_ATI_vertex_streams", glVertexStream1dvATI },
-    { "glVertexStream1fATI", "GL_ATI_vertex_streams", glVertexStream1fATI },
-    { "glVertexStream1fvATI", "GL_ATI_vertex_streams", glVertexStream1fvATI },
-    { "glVertexStream1iATI", "GL_ATI_vertex_streams", glVertexStream1iATI },
-    { "glVertexStream1ivATI", "GL_ATI_vertex_streams", glVertexStream1ivATI },
-    { "glVertexStream1sATI", "GL_ATI_vertex_streams", glVertexStream1sATI },
-    { "glVertexStream1svATI", "GL_ATI_vertex_streams", glVertexStream1svATI },
-    { "glVertexStream2dATI", "GL_ATI_vertex_streams", glVertexStream2dATI },
-    { "glVertexStream2dvATI", "GL_ATI_vertex_streams", glVertexStream2dvATI },
-    { "glVertexStream2fATI", "GL_ATI_vertex_streams", glVertexStream2fATI },
-    { "glVertexStream2fvATI", "GL_ATI_vertex_streams", glVertexStream2fvATI },
-    { "glVertexStream2iATI", "GL_ATI_vertex_streams", glVertexStream2iATI },
-    { "glVertexStream2ivATI", "GL_ATI_vertex_streams", glVertexStream2ivATI },
-    { "glVertexStream2sATI", "GL_ATI_vertex_streams", glVertexStream2sATI },
-    { "glVertexStream2svATI", "GL_ATI_vertex_streams", glVertexStream2svATI },
-    { "glVertexStream3dATI", "GL_ATI_vertex_streams", glVertexStream3dATI },
-    { "glVertexStream3dvATI", "GL_ATI_vertex_streams", glVertexStream3dvATI },
-    { "glVertexStream3fATI", "GL_ATI_vertex_streams", glVertexStream3fATI },
-    { "glVertexStream3fvATI", "GL_ATI_vertex_streams", glVertexStream3fvATI },
-    { "glVertexStream3iATI", "GL_ATI_vertex_streams", glVertexStream3iATI },
-    { "glVertexStream3ivATI", "GL_ATI_vertex_streams", glVertexStream3ivATI },
-    { "glVertexStream3sATI", "GL_ATI_vertex_streams", glVertexStream3sATI },
-    { "glVertexStream3svATI", "GL_ATI_vertex_streams", glVertexStream3svATI },
-    { "glVertexStream4dATI", "GL_ATI_vertex_streams", glVertexStream4dATI },
-    { "glVertexStream4dvATI", "GL_ATI_vertex_streams", glVertexStream4dvATI },
-    { "glVertexStream4fATI", "GL_ATI_vertex_streams", glVertexStream4fATI },
-    { "glVertexStream4fvATI", "GL_ATI_vertex_streams", glVertexStream4fvATI },
-    { "glVertexStream4iATI", "GL_ATI_vertex_streams", glVertexStream4iATI },
-    { "glVertexStream4ivATI", "GL_ATI_vertex_streams", glVertexStream4ivATI },
-    { "glVertexStream4sATI", "GL_ATI_vertex_streams", glVertexStream4sATI },
-    { "glVertexStream4svATI", "GL_ATI_vertex_streams", glVertexStream4svATI },
-    { "glVertexWeightPointerEXT", "GL_EXT_vertex_weighting", glVertexWeightPointerEXT },
-    { "glVertexWeightfEXT", "GL_EXT_vertex_weighting", glVertexWeightfEXT },
-    { "glVertexWeightfvEXT", "GL_EXT_vertex_weighting", glVertexWeightfvEXT },
-    { "glVertexWeighthNV", "GL_NV_half_float", glVertexWeighthNV },
-    { "glVertexWeighthvNV", "GL_NV_half_float", glVertexWeighthvNV },
-    { "glVideoCaptureNV", "GL_NV_video_capture", glVideoCaptureNV },
-    { "glVideoCaptureStreamParameterdvNV", "GL_NV_video_capture", glVideoCaptureStreamParameterdvNV },
-    { "glVideoCaptureStreamParameterfvNV", "GL_NV_video_capture", glVideoCaptureStreamParameterfvNV },
-    { "glVideoCaptureStreamParameterivNV", "GL_NV_video_capture", glVideoCaptureStreamParameterivNV },
-    { "glViewportArrayv", "GL_ARB_viewport_array GL_VERSION_4_1", glViewportArrayv },
-    { "glViewportIndexedf", "GL_ARB_viewport_array GL_VERSION_4_1", glViewportIndexedf },
-    { "glViewportIndexedfv", "GL_ARB_viewport_array GL_VERSION_4_1", glViewportIndexedfv },
-    { "glViewportPositionWScaleNV", "GL_NV_clip_space_w_scaling", glViewportPositionWScaleNV },
-    { "glViewportSwizzleNV", "GL_NV_viewport_swizzle", glViewportSwizzleNV },
-    { "glWaitSemaphoreEXT", "GL_EXT_semaphore", glWaitSemaphoreEXT },
-    { "glWaitSemaphoreui64NVX", "GL_NVX_progress_fence", glWaitSemaphoreui64NVX },
-    { "glWaitSync", "GL_ARB_sync GL_VERSION_3_2", glWaitSync },
-    { "glWaitVkSemaphoreNV", "GL_NV_draw_vulkan_image", glWaitVkSemaphoreNV },
-    { "glWeightPathsNV", "GL_NV_path_rendering", glWeightPathsNV },
-    { "glWeightPointerARB", "GL_ARB_vertex_blend", glWeightPointerARB },
-    { "glWeightbvARB", "GL_ARB_vertex_blend", glWeightbvARB },
-    { "glWeightdvARB", "GL_ARB_vertex_blend", glWeightdvARB },
-    { "glWeightfvARB", "GL_ARB_vertex_blend", glWeightfvARB },
-    { "glWeightivARB", "GL_ARB_vertex_blend", glWeightivARB },
-    { "glWeightsvARB", "GL_ARB_vertex_blend", glWeightsvARB },
-    { "glWeightubvARB", "GL_ARB_vertex_blend", glWeightubvARB },
-    { "glWeightuivARB", "GL_ARB_vertex_blend", glWeightuivARB },
-    { "glWeightusvARB", "GL_ARB_vertex_blend", glWeightusvARB },
-    { "glWindowPos2d", "GL_VERSION_1_4", glWindowPos2d },
-    { "glWindowPos2dARB", "GL_ARB_window_pos", glWindowPos2dARB },
-    { "glWindowPos2dMESA", "GL_MESA_window_pos", glWindowPos2dMESA },
-    { "glWindowPos2dv", "GL_VERSION_1_4", glWindowPos2dv },
-    { "glWindowPos2dvARB", "GL_ARB_window_pos", glWindowPos2dvARB },
-    { "glWindowPos2dvMESA", "GL_MESA_window_pos", glWindowPos2dvMESA },
-    { "glWindowPos2f", "GL_VERSION_1_4", glWindowPos2f },
-    { "glWindowPos2fARB", "GL_ARB_window_pos", glWindowPos2fARB },
-    { "glWindowPos2fMESA", "GL_MESA_window_pos", glWindowPos2fMESA },
-    { "glWindowPos2fv", "GL_VERSION_1_4", glWindowPos2fv },
-    { "glWindowPos2fvARB", "GL_ARB_window_pos", glWindowPos2fvARB },
-    { "glWindowPos2fvMESA", "GL_MESA_window_pos", glWindowPos2fvMESA },
-    { "glWindowPos2i", "GL_VERSION_1_4", glWindowPos2i },
-    { "glWindowPos2iARB", "GL_ARB_window_pos", glWindowPos2iARB },
-    { "glWindowPos2iMESA", "GL_MESA_window_pos", glWindowPos2iMESA },
-    { "glWindowPos2iv", "GL_VERSION_1_4", glWindowPos2iv },
-    { "glWindowPos2ivARB", "GL_ARB_window_pos", glWindowPos2ivARB },
-    { "glWindowPos2ivMESA", "GL_MESA_window_pos", glWindowPos2ivMESA },
-    { "glWindowPos2s", "GL_VERSION_1_4", glWindowPos2s },
-    { "glWindowPos2sARB", "GL_ARB_window_pos", glWindowPos2sARB },
-    { "glWindowPos2sMESA", "GL_MESA_window_pos", glWindowPos2sMESA },
-    { "glWindowPos2sv", "GL_VERSION_1_4", glWindowPos2sv },
-    { "glWindowPos2svARB", "GL_ARB_window_pos", glWindowPos2svARB },
-    { "glWindowPos2svMESA", "GL_MESA_window_pos", glWindowPos2svMESA },
-    { "glWindowPos3d", "GL_VERSION_1_4", glWindowPos3d },
-    { "glWindowPos3dARB", "GL_ARB_window_pos", glWindowPos3dARB },
-    { "glWindowPos3dMESA", "GL_MESA_window_pos", glWindowPos3dMESA },
-    { "glWindowPos3dv", "GL_VERSION_1_4", glWindowPos3dv },
-    { "glWindowPos3dvARB", "GL_ARB_window_pos", glWindowPos3dvARB },
-    { "glWindowPos3dvMESA", "GL_MESA_window_pos", glWindowPos3dvMESA },
-    { "glWindowPos3f", "GL_VERSION_1_4", glWindowPos3f },
-    { "glWindowPos3fARB", "GL_ARB_window_pos", glWindowPos3fARB },
-    { "glWindowPos3fMESA", "GL_MESA_window_pos", glWindowPos3fMESA },
-    { "glWindowPos3fv", "GL_VERSION_1_4", glWindowPos3fv },
-    { "glWindowPos3fvARB", "GL_ARB_window_pos", glWindowPos3fvARB },
-    { "glWindowPos3fvMESA", "GL_MESA_window_pos", glWindowPos3fvMESA },
-    { "glWindowPos3i", "GL_VERSION_1_4", glWindowPos3i },
-    { "glWindowPos3iARB", "GL_ARB_window_pos", glWindowPos3iARB },
-    { "glWindowPos3iMESA", "GL_MESA_window_pos", glWindowPos3iMESA },
-    { "glWindowPos3iv", "GL_VERSION_1_4", glWindowPos3iv },
-    { "glWindowPos3ivARB", "GL_ARB_window_pos", glWindowPos3ivARB },
-    { "glWindowPos3ivMESA", "GL_MESA_window_pos", glWindowPos3ivMESA },
-    { "glWindowPos3s", "GL_VERSION_1_4", glWindowPos3s },
-    { "glWindowPos3sARB", "GL_ARB_window_pos", glWindowPos3sARB },
-    { "glWindowPos3sMESA", "GL_MESA_window_pos", glWindowPos3sMESA },
-    { "glWindowPos3sv", "GL_VERSION_1_4", glWindowPos3sv },
-    { "glWindowPos3svARB", "GL_ARB_window_pos", glWindowPos3svARB },
-    { "glWindowPos3svMESA", "GL_MESA_window_pos", glWindowPos3svMESA },
-    { "glWindowPos4dMESA", "GL_MESA_window_pos", glWindowPos4dMESA },
-    { "glWindowPos4dvMESA", "GL_MESA_window_pos", glWindowPos4dvMESA },
-    { "glWindowPos4fMESA", "GL_MESA_window_pos", glWindowPos4fMESA },
-    { "glWindowPos4fvMESA", "GL_MESA_window_pos", glWindowPos4fvMESA },
-    { "glWindowPos4iMESA", "GL_MESA_window_pos", glWindowPos4iMESA },
-    { "glWindowPos4ivMESA", "GL_MESA_window_pos", glWindowPos4ivMESA },
-    { "glWindowPos4sMESA", "GL_MESA_window_pos", glWindowPos4sMESA },
-    { "glWindowPos4svMESA", "GL_MESA_window_pos", glWindowPos4svMESA },
-    { "glWindowRectanglesEXT", "GL_EXT_window_rectangles", glWindowRectanglesEXT },
-    { "glWriteMaskEXT", "GL_EXT_vertex_shader", glWriteMaskEXT },
-    { "wglAllocateMemoryNV", "WGL_NV_vertex_array_range", wglAllocateMemoryNV },
-    { "wglBindTexImageARB", "WGL_ARB_render_texture", wglBindTexImageARB },
-    { "wglChoosePixelFormatARB", "WGL_ARB_pixel_format", wglChoosePixelFormatARB },
-    { "wglCreateContextAttribsARB", "WGL_ARB_create_context", wglCreateContextAttribsARB },
-    { "wglCreatePbufferARB", "WGL_ARB_pbuffer", wglCreatePbufferARB },
-    { "wglDestroyPbufferARB", "WGL_ARB_pbuffer", wglDestroyPbufferARB },
-    { "wglFreeMemoryNV", "WGL_NV_vertex_array_range", wglFreeMemoryNV },
-    { "wglGetCurrentReadDCARB", "WGL_ARB_make_current_read", wglGetCurrentReadDCARB },
-    { "wglGetExtensionsStringARB", "WGL_ARB_extensions_string", wglGetExtensionsStringARB },
-    { "wglGetExtensionsStringEXT", "WGL_EXT_extensions_string", wglGetExtensionsStringEXT },
-    { "wglGetPbufferDCARB", "WGL_ARB_pbuffer", wglGetPbufferDCARB },
-    { "wglGetPixelFormatAttribfvARB", "WGL_ARB_pixel_format", wglGetPixelFormatAttribfvARB },
-    { "wglGetPixelFormatAttribivARB", "WGL_ARB_pixel_format", wglGetPixelFormatAttribivARB },
-    { "wglGetSwapIntervalEXT", "WGL_EXT_swap_control", wglGetSwapIntervalEXT },
-    { "wglMakeContextCurrentARB", "WGL_ARB_make_current_read", wglMakeContextCurrentARB },
-    { "wglQueryCurrentRendererIntegerWINE", "WGL_WINE_query_renderer", wglQueryCurrentRendererIntegerWINE },
-    { "wglQueryCurrentRendererStringWINE", "WGL_WINE_query_renderer", wglQueryCurrentRendererStringWINE },
-    { "wglQueryPbufferARB", "WGL_ARB_pbuffer", wglQueryPbufferARB },
-    { "wglQueryRendererIntegerWINE", "WGL_WINE_query_renderer", wglQueryRendererIntegerWINE },
-    { "wglQueryRendererStringWINE", "WGL_WINE_query_renderer", wglQueryRendererStringWINE },
-    { "wglReleasePbufferDCARB", "WGL_ARB_pbuffer", wglReleasePbufferDCARB },
-    { "wglReleaseTexImageARB", "WGL_ARB_render_texture", wglReleaseTexImageARB },
-    { "wglSetPbufferAttribARB", "WGL_ARB_render_texture", wglSetPbufferAttribARB },
-    { "wglSetPixelFormatWINE", "WGL_WINE_pixel_format_passthrough", wglSetPixelFormatWINE },
-    { "wglSwapIntervalEXT", "WGL_EXT_swap_control", wglSwapIntervalEXT },
+const void *extension_procs[] =
+{
+    &glAccumxOES,
+    &glAcquireKeyedMutexWin32EXT,
+    &glActiveProgramEXT,
+    &glActiveShaderProgram,
+    &glActiveStencilFaceEXT,
+    &glActiveTexture,
+    &glActiveTextureARB,
+    &glActiveVaryingNV,
+    &glAlphaFragmentOp1ATI,
+    &glAlphaFragmentOp2ATI,
+    &glAlphaFragmentOp3ATI,
+    &glAlphaFuncxOES,
+    &glAlphaToCoverageDitherControlNV,
+    &glApplyFramebufferAttachmentCMAAINTEL,
+    &glApplyTextureEXT,
+    &glAreProgramsResidentNV,
+    &glAreTexturesResidentEXT,
+    &glArrayElementEXT,
+    &glArrayObjectATI,
+    &glAsyncCopyBufferSubDataNVX,
+    &glAsyncCopyImageSubDataNVX,
+    &glAsyncMarkerSGIX,
+    &glAttachObjectARB,
+    &glAttachShader,
+    &glBeginConditionalRender,
+    &glBeginConditionalRenderNV,
+    &glBeginConditionalRenderNVX,
+    &glBeginFragmentShaderATI,
+    &glBeginOcclusionQueryNV,
+    &glBeginPerfMonitorAMD,
+    &glBeginPerfQueryINTEL,
+    &glBeginQuery,
+    &glBeginQueryARB,
+    &glBeginQueryIndexed,
+    &glBeginTransformFeedback,
+    &glBeginTransformFeedbackEXT,
+    &glBeginTransformFeedbackNV,
+    &glBeginVertexShaderEXT,
+    &glBeginVideoCaptureNV,
+    &glBindAttribLocation,
+    &glBindAttribLocationARB,
+    &glBindBuffer,
+    &glBindBufferARB,
+    &glBindBufferBase,
+    &glBindBufferBaseEXT,
+    &glBindBufferBaseNV,
+    &glBindBufferOffsetEXT,
+    &glBindBufferOffsetNV,
+    &glBindBufferRange,
+    &glBindBufferRangeEXT,
+    &glBindBufferRangeNV,
+    &glBindBuffersBase,
+    &glBindBuffersRange,
+    &glBindFragDataLocation,
+    &glBindFragDataLocationEXT,
+    &glBindFragDataLocationIndexed,
+    &glBindFragmentShaderATI,
+    &glBindFramebuffer,
+    &glBindFramebufferEXT,
+    &glBindImageTexture,
+    &glBindImageTextureEXT,
+    &glBindImageTextures,
+    &glBindLightParameterEXT,
+    &glBindMaterialParameterEXT,
+    &glBindMultiTextureEXT,
+    &glBindParameterEXT,
+    &glBindProgramARB,
+    &glBindProgramNV,
+    &glBindProgramPipeline,
+    &glBindRenderbuffer,
+    &glBindRenderbufferEXT,
+    &glBindSampler,
+    &glBindSamplers,
+    &glBindShadingRateImageNV,
+    &glBindTexGenParameterEXT,
+    &glBindTextureEXT,
+    &glBindTextureUnit,
+    &glBindTextureUnitParameterEXT,
+    &glBindTextures,
+    &glBindTransformFeedback,
+    &glBindTransformFeedbackNV,
+    &glBindVertexArray,
+    &glBindVertexArrayAPPLE,
+    &glBindVertexBuffer,
+    &glBindVertexBuffers,
+    &glBindVertexShaderEXT,
+    &glBindVideoCaptureStreamBufferNV,
+    &glBindVideoCaptureStreamTextureNV,
+    &glBinormal3bEXT,
+    &glBinormal3bvEXT,
+    &glBinormal3dEXT,
+    &glBinormal3dvEXT,
+    &glBinormal3fEXT,
+    &glBinormal3fvEXT,
+    &glBinormal3iEXT,
+    &glBinormal3ivEXT,
+    &glBinormal3sEXT,
+    &glBinormal3svEXT,
+    &glBinormalPointerEXT,
+    &glBitmapxOES,
+    &glBlendBarrierKHR,
+    &glBlendBarrierNV,
+    &glBlendColor,
+    &glBlendColorEXT,
+    &glBlendColorxOES,
+    &glBlendEquation,
+    &glBlendEquationEXT,
+    &glBlendEquationIndexedAMD,
+    &glBlendEquationSeparate,
+    &glBlendEquationSeparateEXT,
+    &glBlendEquationSeparateIndexedAMD,
+    &glBlendEquationSeparatei,
+    &glBlendEquationSeparateiARB,
+    &glBlendEquationi,
+    &glBlendEquationiARB,
+    &glBlendFuncIndexedAMD,
+    &glBlendFuncSeparate,
+    &glBlendFuncSeparateEXT,
+    &glBlendFuncSeparateINGR,
+    &glBlendFuncSeparateIndexedAMD,
+    &glBlendFuncSeparatei,
+    &glBlendFuncSeparateiARB,
+    &glBlendFunci,
+    &glBlendFunciARB,
+    &glBlendParameteriNV,
+    &glBlitFramebuffer,
+    &glBlitFramebufferEXT,
+    &glBlitNamedFramebuffer,
+    &glBufferAddressRangeNV,
+    &glBufferAttachMemoryNV,
+    &glBufferData,
+    &glBufferDataARB,
+    &glBufferPageCommitmentARB,
+    &glBufferParameteriAPPLE,
+    &glBufferRegionEnabled,
+    &glBufferStorage,
+    &glBufferStorageExternalEXT,
+    &glBufferStorageMemEXT,
+    &glBufferSubData,
+    &glBufferSubDataARB,
+    &glCallCommandListNV,
+    &glCheckFramebufferStatus,
+    &glCheckFramebufferStatusEXT,
+    &glCheckNamedFramebufferStatus,
+    &glCheckNamedFramebufferStatusEXT,
+    &glClampColor,
+    &glClampColorARB,
+    &glClearAccumxOES,
+    &glClearBufferData,
+    &glClearBufferSubData,
+    &glClearBufferfi,
+    &glClearBufferfv,
+    &glClearBufferiv,
+    &glClearBufferuiv,
+    &glClearColorIiEXT,
+    &glClearColorIuiEXT,
+    &glClearColorxOES,
+    &glClearDepthdNV,
+    &glClearDepthf,
+    &glClearDepthfOES,
+    &glClearDepthxOES,
+    &glClearNamedBufferData,
+    &glClearNamedBufferDataEXT,
+    &glClearNamedBufferSubData,
+    &glClearNamedBufferSubDataEXT,
+    &glClearNamedFramebufferfi,
+    &glClearNamedFramebufferfv,
+    &glClearNamedFramebufferiv,
+    &glClearNamedFramebufferuiv,
+    &glClearTexImage,
+    &glClearTexSubImage,
+    &glClientActiveTexture,
+    &glClientActiveTextureARB,
+    &glClientActiveVertexStreamATI,
+    &glClientAttribDefaultEXT,
+    &glClientWaitSemaphoreui64NVX,
+    &glClientWaitSync,
+    &glClipControl,
+    &glClipPlanefOES,
+    &glClipPlanexOES,
+    &glColor3fVertex3fSUN,
+    &glColor3fVertex3fvSUN,
+    &glColor3hNV,
+    &glColor3hvNV,
+    &glColor3xOES,
+    &glColor3xvOES,
+    &glColor4fNormal3fVertex3fSUN,
+    &glColor4fNormal3fVertex3fvSUN,
+    &glColor4hNV,
+    &glColor4hvNV,
+    &glColor4ubVertex2fSUN,
+    &glColor4ubVertex2fvSUN,
+    &glColor4ubVertex3fSUN,
+    &glColor4ubVertex3fvSUN,
+    &glColor4xOES,
+    &glColor4xvOES,
+    &glColorFormatNV,
+    &glColorFragmentOp1ATI,
+    &glColorFragmentOp2ATI,
+    &glColorFragmentOp3ATI,
+    &glColorMaskIndexedEXT,
+    &glColorMaski,
+    &glColorP3ui,
+    &glColorP3uiv,
+    &glColorP4ui,
+    &glColorP4uiv,
+    &glColorPointerEXT,
+    &glColorPointerListIBM,
+    &glColorPointervINTEL,
+    &glColorSubTable,
+    &glColorSubTableEXT,
+    &glColorTable,
+    &glColorTableEXT,
+    &glColorTableParameterfv,
+    &glColorTableParameterfvSGI,
+    &glColorTableParameteriv,
+    &glColorTableParameterivSGI,
+    &glColorTableSGI,
+    &glCombinerInputNV,
+    &glCombinerOutputNV,
+    &glCombinerParameterfNV,
+    &glCombinerParameterfvNV,
+    &glCombinerParameteriNV,
+    &glCombinerParameterivNV,
+    &glCombinerStageParameterfvNV,
+    &glCommandListSegmentsNV,
+    &glCompileCommandListNV,
+    &glCompileShader,
+    &glCompileShaderARB,
+    &glCompileShaderIncludeARB,
+    &glCompressedMultiTexImage1DEXT,
+    &glCompressedMultiTexImage2DEXT,
+    &glCompressedMultiTexImage3DEXT,
+    &glCompressedMultiTexSubImage1DEXT,
+    &glCompressedMultiTexSubImage2DEXT,
+    &glCompressedMultiTexSubImage3DEXT,
+    &glCompressedTexImage1D,
+    &glCompressedTexImage1DARB,
+    &glCompressedTexImage2D,
+    &glCompressedTexImage2DARB,
+    &glCompressedTexImage3D,
+    &glCompressedTexImage3DARB,
+    &glCompressedTexSubImage1D,
+    &glCompressedTexSubImage1DARB,
+    &glCompressedTexSubImage2D,
+    &glCompressedTexSubImage2DARB,
+    &glCompressedTexSubImage3D,
+    &glCompressedTexSubImage3DARB,
+    &glCompressedTextureImage1DEXT,
+    &glCompressedTextureImage2DEXT,
+    &glCompressedTextureImage3DEXT,
+    &glCompressedTextureSubImage1D,
+    &glCompressedTextureSubImage1DEXT,
+    &glCompressedTextureSubImage2D,
+    &glCompressedTextureSubImage2DEXT,
+    &glCompressedTextureSubImage3D,
+    &glCompressedTextureSubImage3DEXT,
+    &glConservativeRasterParameterfNV,
+    &glConservativeRasterParameteriNV,
+    &glConvolutionFilter1D,
+    &glConvolutionFilter1DEXT,
+    &glConvolutionFilter2D,
+    &glConvolutionFilter2DEXT,
+    &glConvolutionParameterf,
+    &glConvolutionParameterfEXT,
+    &glConvolutionParameterfv,
+    &glConvolutionParameterfvEXT,
+    &glConvolutionParameteri,
+    &glConvolutionParameteriEXT,
+    &glConvolutionParameteriv,
+    &glConvolutionParameterivEXT,
+    &glConvolutionParameterxOES,
+    &glConvolutionParameterxvOES,
+    &glCopyBufferSubData,
+    &glCopyColorSubTable,
+    &glCopyColorSubTableEXT,
+    &glCopyColorTable,
+    &glCopyColorTableSGI,
+    &glCopyConvolutionFilter1D,
+    &glCopyConvolutionFilter1DEXT,
+    &glCopyConvolutionFilter2D,
+    &glCopyConvolutionFilter2DEXT,
+    &glCopyImageSubData,
+    &glCopyImageSubDataNV,
+    &glCopyMultiTexImage1DEXT,
+    &glCopyMultiTexImage2DEXT,
+    &glCopyMultiTexSubImage1DEXT,
+    &glCopyMultiTexSubImage2DEXT,
+    &glCopyMultiTexSubImage3DEXT,
+    &glCopyNamedBufferSubData,
+    &glCopyPathNV,
+    &glCopyTexImage1DEXT,
+    &glCopyTexImage2DEXT,
+    &glCopyTexSubImage1DEXT,
+    &glCopyTexSubImage2DEXT,
+    &glCopyTexSubImage3D,
+    &glCopyTexSubImage3DEXT,
+    &glCopyTextureImage1DEXT,
+    &glCopyTextureImage2DEXT,
+    &glCopyTextureSubImage1D,
+    &glCopyTextureSubImage1DEXT,
+    &glCopyTextureSubImage2D,
+    &glCopyTextureSubImage2DEXT,
+    &glCopyTextureSubImage3D,
+    &glCopyTextureSubImage3DEXT,
+    &glCoverFillPathInstancedNV,
+    &glCoverFillPathNV,
+    &glCoverStrokePathInstancedNV,
+    &glCoverStrokePathNV,
+    &glCoverageModulationNV,
+    &glCoverageModulationTableNV,
+    &glCreateBuffers,
+    &glCreateCommandListsNV,
+    &glCreateFramebuffers,
+    &glCreateMemoryObjectsEXT,
+    &glCreatePerfQueryINTEL,
+    &glCreateProgram,
+    &glCreateProgramObjectARB,
+    &glCreateProgramPipelines,
+    &glCreateProgressFenceNVX,
+    &glCreateQueries,
+    &glCreateRenderbuffers,
+    &glCreateSamplers,
+    &glCreateShader,
+    &glCreateShaderObjectARB,
+    &glCreateShaderProgramEXT,
+    &glCreateShaderProgramv,
+    &glCreateStatesNV,
+    &glCreateSyncFromCLeventARB,
+    &glCreateTextures,
+    &glCreateTransformFeedbacks,
+    &glCreateVertexArrays,
+    &glCullParameterdvEXT,
+    &glCullParameterfvEXT,
+    &glCurrentPaletteMatrixARB,
+    &glDebugMessageCallback,
+    &glDebugMessageCallbackAMD,
+    &glDebugMessageCallbackARB,
+    &glDebugMessageControl,
+    &glDebugMessageControlARB,
+    &glDebugMessageEnableAMD,
+    &glDebugMessageInsert,
+    &glDebugMessageInsertAMD,
+    &glDebugMessageInsertARB,
+    &glDeformSGIX,
+    &glDeformationMap3dSGIX,
+    &glDeformationMap3fSGIX,
+    &glDeleteAsyncMarkersSGIX,
+    &glDeleteBufferRegion,
+    &glDeleteBuffers,
+    &glDeleteBuffersARB,
+    &glDeleteCommandListsNV,
+    &glDeleteFencesAPPLE,
+    &glDeleteFencesNV,
+    &glDeleteFragmentShaderATI,
+    &glDeleteFramebuffers,
+    &glDeleteFramebuffersEXT,
+    &glDeleteMemoryObjectsEXT,
+    &glDeleteNamedStringARB,
+    &glDeleteNamesAMD,
+    &glDeleteObjectARB,
+    &glDeleteObjectBufferATI,
+    &glDeleteOcclusionQueriesNV,
+    &glDeletePathsNV,
+    &glDeletePerfMonitorsAMD,
+    &glDeletePerfQueryINTEL,
+    &glDeleteProgram,
+    &glDeleteProgramPipelines,
+    &glDeleteProgramsARB,
+    &glDeleteProgramsNV,
+    &glDeleteQueries,
+    &glDeleteQueriesARB,
+    &glDeleteQueryResourceTagNV,
+    &glDeleteRenderbuffers,
+    &glDeleteRenderbuffersEXT,
+    &glDeleteSamplers,
+    &glDeleteSemaphoresEXT,
+    &glDeleteShader,
+    &glDeleteStatesNV,
+    &glDeleteSync,
+    &glDeleteTexturesEXT,
+    &glDeleteTransformFeedbacks,
+    &glDeleteTransformFeedbacksNV,
+    &glDeleteVertexArrays,
+    &glDeleteVertexArraysAPPLE,
+    &glDeleteVertexShaderEXT,
+    &glDepthBoundsEXT,
+    &glDepthBoundsdNV,
+    &glDepthRangeArraydvNV,
+    &glDepthRangeArrayv,
+    &glDepthRangeIndexed,
+    &glDepthRangeIndexeddNV,
+    &glDepthRangedNV,
+    &glDepthRangef,
+    &glDepthRangefOES,
+    &glDepthRangexOES,
+    &glDetachObjectARB,
+    &glDetachShader,
+    &glDetailTexFuncSGIS,
+    &glDisableClientStateIndexedEXT,
+    &glDisableClientStateiEXT,
+    &glDisableIndexedEXT,
+    &glDisableVariantClientStateEXT,
+    &glDisableVertexArrayAttrib,
+    &glDisableVertexArrayAttribEXT,
+    &glDisableVertexArrayEXT,
+    &glDisableVertexAttribAPPLE,
+    &glDisableVertexAttribArray,
+    &glDisableVertexAttribArrayARB,
+    &glDisablei,
+    &glDispatchCompute,
+    &glDispatchComputeGroupSizeARB,
+    &glDispatchComputeIndirect,
+    &glDrawArraysEXT,
+    &glDrawArraysIndirect,
+    &glDrawArraysInstanced,
+    &glDrawArraysInstancedARB,
+    &glDrawArraysInstancedBaseInstance,
+    &glDrawArraysInstancedEXT,
+    &glDrawBufferRegion,
+    &glDrawBuffers,
+    &glDrawBuffersARB,
+    &glDrawBuffersATI,
+    &glDrawCommandsAddressNV,
+    &glDrawCommandsNV,
+    &glDrawCommandsStatesAddressNV,
+    &glDrawCommandsStatesNV,
+    &glDrawElementArrayAPPLE,
+    &glDrawElementArrayATI,
+    &glDrawElementsBaseVertex,
+    &glDrawElementsIndirect,
+    &glDrawElementsInstanced,
+    &glDrawElementsInstancedARB,
+    &glDrawElementsInstancedBaseInstance,
+    &glDrawElementsInstancedBaseVertex,
+    &glDrawElementsInstancedBaseVertexBaseInstance,
+    &glDrawElementsInstancedEXT,
+    &glDrawMeshArraysSUN,
+    &glDrawMeshTasksIndirectNV,
+    &glDrawMeshTasksNV,
+    &glDrawRangeElementArrayAPPLE,
+    &glDrawRangeElementArrayATI,
+    &glDrawRangeElements,
+    &glDrawRangeElementsBaseVertex,
+    &glDrawRangeElementsEXT,
+    &glDrawTextureNV,
+    &glDrawTransformFeedback,
+    &glDrawTransformFeedbackInstanced,
+    &glDrawTransformFeedbackNV,
+    &glDrawTransformFeedbackStream,
+    &glDrawTransformFeedbackStreamInstanced,
+    &glDrawVkImageNV,
+    &glEGLImageTargetTexStorageEXT,
+    &glEGLImageTargetTextureStorageEXT,
+    &glEdgeFlagFormatNV,
+    &glEdgeFlagPointerEXT,
+    &glEdgeFlagPointerListIBM,
+    &glElementPointerAPPLE,
+    &glElementPointerATI,
+    &glEnableClientStateIndexedEXT,
+    &glEnableClientStateiEXT,
+    &glEnableIndexedEXT,
+    &glEnableVariantClientStateEXT,
+    &glEnableVertexArrayAttrib,
+    &glEnableVertexArrayAttribEXT,
+    &glEnableVertexArrayEXT,
+    &glEnableVertexAttribAPPLE,
+    &glEnableVertexAttribArray,
+    &glEnableVertexAttribArrayARB,
+    &glEnablei,
+    &glEndConditionalRender,
+    &glEndConditionalRenderNV,
+    &glEndConditionalRenderNVX,
+    &glEndFragmentShaderATI,
+    &glEndOcclusionQueryNV,
+    &glEndPerfMonitorAMD,
+    &glEndPerfQueryINTEL,
+    &glEndQuery,
+    &glEndQueryARB,
+    &glEndQueryIndexed,
+    &glEndTransformFeedback,
+    &glEndTransformFeedbackEXT,
+    &glEndTransformFeedbackNV,
+    &glEndVertexShaderEXT,
+    &glEndVideoCaptureNV,
+    &glEvalCoord1xOES,
+    &glEvalCoord1xvOES,
+    &glEvalCoord2xOES,
+    &glEvalCoord2xvOES,
+    &glEvalMapsNV,
+    &glEvaluateDepthValuesARB,
+    &glExecuteProgramNV,
+    &glExtractComponentEXT,
+    &glFeedbackBufferxOES,
+    &glFenceSync,
+    &glFinalCombinerInputNV,
+    &glFinishAsyncSGIX,
+    &glFinishFenceAPPLE,
+    &glFinishFenceNV,
+    &glFinishObjectAPPLE,
+    &glFinishTextureSUNX,
+    &glFlushMappedBufferRange,
+    &glFlushMappedBufferRangeAPPLE,
+    &glFlushMappedNamedBufferRange,
+    &glFlushMappedNamedBufferRangeEXT,
+    &glFlushPixelDataRangeNV,
+    &glFlushRasterSGIX,
+    &glFlushStaticDataIBM,
+    &glFlushVertexArrayRangeAPPLE,
+    &glFlushVertexArrayRangeNV,
+    &glFogCoordFormatNV,
+    &glFogCoordPointer,
+    &glFogCoordPointerEXT,
+    &glFogCoordPointerListIBM,
+    &glFogCoordd,
+    &glFogCoorddEXT,
+    &glFogCoorddv,
+    &glFogCoorddvEXT,
+    &glFogCoordf,
+    &glFogCoordfEXT,
+    &glFogCoordfv,
+    &glFogCoordfvEXT,
+    &glFogCoordhNV,
+    &glFogCoordhvNV,
+    &glFogFuncSGIS,
+    &glFogxOES,
+    &glFogxvOES,
+    &glFragmentColorMaterialSGIX,
+    &glFragmentCoverageColorNV,
+    &glFragmentLightModelfSGIX,
+    &glFragmentLightModelfvSGIX,
+    &glFragmentLightModeliSGIX,
+    &glFragmentLightModelivSGIX,
+    &glFragmentLightfSGIX,
+    &glFragmentLightfvSGIX,
+    &glFragmentLightiSGIX,
+    &glFragmentLightivSGIX,
+    &glFragmentMaterialfSGIX,
+    &glFragmentMaterialfvSGIX,
+    &glFragmentMaterialiSGIX,
+    &glFragmentMaterialivSGIX,
+    &glFrameTerminatorGREMEDY,
+    &glFrameZoomSGIX,
+    &glFramebufferDrawBufferEXT,
+    &glFramebufferDrawBuffersEXT,
+    &glFramebufferFetchBarrierEXT,
+    &glFramebufferParameteri,
+    &glFramebufferParameteriMESA,
+    &glFramebufferReadBufferEXT,
+    &glFramebufferRenderbuffer,
+    &glFramebufferRenderbufferEXT,
+    &glFramebufferSampleLocationsfvARB,
+    &glFramebufferSampleLocationsfvNV,
+    &glFramebufferSamplePositionsfvAMD,
+    &glFramebufferTexture,
+    &glFramebufferTexture1D,
+    &glFramebufferTexture1DEXT,
+    &glFramebufferTexture2D,
+    &glFramebufferTexture2DEXT,
+    &glFramebufferTexture3D,
+    &glFramebufferTexture3DEXT,
+    &glFramebufferTextureARB,
+    &glFramebufferTextureEXT,
+    &glFramebufferTextureFaceARB,
+    &glFramebufferTextureFaceEXT,
+    &glFramebufferTextureLayer,
+    &glFramebufferTextureLayerARB,
+    &glFramebufferTextureLayerEXT,
+    &glFramebufferTextureMultiviewOVR,
+    &glFreeObjectBufferATI,
+    &glFrustumfOES,
+    &glFrustumxOES,
+    &glGenAsyncMarkersSGIX,
+    &glGenBuffers,
+    &glGenBuffersARB,
+    &glGenFencesAPPLE,
+    &glGenFencesNV,
+    &glGenFragmentShadersATI,
+    &glGenFramebuffers,
+    &glGenFramebuffersEXT,
+    &glGenNamesAMD,
+    &glGenOcclusionQueriesNV,
+    &glGenPathsNV,
+    &glGenPerfMonitorsAMD,
+    &glGenProgramPipelines,
+    &glGenProgramsARB,
+    &glGenProgramsNV,
+    &glGenQueries,
+    &glGenQueriesARB,
+    &glGenQueryResourceTagNV,
+    &glGenRenderbuffers,
+    &glGenRenderbuffersEXT,
+    &glGenSamplers,
+    &glGenSemaphoresEXT,
+    &glGenSymbolsEXT,
+    &glGenTexturesEXT,
+    &glGenTransformFeedbacks,
+    &glGenTransformFeedbacksNV,
+    &glGenVertexArrays,
+    &glGenVertexArraysAPPLE,
+    &glGenVertexShadersEXT,
+    &glGenerateMipmap,
+    &glGenerateMipmapEXT,
+    &glGenerateMultiTexMipmapEXT,
+    &glGenerateTextureMipmap,
+    &glGenerateTextureMipmapEXT,
+    &glGetActiveAtomicCounterBufferiv,
+    &glGetActiveAttrib,
+    &glGetActiveAttribARB,
+    &glGetActiveSubroutineName,
+    &glGetActiveSubroutineUniformName,
+    &glGetActiveSubroutineUniformiv,
+    &glGetActiveUniform,
+    &glGetActiveUniformARB,
+    &glGetActiveUniformBlockName,
+    &glGetActiveUniformBlockiv,
+    &glGetActiveUniformName,
+    &glGetActiveUniformsiv,
+    &glGetActiveVaryingNV,
+    &glGetArrayObjectfvATI,
+    &glGetArrayObjectivATI,
+    &glGetAttachedObjectsARB,
+    &glGetAttachedShaders,
+    &glGetAttribLocation,
+    &glGetAttribLocationARB,
+    &glGetBooleanIndexedvEXT,
+    &glGetBooleani_v,
+    &glGetBufferParameteri64v,
+    &glGetBufferParameteriv,
+    &glGetBufferParameterivARB,
+    &glGetBufferParameterui64vNV,
+    &glGetBufferPointerv,
+    &glGetBufferPointervARB,
+    &glGetBufferSubData,
+    &glGetBufferSubDataARB,
+    &glGetClipPlanefOES,
+    &glGetClipPlanexOES,
+    &glGetColorTable,
+    &glGetColorTableEXT,
+    &glGetColorTableParameterfv,
+    &glGetColorTableParameterfvEXT,
+    &glGetColorTableParameterfvSGI,
+    &glGetColorTableParameteriv,
+    &glGetColorTableParameterivEXT,
+    &glGetColorTableParameterivSGI,
+    &glGetColorTableSGI,
+    &glGetCombinerInputParameterfvNV,
+    &glGetCombinerInputParameterivNV,
+    &glGetCombinerOutputParameterfvNV,
+    &glGetCombinerOutputParameterivNV,
+    &glGetCombinerStageParameterfvNV,
+    &glGetCommandHeaderNV,
+    &glGetCompressedMultiTexImageEXT,
+    &glGetCompressedTexImage,
+    &glGetCompressedTexImageARB,
+    &glGetCompressedTextureImage,
+    &glGetCompressedTextureImageEXT,
+    &glGetCompressedTextureSubImage,
+    &glGetConvolutionFilter,
+    &glGetConvolutionFilterEXT,
+    &glGetConvolutionParameterfv,
+    &glGetConvolutionParameterfvEXT,
+    &glGetConvolutionParameteriv,
+    &glGetConvolutionParameterivEXT,
+    &glGetConvolutionParameterxvOES,
+    &glGetCoverageModulationTableNV,
+    &glGetDebugMessageLog,
+    &glGetDebugMessageLogAMD,
+    &glGetDebugMessageLogARB,
+    &glGetDetailTexFuncSGIS,
+    &glGetDoubleIndexedvEXT,
+    &glGetDoublei_v,
+    &glGetDoublei_vEXT,
+    &glGetFenceivNV,
+    &glGetFinalCombinerInputParameterfvNV,
+    &glGetFinalCombinerInputParameterivNV,
+    &glGetFirstPerfQueryIdINTEL,
+    &glGetFixedvOES,
+    &glGetFloatIndexedvEXT,
+    &glGetFloati_v,
+    &glGetFloati_vEXT,
+    &glGetFogFuncSGIS,
+    &glGetFragDataIndex,
+    &glGetFragDataLocation,
+    &glGetFragDataLocationEXT,
+    &glGetFragmentLightfvSGIX,
+    &glGetFragmentLightivSGIX,
+    &glGetFragmentMaterialfvSGIX,
+    &glGetFragmentMaterialivSGIX,
+    &glGetFramebufferAttachmentParameteriv,
+    &glGetFramebufferAttachmentParameterivEXT,
+    &glGetFramebufferParameterfvAMD,
+    &glGetFramebufferParameteriv,
+    &glGetFramebufferParameterivEXT,
+    &glGetFramebufferParameterivMESA,
+    &glGetGraphicsResetStatus,
+    &glGetGraphicsResetStatusARB,
+    &glGetHandleARB,
+    &glGetHistogram,
+    &glGetHistogramEXT,
+    &glGetHistogramParameterfv,
+    &glGetHistogramParameterfvEXT,
+    &glGetHistogramParameteriv,
+    &glGetHistogramParameterivEXT,
+    &glGetHistogramParameterxvOES,
+    &glGetImageHandleARB,
+    &glGetImageHandleNV,
+    &glGetImageTransformParameterfvHP,
+    &glGetImageTransformParameterivHP,
+    &glGetInfoLogARB,
+    &glGetInstrumentsSGIX,
+    &glGetInteger64i_v,
+    &glGetInteger64v,
+    &glGetIntegerIndexedvEXT,
+    &glGetIntegeri_v,
+    &glGetIntegerui64i_vNV,
+    &glGetIntegerui64vNV,
+    &glGetInternalformatSampleivNV,
+    &glGetInternalformati64v,
+    &glGetInternalformativ,
+    &glGetInvariantBooleanvEXT,
+    &glGetInvariantFloatvEXT,
+    &glGetInvariantIntegervEXT,
+    &glGetLightxOES,
+    &glGetListParameterfvSGIX,
+    &glGetListParameterivSGIX,
+    &glGetLocalConstantBooleanvEXT,
+    &glGetLocalConstantFloatvEXT,
+    &glGetLocalConstantIntegervEXT,
+    &glGetMapAttribParameterfvNV,
+    &glGetMapAttribParameterivNV,
+    &glGetMapControlPointsNV,
+    &glGetMapParameterfvNV,
+    &glGetMapParameterivNV,
+    &glGetMapxvOES,
+    &glGetMaterialxOES,
+    &glGetMemoryObjectDetachedResourcesuivNV,
+    &glGetMemoryObjectParameterivEXT,
+    &glGetMinmax,
+    &glGetMinmaxEXT,
+    &glGetMinmaxParameterfv,
+    &glGetMinmaxParameterfvEXT,
+    &glGetMinmaxParameteriv,
+    &glGetMinmaxParameterivEXT,
+    &glGetMultiTexEnvfvEXT,
+    &glGetMultiTexEnvivEXT,
+    &glGetMultiTexGendvEXT,
+    &glGetMultiTexGenfvEXT,
+    &glGetMultiTexGenivEXT,
+    &glGetMultiTexImageEXT,
+    &glGetMultiTexLevelParameterfvEXT,
+    &glGetMultiTexLevelParameterivEXT,
+    &glGetMultiTexParameterIivEXT,
+    &glGetMultiTexParameterIuivEXT,
+    &glGetMultiTexParameterfvEXT,
+    &glGetMultiTexParameterivEXT,
+    &glGetMultisamplefv,
+    &glGetMultisamplefvNV,
+    &glGetNamedBufferParameteri64v,
+    &glGetNamedBufferParameteriv,
+    &glGetNamedBufferParameterivEXT,
+    &glGetNamedBufferParameterui64vNV,
+    &glGetNamedBufferPointerv,
+    &glGetNamedBufferPointervEXT,
+    &glGetNamedBufferSubData,
+    &glGetNamedBufferSubDataEXT,
+    &glGetNamedFramebufferAttachmentParameteriv,
+    &glGetNamedFramebufferAttachmentParameterivEXT,
+    &glGetNamedFramebufferParameterfvAMD,
+    &glGetNamedFramebufferParameteriv,
+    &glGetNamedFramebufferParameterivEXT,
+    &glGetNamedProgramLocalParameterIivEXT,
+    &glGetNamedProgramLocalParameterIuivEXT,
+    &glGetNamedProgramLocalParameterdvEXT,
+    &glGetNamedProgramLocalParameterfvEXT,
+    &glGetNamedProgramStringEXT,
+    &glGetNamedProgramivEXT,
+    &glGetNamedRenderbufferParameteriv,
+    &glGetNamedRenderbufferParameterivEXT,
+    &glGetNamedStringARB,
+    &glGetNamedStringivARB,
+    &glGetNextPerfQueryIdINTEL,
+    &glGetObjectBufferfvATI,
+    &glGetObjectBufferivATI,
+    &glGetObjectLabel,
+    &glGetObjectLabelEXT,
+    &glGetObjectParameterfvARB,
+    &glGetObjectParameterivAPPLE,
+    &glGetObjectParameterivARB,
+    &glGetObjectPtrLabel,
+    &glGetOcclusionQueryivNV,
+    &glGetOcclusionQueryuivNV,
+    &glGetPathColorGenfvNV,
+    &glGetPathColorGenivNV,
+    &glGetPathCommandsNV,
+    &glGetPathCoordsNV,
+    &glGetPathDashArrayNV,
+    &glGetPathLengthNV,
+    &glGetPathMetricRangeNV,
+    &glGetPathMetricsNV,
+    &glGetPathParameterfvNV,
+    &glGetPathParameterivNV,
+    &glGetPathSpacingNV,
+    &glGetPathTexGenfvNV,
+    &glGetPathTexGenivNV,
+    &glGetPerfCounterInfoINTEL,
+    &glGetPerfMonitorCounterDataAMD,
+    &glGetPerfMonitorCounterInfoAMD,
+    &glGetPerfMonitorCounterStringAMD,
+    &glGetPerfMonitorCountersAMD,
+    &glGetPerfMonitorGroupStringAMD,
+    &glGetPerfMonitorGroupsAMD,
+    &glGetPerfQueryDataINTEL,
+    &glGetPerfQueryIdByNameINTEL,
+    &glGetPerfQueryInfoINTEL,
+    &glGetPixelMapxv,
+    &glGetPixelTexGenParameterfvSGIS,
+    &glGetPixelTexGenParameterivSGIS,
+    &glGetPixelTransformParameterfvEXT,
+    &glGetPixelTransformParameterivEXT,
+    &glGetPointerIndexedvEXT,
+    &glGetPointeri_vEXT,
+    &glGetPointervEXT,
+    &glGetProgramBinary,
+    &glGetProgramEnvParameterIivNV,
+    &glGetProgramEnvParameterIuivNV,
+    &glGetProgramEnvParameterdvARB,
+    &glGetProgramEnvParameterfvARB,
+    &glGetProgramInfoLog,
+    &glGetProgramInterfaceiv,
+    &glGetProgramLocalParameterIivNV,
+    &glGetProgramLocalParameterIuivNV,
+    &glGetProgramLocalParameterdvARB,
+    &glGetProgramLocalParameterfvARB,
+    &glGetProgramNamedParameterdvNV,
+    &glGetProgramNamedParameterfvNV,
+    &glGetProgramParameterdvNV,
+    &glGetProgramParameterfvNV,
+    &glGetProgramPipelineInfoLog,
+    &glGetProgramPipelineiv,
+    &glGetProgramResourceIndex,
+    &glGetProgramResourceLocation,
+    &glGetProgramResourceLocationIndex,
+    &glGetProgramResourceName,
+    &glGetProgramResourcefvNV,
+    &glGetProgramResourceiv,
+    &glGetProgramStageiv,
+    &glGetProgramStringARB,
+    &glGetProgramStringNV,
+    &glGetProgramSubroutineParameteruivNV,
+    &glGetProgramiv,
+    &glGetProgramivARB,
+    &glGetProgramivNV,
+    &glGetQueryBufferObjecti64v,
+    &glGetQueryBufferObjectiv,
+    &glGetQueryBufferObjectui64v,
+    &glGetQueryBufferObjectuiv,
+    &glGetQueryIndexediv,
+    &glGetQueryObjecti64v,
+    &glGetQueryObjecti64vEXT,
+    &glGetQueryObjectiv,
+    &glGetQueryObjectivARB,
+    &glGetQueryObjectui64v,
+    &glGetQueryObjectui64vEXT,
+    &glGetQueryObjectuiv,
+    &glGetQueryObjectuivARB,
+    &glGetQueryiv,
+    &glGetQueryivARB,
+    &glGetRenderbufferParameteriv,
+    &glGetRenderbufferParameterivEXT,
+    &glGetSamplerParameterIiv,
+    &glGetSamplerParameterIuiv,
+    &glGetSamplerParameterfv,
+    &glGetSamplerParameteriv,
+    &glGetSemaphoreParameterui64vEXT,
+    &glGetSeparableFilter,
+    &glGetSeparableFilterEXT,
+    &glGetShaderInfoLog,
+    &glGetShaderPrecisionFormat,
+    &glGetShaderSource,
+    &glGetShaderSourceARB,
+    &glGetShaderiv,
+    &glGetShadingRateImagePaletteNV,
+    &glGetShadingRateSampleLocationivNV,
+    &glGetSharpenTexFuncSGIS,
+    &glGetStageIndexNV,
+    &glGetStringi,
+    &glGetSubroutineIndex,
+    &glGetSubroutineUniformLocation,
+    &glGetSynciv,
+    &glGetTexBumpParameterfvATI,
+    &glGetTexBumpParameterivATI,
+    &glGetTexEnvxvOES,
+    &glGetTexFilterFuncSGIS,
+    &glGetTexGenxvOES,
+    &glGetTexLevelParameterxvOES,
+    &glGetTexParameterIiv,
+    &glGetTexParameterIivEXT,
+    &glGetTexParameterIuiv,
+    &glGetTexParameterIuivEXT,
+    &glGetTexParameterPointervAPPLE,
+    &glGetTexParameterxvOES,
+    &glGetTextureHandleARB,
+    &glGetTextureHandleNV,
+    &glGetTextureImage,
+    &glGetTextureImageEXT,
+    &glGetTextureLevelParameterfv,
+    &glGetTextureLevelParameterfvEXT,
+    &glGetTextureLevelParameteriv,
+    &glGetTextureLevelParameterivEXT,
+    &glGetTextureParameterIiv,
+    &glGetTextureParameterIivEXT,
+    &glGetTextureParameterIuiv,
+    &glGetTextureParameterIuivEXT,
+    &glGetTextureParameterfv,
+    &glGetTextureParameterfvEXT,
+    &glGetTextureParameteriv,
+    &glGetTextureParameterivEXT,
+    &glGetTextureSamplerHandleARB,
+    &glGetTextureSamplerHandleNV,
+    &glGetTextureSubImage,
+    &glGetTrackMatrixivNV,
+    &glGetTransformFeedbackVarying,
+    &glGetTransformFeedbackVaryingEXT,
+    &glGetTransformFeedbackVaryingNV,
+    &glGetTransformFeedbacki64_v,
+    &glGetTransformFeedbacki_v,
+    &glGetTransformFeedbackiv,
+    &glGetUniformBlockIndex,
+    &glGetUniformBufferSizeEXT,
+    &glGetUniformIndices,
+    &glGetUniformLocation,
+    &glGetUniformLocationARB,
+    &glGetUniformOffsetEXT,
+    &glGetUniformSubroutineuiv,
+    &glGetUniformdv,
+    &glGetUniformfv,
+    &glGetUniformfvARB,
+    &glGetUniformi64vARB,
+    &glGetUniformi64vNV,
+    &glGetUniformiv,
+    &glGetUniformivARB,
+    &glGetUniformui64vARB,
+    &glGetUniformui64vNV,
+    &glGetUniformuiv,
+    &glGetUniformuivEXT,
+    &glGetUnsignedBytei_vEXT,
+    &glGetUnsignedBytevEXT,
+    &glGetVariantArrayObjectfvATI,
+    &glGetVariantArrayObjectivATI,
+    &glGetVariantBooleanvEXT,
+    &glGetVariantFloatvEXT,
+    &glGetVariantIntegervEXT,
+    &glGetVariantPointervEXT,
+    &glGetVaryingLocationNV,
+    &glGetVertexArrayIndexed64iv,
+    &glGetVertexArrayIndexediv,
+    &glGetVertexArrayIntegeri_vEXT,
+    &glGetVertexArrayIntegervEXT,
+    &glGetVertexArrayPointeri_vEXT,
+    &glGetVertexArrayPointervEXT,
+    &glGetVertexArrayiv,
+    &glGetVertexAttribArrayObjectfvATI,
+    &glGetVertexAttribArrayObjectivATI,
+    &glGetVertexAttribIiv,
+    &glGetVertexAttribIivEXT,
+    &glGetVertexAttribIuiv,
+    &glGetVertexAttribIuivEXT,
+    &glGetVertexAttribLdv,
+    &glGetVertexAttribLdvEXT,
+    &glGetVertexAttribLi64vNV,
+    &glGetVertexAttribLui64vARB,
+    &glGetVertexAttribLui64vNV,
+    &glGetVertexAttribPointerv,
+    &glGetVertexAttribPointervARB,
+    &glGetVertexAttribPointervNV,
+    &glGetVertexAttribdv,
+    &glGetVertexAttribdvARB,
+    &glGetVertexAttribdvNV,
+    &glGetVertexAttribfv,
+    &glGetVertexAttribfvARB,
+    &glGetVertexAttribfvNV,
+    &glGetVertexAttribiv,
+    &glGetVertexAttribivARB,
+    &glGetVertexAttribivNV,
+    &glGetVideoCaptureStreamdvNV,
+    &glGetVideoCaptureStreamfvNV,
+    &glGetVideoCaptureStreamivNV,
+    &glGetVideoCaptureivNV,
+    &glGetVideoi64vNV,
+    &glGetVideoivNV,
+    &glGetVideoui64vNV,
+    &glGetVideouivNV,
+    &glGetVkProcAddrNV,
+    &glGetnColorTable,
+    &glGetnColorTableARB,
+    &glGetnCompressedTexImage,
+    &glGetnCompressedTexImageARB,
+    &glGetnConvolutionFilter,
+    &glGetnConvolutionFilterARB,
+    &glGetnHistogram,
+    &glGetnHistogramARB,
+    &glGetnMapdv,
+    &glGetnMapdvARB,
+    &glGetnMapfv,
+    &glGetnMapfvARB,
+    &glGetnMapiv,
+    &glGetnMapivARB,
+    &glGetnMinmax,
+    &glGetnMinmaxARB,
+    &glGetnPixelMapfv,
+    &glGetnPixelMapfvARB,
+    &glGetnPixelMapuiv,
+    &glGetnPixelMapuivARB,
+    &glGetnPixelMapusv,
+    &glGetnPixelMapusvARB,
+    &glGetnPolygonStipple,
+    &glGetnPolygonStippleARB,
+    &glGetnSeparableFilter,
+    &glGetnSeparableFilterARB,
+    &glGetnTexImage,
+    &glGetnTexImageARB,
+    &glGetnUniformdv,
+    &glGetnUniformdvARB,
+    &glGetnUniformfv,
+    &glGetnUniformfvARB,
+    &glGetnUniformi64vARB,
+    &glGetnUniformiv,
+    &glGetnUniformivARB,
+    &glGetnUniformui64vARB,
+    &glGetnUniformuiv,
+    &glGetnUniformuivARB,
+    &glGlobalAlphaFactorbSUN,
+    &glGlobalAlphaFactordSUN,
+    &glGlobalAlphaFactorfSUN,
+    &glGlobalAlphaFactoriSUN,
+    &glGlobalAlphaFactorsSUN,
+    &glGlobalAlphaFactorubSUN,
+    &glGlobalAlphaFactoruiSUN,
+    &glGlobalAlphaFactorusSUN,
+    &glHintPGI,
+    &glHistogram,
+    &glHistogramEXT,
+    &glIglooInterfaceSGIX,
+    &glImageTransformParameterfHP,
+    &glImageTransformParameterfvHP,
+    &glImageTransformParameteriHP,
+    &glImageTransformParameterivHP,
+    &glImportMemoryFdEXT,
+    &glImportMemoryWin32HandleEXT,
+    &glImportMemoryWin32NameEXT,
+    &glImportSemaphoreFdEXT,
+    &glImportSemaphoreWin32HandleEXT,
+    &glImportSemaphoreWin32NameEXT,
+    &glImportSyncEXT,
+    &glIndexFormatNV,
+    &glIndexFuncEXT,
+    &glIndexMaterialEXT,
+    &glIndexPointerEXT,
+    &glIndexPointerListIBM,
+    &glIndexxOES,
+    &glIndexxvOES,
+    &glInsertComponentEXT,
+    &glInsertEventMarkerEXT,
+    &glInstrumentsBufferSGIX,
+    &glInterpolatePathsNV,
+    &glInvalidateBufferData,
+    &glInvalidateBufferSubData,
+    &glInvalidateFramebuffer,
+    &glInvalidateNamedFramebufferData,
+    &glInvalidateNamedFramebufferSubData,
+    &glInvalidateSubFramebuffer,
+    &glInvalidateTexImage,
+    &glInvalidateTexSubImage,
+    &glIsAsyncMarkerSGIX,
+    &glIsBuffer,
+    &glIsBufferARB,
+    &glIsBufferResidentNV,
+    &glIsCommandListNV,
+    &glIsEnabledIndexedEXT,
+    &glIsEnabledi,
+    &glIsFenceAPPLE,
+    &glIsFenceNV,
+    &glIsFramebuffer,
+    &glIsFramebufferEXT,
+    &glIsImageHandleResidentARB,
+    &glIsImageHandleResidentNV,
+    &glIsMemoryObjectEXT,
+    &glIsNameAMD,
+    &glIsNamedBufferResidentNV,
+    &glIsNamedStringARB,
+    &glIsObjectBufferATI,
+    &glIsOcclusionQueryNV,
+    &glIsPathNV,
+    &glIsPointInFillPathNV,
+    &glIsPointInStrokePathNV,
+    &glIsProgram,
+    &glIsProgramARB,
+    &glIsProgramNV,
+    &glIsProgramPipeline,
+    &glIsQuery,
+    &glIsQueryARB,
+    &glIsRenderbuffer,
+    &glIsRenderbufferEXT,
+    &glIsSampler,
+    &glIsSemaphoreEXT,
+    &glIsShader,
+    &glIsStateNV,
+    &glIsSync,
+    &glIsTextureEXT,
+    &glIsTextureHandleResidentARB,
+    &glIsTextureHandleResidentNV,
+    &glIsTransformFeedback,
+    &glIsTransformFeedbackNV,
+    &glIsVariantEnabledEXT,
+    &glIsVertexArray,
+    &glIsVertexArrayAPPLE,
+    &glIsVertexAttribEnabledAPPLE,
+    &glLGPUCopyImageSubDataNVX,
+    &glLGPUInterlockNVX,
+    &glLGPUNamedBufferSubDataNVX,
+    &glLabelObjectEXT,
+    &glLightEnviSGIX,
+    &glLightModelxOES,
+    &glLightModelxvOES,
+    &glLightxOES,
+    &glLightxvOES,
+    &glLineWidthxOES,
+    &glLinkProgram,
+    &glLinkProgramARB,
+    &glListDrawCommandsStatesClientNV,
+    &glListParameterfSGIX,
+    &glListParameterfvSGIX,
+    &glListParameteriSGIX,
+    &glListParameterivSGIX,
+    &glLoadIdentityDeformationMapSGIX,
+    &glLoadMatrixxOES,
+    &glLoadProgramNV,
+    &glLoadTransposeMatrixd,
+    &glLoadTransposeMatrixdARB,
+    &glLoadTransposeMatrixf,
+    &glLoadTransposeMatrixfARB,
+    &glLoadTransposeMatrixxOES,
+    &glLockArraysEXT,
+    &glMTexCoord2fSGIS,
+    &glMTexCoord2fvSGIS,
+    &glMakeBufferNonResidentNV,
+    &glMakeBufferResidentNV,
+    &glMakeImageHandleNonResidentARB,
+    &glMakeImageHandleNonResidentNV,
+    &glMakeImageHandleResidentARB,
+    &glMakeImageHandleResidentNV,
+    &glMakeNamedBufferNonResidentNV,
+    &glMakeNamedBufferResidentNV,
+    &glMakeTextureHandleNonResidentARB,
+    &glMakeTextureHandleNonResidentNV,
+    &glMakeTextureHandleResidentARB,
+    &glMakeTextureHandleResidentNV,
+    &glMap1xOES,
+    &glMap2xOES,
+    &glMapBuffer,
+    &glMapBufferARB,
+    &glMapBufferRange,
+    &glMapControlPointsNV,
+    &glMapGrid1xOES,
+    &glMapGrid2xOES,
+    &glMapNamedBuffer,
+    &glMapNamedBufferEXT,
+    &glMapNamedBufferRange,
+    &glMapNamedBufferRangeEXT,
+    &glMapObjectBufferATI,
+    &glMapParameterfvNV,
+    &glMapParameterivNV,
+    &glMapTexture2DINTEL,
+    &glMapVertexAttrib1dAPPLE,
+    &glMapVertexAttrib1fAPPLE,
+    &glMapVertexAttrib2dAPPLE,
+    &glMapVertexAttrib2fAPPLE,
+    &glMaterialxOES,
+    &glMaterialxvOES,
+    &glMatrixFrustumEXT,
+    &glMatrixIndexPointerARB,
+    &glMatrixIndexubvARB,
+    &glMatrixIndexuivARB,
+    &glMatrixIndexusvARB,
+    &glMatrixLoad3x2fNV,
+    &glMatrixLoad3x3fNV,
+    &glMatrixLoadIdentityEXT,
+    &glMatrixLoadTranspose3x3fNV,
+    &glMatrixLoadTransposedEXT,
+    &glMatrixLoadTransposefEXT,
+    &glMatrixLoaddEXT,
+    &glMatrixLoadfEXT,
+    &glMatrixMult3x2fNV,
+    &glMatrixMult3x3fNV,
+    &glMatrixMultTranspose3x3fNV,
+    &glMatrixMultTransposedEXT,
+    &glMatrixMultTransposefEXT,
+    &glMatrixMultdEXT,
+    &glMatrixMultfEXT,
+    &glMatrixOrthoEXT,
+    &glMatrixPopEXT,
+    &glMatrixPushEXT,
+    &glMatrixRotatedEXT,
+    &glMatrixRotatefEXT,
+    &glMatrixScaledEXT,
+    &glMatrixScalefEXT,
+    &glMatrixTranslatedEXT,
+    &glMatrixTranslatefEXT,
+    &glMaxShaderCompilerThreadsARB,
+    &glMaxShaderCompilerThreadsKHR,
+    &glMemoryBarrier,
+    &glMemoryBarrierByRegion,
+    &glMemoryBarrierEXT,
+    &glMemoryObjectParameterivEXT,
+    &glMinSampleShading,
+    &glMinSampleShadingARB,
+    &glMinmax,
+    &glMinmaxEXT,
+    &glMultMatrixxOES,
+    &glMultTransposeMatrixd,
+    &glMultTransposeMatrixdARB,
+    &glMultTransposeMatrixf,
+    &glMultTransposeMatrixfARB,
+    &glMultTransposeMatrixxOES,
+    &glMultiDrawArrays,
+    &glMultiDrawArraysEXT,
+    &glMultiDrawArraysIndirect,
+    &glMultiDrawArraysIndirectAMD,
+    &glMultiDrawArraysIndirectBindlessCountNV,
+    &glMultiDrawArraysIndirectBindlessNV,
+    &glMultiDrawArraysIndirectCount,
+    &glMultiDrawArraysIndirectCountARB,
+    &glMultiDrawElementArrayAPPLE,
+    &glMultiDrawElements,
+    &glMultiDrawElementsBaseVertex,
+    &glMultiDrawElementsEXT,
+    &glMultiDrawElementsIndirect,
+    &glMultiDrawElementsIndirectAMD,
+    &glMultiDrawElementsIndirectBindlessCountNV,
+    &glMultiDrawElementsIndirectBindlessNV,
+    &glMultiDrawElementsIndirectCount,
+    &glMultiDrawElementsIndirectCountARB,
+    &glMultiDrawMeshTasksIndirectCountNV,
+    &glMultiDrawMeshTasksIndirectNV,
+    &glMultiDrawRangeElementArrayAPPLE,
+    &glMultiModeDrawArraysIBM,
+    &glMultiModeDrawElementsIBM,
+    &glMultiTexBufferEXT,
+    &glMultiTexCoord1bOES,
+    &glMultiTexCoord1bvOES,
+    &glMultiTexCoord1d,
+    &glMultiTexCoord1dARB,
+    &glMultiTexCoord1dSGIS,
+    &glMultiTexCoord1dv,
+    &glMultiTexCoord1dvARB,
+    &glMultiTexCoord1dvSGIS,
+    &glMultiTexCoord1f,
+    &glMultiTexCoord1fARB,
+    &glMultiTexCoord1fSGIS,
+    &glMultiTexCoord1fv,
+    &glMultiTexCoord1fvARB,
+    &glMultiTexCoord1fvSGIS,
+    &glMultiTexCoord1hNV,
+    &glMultiTexCoord1hvNV,
+    &glMultiTexCoord1i,
+    &glMultiTexCoord1iARB,
+    &glMultiTexCoord1iSGIS,
+    &glMultiTexCoord1iv,
+    &glMultiTexCoord1ivARB,
+    &glMultiTexCoord1ivSGIS,
+    &glMultiTexCoord1s,
+    &glMultiTexCoord1sARB,
+    &glMultiTexCoord1sSGIS,
+    &glMultiTexCoord1sv,
+    &glMultiTexCoord1svARB,
+    &glMultiTexCoord1svSGIS,
+    &glMultiTexCoord1xOES,
+    &glMultiTexCoord1xvOES,
+    &glMultiTexCoord2bOES,
+    &glMultiTexCoord2bvOES,
+    &glMultiTexCoord2d,
+    &glMultiTexCoord2dARB,
+    &glMultiTexCoord2dSGIS,
+    &glMultiTexCoord2dv,
+    &glMultiTexCoord2dvARB,
+    &glMultiTexCoord2dvSGIS,
+    &glMultiTexCoord2f,
+    &glMultiTexCoord2fARB,
+    &glMultiTexCoord2fSGIS,
+    &glMultiTexCoord2fv,
+    &glMultiTexCoord2fvARB,
+    &glMultiTexCoord2fvSGIS,
+    &glMultiTexCoord2hNV,
+    &glMultiTexCoord2hvNV,
+    &glMultiTexCoord2i,
+    &glMultiTexCoord2iARB,
+    &glMultiTexCoord2iSGIS,
+    &glMultiTexCoord2iv,
+    &glMultiTexCoord2ivARB,
+    &glMultiTexCoord2ivSGIS,
+    &glMultiTexCoord2s,
+    &glMultiTexCoord2sARB,
+    &glMultiTexCoord2sSGIS,
+    &glMultiTexCoord2sv,
+    &glMultiTexCoord2svARB,
+    &glMultiTexCoord2svSGIS,
+    &glMultiTexCoord2xOES,
+    &glMultiTexCoord2xvOES,
+    &glMultiTexCoord3bOES,
+    &glMultiTexCoord3bvOES,
+    &glMultiTexCoord3d,
+    &glMultiTexCoord3dARB,
+    &glMultiTexCoord3dSGIS,
+    &glMultiTexCoord3dv,
+    &glMultiTexCoord3dvARB,
+    &glMultiTexCoord3dvSGIS,
+    &glMultiTexCoord3f,
+    &glMultiTexCoord3fARB,
+    &glMultiTexCoord3fSGIS,
+    &glMultiTexCoord3fv,
+    &glMultiTexCoord3fvARB,
+    &glMultiTexCoord3fvSGIS,
+    &glMultiTexCoord3hNV,
+    &glMultiTexCoord3hvNV,
+    &glMultiTexCoord3i,
+    &glMultiTexCoord3iARB,
+    &glMultiTexCoord3iSGIS,
+    &glMultiTexCoord3iv,
+    &glMultiTexCoord3ivARB,
+    &glMultiTexCoord3ivSGIS,
+    &glMultiTexCoord3s,
+    &glMultiTexCoord3sARB,
+    &glMultiTexCoord3sSGIS,
+    &glMultiTexCoord3sv,
+    &glMultiTexCoord3svARB,
+    &glMultiTexCoord3svSGIS,
+    &glMultiTexCoord3xOES,
+    &glMultiTexCoord3xvOES,
+    &glMultiTexCoord4bOES,
+    &glMultiTexCoord4bvOES,
+    &glMultiTexCoord4d,
+    &glMultiTexCoord4dARB,
+    &glMultiTexCoord4dSGIS,
+    &glMultiTexCoord4dv,
+    &glMultiTexCoord4dvARB,
+    &glMultiTexCoord4dvSGIS,
+    &glMultiTexCoord4f,
+    &glMultiTexCoord4fARB,
+    &glMultiTexCoord4fSGIS,
+    &glMultiTexCoord4fv,
+    &glMultiTexCoord4fvARB,
+    &glMultiTexCoord4fvSGIS,
+    &glMultiTexCoord4hNV,
+    &glMultiTexCoord4hvNV,
+    &glMultiTexCoord4i,
+    &glMultiTexCoord4iARB,
+    &glMultiTexCoord4iSGIS,
+    &glMultiTexCoord4iv,
+    &glMultiTexCoord4ivARB,
+    &glMultiTexCoord4ivSGIS,
+    &glMultiTexCoord4s,
+    &glMultiTexCoord4sARB,
+    &glMultiTexCoord4sSGIS,
+    &glMultiTexCoord4sv,
+    &glMultiTexCoord4svARB,
+    &glMultiTexCoord4svSGIS,
+    &glMultiTexCoord4xOES,
+    &glMultiTexCoord4xvOES,
+    &glMultiTexCoordP1ui,
+    &glMultiTexCoordP1uiv,
+    &glMultiTexCoordP2ui,
+    &glMultiTexCoordP2uiv,
+    &glMultiTexCoordP3ui,
+    &glMultiTexCoordP3uiv,
+    &glMultiTexCoordP4ui,
+    &glMultiTexCoordP4uiv,
+    &glMultiTexCoordPointerEXT,
+    &glMultiTexCoordPointerSGIS,
+    &glMultiTexEnvfEXT,
+    &glMultiTexEnvfvEXT,
+    &glMultiTexEnviEXT,
+    &glMultiTexEnvivEXT,
+    &glMultiTexGendEXT,
+    &glMultiTexGendvEXT,
+    &glMultiTexGenfEXT,
+    &glMultiTexGenfvEXT,
+    &glMultiTexGeniEXT,
+    &glMultiTexGenivEXT,
+    &glMultiTexImage1DEXT,
+    &glMultiTexImage2DEXT,
+    &glMultiTexImage3DEXT,
+    &glMultiTexParameterIivEXT,
+    &glMultiTexParameterIuivEXT,
+    &glMultiTexParameterfEXT,
+    &glMultiTexParameterfvEXT,
+    &glMultiTexParameteriEXT,
+    &glMultiTexParameterivEXT,
+    &glMultiTexRenderbufferEXT,
+    &glMultiTexSubImage1DEXT,
+    &glMultiTexSubImage2DEXT,
+    &glMultiTexSubImage3DEXT,
+    &glMulticastBarrierNV,
+    &glMulticastBlitFramebufferNV,
+    &glMulticastBufferSubDataNV,
+    &glMulticastCopyBufferSubDataNV,
+    &glMulticastCopyImageSubDataNV,
+    &glMulticastFramebufferSampleLocationsfvNV,
+    &glMulticastGetQueryObjecti64vNV,
+    &glMulticastGetQueryObjectivNV,
+    &glMulticastGetQueryObjectui64vNV,
+    &glMulticastGetQueryObjectuivNV,
+    &glMulticastScissorArrayvNVX,
+    &glMulticastViewportArrayvNVX,
+    &glMulticastViewportPositionWScaleNVX,
+    &glMulticastWaitSyncNV,
+    &glNamedBufferAttachMemoryNV,
+    &glNamedBufferData,
+    &glNamedBufferDataEXT,
+    &glNamedBufferPageCommitmentARB,
+    &glNamedBufferPageCommitmentEXT,
+    &glNamedBufferStorage,
+    &glNamedBufferStorageEXT,
+    &glNamedBufferStorageExternalEXT,
+    &glNamedBufferStorageMemEXT,
+    &glNamedBufferSubData,
+    &glNamedBufferSubDataEXT,
+    &glNamedCopyBufferSubDataEXT,
+    &glNamedFramebufferDrawBuffer,
+    &glNamedFramebufferDrawBuffers,
+    &glNamedFramebufferParameteri,
+    &glNamedFramebufferParameteriEXT,
+    &glNamedFramebufferReadBuffer,
+    &glNamedFramebufferRenderbuffer,
+    &glNamedFramebufferRenderbufferEXT,
+    &glNamedFramebufferSampleLocationsfvARB,
+    &glNamedFramebufferSampleLocationsfvNV,
+    &glNamedFramebufferSamplePositionsfvAMD,
+    &glNamedFramebufferTexture,
+    &glNamedFramebufferTexture1DEXT,
+    &glNamedFramebufferTexture2DEXT,
+    &glNamedFramebufferTexture3DEXT,
+    &glNamedFramebufferTextureEXT,
+    &glNamedFramebufferTextureFaceEXT,
+    &glNamedFramebufferTextureLayer,
+    &glNamedFramebufferTextureLayerEXT,
+    &glNamedProgramLocalParameter4dEXT,
+    &glNamedProgramLocalParameter4dvEXT,
+    &glNamedProgramLocalParameter4fEXT,
+    &glNamedProgramLocalParameter4fvEXT,
+    &glNamedProgramLocalParameterI4iEXT,
+    &glNamedProgramLocalParameterI4ivEXT,
+    &glNamedProgramLocalParameterI4uiEXT,
+    &glNamedProgramLocalParameterI4uivEXT,
+    &glNamedProgramLocalParameters4fvEXT,
+    &glNamedProgramLocalParametersI4ivEXT,
+    &glNamedProgramLocalParametersI4uivEXT,
+    &glNamedProgramStringEXT,
+    &glNamedRenderbufferStorage,
+    &glNamedRenderbufferStorageEXT,
+    &glNamedRenderbufferStorageMultisample,
+    &glNamedRenderbufferStorageMultisampleAdvancedAMD,
+    &glNamedRenderbufferStorageMultisampleCoverageEXT,
+    &glNamedRenderbufferStorageMultisampleEXT,
+    &glNamedStringARB,
+    &glNewBufferRegion,
+    &glNewObjectBufferATI,
+    &glNormal3fVertex3fSUN,
+    &glNormal3fVertex3fvSUN,
+    &glNormal3hNV,
+    &glNormal3hvNV,
+    &glNormal3xOES,
+    &glNormal3xvOES,
+    &glNormalFormatNV,
+    &glNormalP3ui,
+    &glNormalP3uiv,
+    &glNormalPointerEXT,
+    &glNormalPointerListIBM,
+    &glNormalPointervINTEL,
+    &glNormalStream3bATI,
+    &glNormalStream3bvATI,
+    &glNormalStream3dATI,
+    &glNormalStream3dvATI,
+    &glNormalStream3fATI,
+    &glNormalStream3fvATI,
+    &glNormalStream3iATI,
+    &glNormalStream3ivATI,
+    &glNormalStream3sATI,
+    &glNormalStream3svATI,
+    &glObjectLabel,
+    &glObjectPtrLabel,
+    &glObjectPurgeableAPPLE,
+    &glObjectUnpurgeableAPPLE,
+    &glOrthofOES,
+    &glOrthoxOES,
+    &glPNTrianglesfATI,
+    &glPNTrianglesiATI,
+    &glPassTexCoordATI,
+    &glPassThroughxOES,
+    &glPatchParameterfv,
+    &glPatchParameteri,
+    &glPathColorGenNV,
+    &glPathCommandsNV,
+    &glPathCoordsNV,
+    &glPathCoverDepthFuncNV,
+    &glPathDashArrayNV,
+    &glPathFogGenNV,
+    &glPathGlyphIndexArrayNV,
+    &glPathGlyphIndexRangeNV,
+    &glPathGlyphRangeNV,
+    &glPathGlyphsNV,
+    &glPathMemoryGlyphIndexArrayNV,
+    &glPathParameterfNV,
+    &glPathParameterfvNV,
+    &glPathParameteriNV,
+    &glPathParameterivNV,
+    &glPathStencilDepthOffsetNV,
+    &glPathStencilFuncNV,
+    &glPathStringNV,
+    &glPathSubCommandsNV,
+    &glPathSubCoordsNV,
+    &glPathTexGenNV,
+    &glPauseTransformFeedback,
+    &glPauseTransformFeedbackNV,
+    &glPixelDataRangeNV,
+    &glPixelMapx,
+    &glPixelStorex,
+    &glPixelTexGenParameterfSGIS,
+    &glPixelTexGenParameterfvSGIS,
+    &glPixelTexGenParameteriSGIS,
+    &glPixelTexGenParameterivSGIS,
+    &glPixelTexGenSGIX,
+    &glPixelTransferxOES,
+    &glPixelTransformParameterfEXT,
+    &glPixelTransformParameterfvEXT,
+    &glPixelTransformParameteriEXT,
+    &glPixelTransformParameterivEXT,
+    &glPixelZoomxOES,
+    &glPointAlongPathNV,
+    &glPointParameterf,
+    &glPointParameterfARB,
+    &glPointParameterfEXT,
+    &glPointParameterfSGIS,
+    &glPointParameterfv,
+    &glPointParameterfvARB,
+    &glPointParameterfvEXT,
+    &glPointParameterfvSGIS,
+    &glPointParameteri,
+    &glPointParameteriNV,
+    &glPointParameteriv,
+    &glPointParameterivNV,
+    &glPointParameterxvOES,
+    &glPointSizexOES,
+    &glPollAsyncSGIX,
+    &glPollInstrumentsSGIX,
+    &glPolygonOffsetClamp,
+    &glPolygonOffsetClampEXT,
+    &glPolygonOffsetEXT,
+    &glPolygonOffsetxOES,
+    &glPopDebugGroup,
+    &glPopGroupMarkerEXT,
+    &glPresentFrameDualFillNV,
+    &glPresentFrameKeyedNV,
+    &glPrimitiveBoundingBoxARB,
+    &glPrimitiveRestartIndex,
+    &glPrimitiveRestartIndexNV,
+    &glPrimitiveRestartNV,
+    &glPrioritizeTexturesEXT,
+    &glPrioritizeTexturesxOES,
+    &glProgramBinary,
+    &glProgramBufferParametersIivNV,
+    &glProgramBufferParametersIuivNV,
+    &glProgramBufferParametersfvNV,
+    &glProgramEnvParameter4dARB,
+    &glProgramEnvParameter4dvARB,
+    &glProgramEnvParameter4fARB,
+    &glProgramEnvParameter4fvARB,
+    &glProgramEnvParameterI4iNV,
+    &glProgramEnvParameterI4ivNV,
+    &glProgramEnvParameterI4uiNV,
+    &glProgramEnvParameterI4uivNV,
+    &glProgramEnvParameters4fvEXT,
+    &glProgramEnvParametersI4ivNV,
+    &glProgramEnvParametersI4uivNV,
+    &glProgramLocalParameter4dARB,
+    &glProgramLocalParameter4dvARB,
+    &glProgramLocalParameter4fARB,
+    &glProgramLocalParameter4fvARB,
+    &glProgramLocalParameterI4iNV,
+    &glProgramLocalParameterI4ivNV,
+    &glProgramLocalParameterI4uiNV,
+    &glProgramLocalParameterI4uivNV,
+    &glProgramLocalParameters4fvEXT,
+    &glProgramLocalParametersI4ivNV,
+    &glProgramLocalParametersI4uivNV,
+    &glProgramNamedParameter4dNV,
+    &glProgramNamedParameter4dvNV,
+    &glProgramNamedParameter4fNV,
+    &glProgramNamedParameter4fvNV,
+    &glProgramParameter4dNV,
+    &glProgramParameter4dvNV,
+    &glProgramParameter4fNV,
+    &glProgramParameter4fvNV,
+    &glProgramParameteri,
+    &glProgramParameteriARB,
+    &glProgramParameteriEXT,
+    &glProgramParameters4dvNV,
+    &glProgramParameters4fvNV,
+    &glProgramPathFragmentInputGenNV,
+    &glProgramStringARB,
+    &glProgramSubroutineParametersuivNV,
+    &glProgramUniform1d,
+    &glProgramUniform1dEXT,
+    &glProgramUniform1dv,
+    &glProgramUniform1dvEXT,
+    &glProgramUniform1f,
+    &glProgramUniform1fEXT,
+    &glProgramUniform1fv,
+    &glProgramUniform1fvEXT,
+    &glProgramUniform1i,
+    &glProgramUniform1i64ARB,
+    &glProgramUniform1i64NV,
+    &glProgramUniform1i64vARB,
+    &glProgramUniform1i64vNV,
+    &glProgramUniform1iEXT,
+    &glProgramUniform1iv,
+    &glProgramUniform1ivEXT,
+    &glProgramUniform1ui,
+    &glProgramUniform1ui64ARB,
+    &glProgramUniform1ui64NV,
+    &glProgramUniform1ui64vARB,
+    &glProgramUniform1ui64vNV,
+    &glProgramUniform1uiEXT,
+    &glProgramUniform1uiv,
+    &glProgramUniform1uivEXT,
+    &glProgramUniform2d,
+    &glProgramUniform2dEXT,
+    &glProgramUniform2dv,
+    &glProgramUniform2dvEXT,
+    &glProgramUniform2f,
+    &glProgramUniform2fEXT,
+    &glProgramUniform2fv,
+    &glProgramUniform2fvEXT,
+    &glProgramUniform2i,
+    &glProgramUniform2i64ARB,
+    &glProgramUniform2i64NV,
+    &glProgramUniform2i64vARB,
+    &glProgramUniform2i64vNV,
+    &glProgramUniform2iEXT,
+    &glProgramUniform2iv,
+    &glProgramUniform2ivEXT,
+    &glProgramUniform2ui,
+    &glProgramUniform2ui64ARB,
+    &glProgramUniform2ui64NV,
+    &glProgramUniform2ui64vARB,
+    &glProgramUniform2ui64vNV,
+    &glProgramUniform2uiEXT,
+    &glProgramUniform2uiv,
+    &glProgramUniform2uivEXT,
+    &glProgramUniform3d,
+    &glProgramUniform3dEXT,
+    &glProgramUniform3dv,
+    &glProgramUniform3dvEXT,
+    &glProgramUniform3f,
+    &glProgramUniform3fEXT,
+    &glProgramUniform3fv,
+    &glProgramUniform3fvEXT,
+    &glProgramUniform3i,
+    &glProgramUniform3i64ARB,
+    &glProgramUniform3i64NV,
+    &glProgramUniform3i64vARB,
+    &glProgramUniform3i64vNV,
+    &glProgramUniform3iEXT,
+    &glProgramUniform3iv,
+    &glProgramUniform3ivEXT,
+    &glProgramUniform3ui,
+    &glProgramUniform3ui64ARB,
+    &glProgramUniform3ui64NV,
+    &glProgramUniform3ui64vARB,
+    &glProgramUniform3ui64vNV,
+    &glProgramUniform3uiEXT,
+    &glProgramUniform3uiv,
+    &glProgramUniform3uivEXT,
+    &glProgramUniform4d,
+    &glProgramUniform4dEXT,
+    &glProgramUniform4dv,
+    &glProgramUniform4dvEXT,
+    &glProgramUniform4f,
+    &glProgramUniform4fEXT,
+    &glProgramUniform4fv,
+    &glProgramUniform4fvEXT,
+    &glProgramUniform4i,
+    &glProgramUniform4i64ARB,
+    &glProgramUniform4i64NV,
+    &glProgramUniform4i64vARB,
+    &glProgramUniform4i64vNV,
+    &glProgramUniform4iEXT,
+    &glProgramUniform4iv,
+    &glProgramUniform4ivEXT,
+    &glProgramUniform4ui,
+    &glProgramUniform4ui64ARB,
+    &glProgramUniform4ui64NV,
+    &glProgramUniform4ui64vARB,
+    &glProgramUniform4ui64vNV,
+    &glProgramUniform4uiEXT,
+    &glProgramUniform4uiv,
+    &glProgramUniform4uivEXT,
+    &glProgramUniformHandleui64ARB,
+    &glProgramUniformHandleui64NV,
+    &glProgramUniformHandleui64vARB,
+    &glProgramUniformHandleui64vNV,
+    &glProgramUniformMatrix2dv,
+    &glProgramUniformMatrix2dvEXT,
+    &glProgramUniformMatrix2fv,
+    &glProgramUniformMatrix2fvEXT,
+    &glProgramUniformMatrix2x3dv,
+    &glProgramUniformMatrix2x3dvEXT,
+    &glProgramUniformMatrix2x3fv,
+    &glProgramUniformMatrix2x3fvEXT,
+    &glProgramUniformMatrix2x4dv,
+    &glProgramUniformMatrix2x4dvEXT,
+    &glProgramUniformMatrix2x4fv,
+    &glProgramUniformMatrix2x4fvEXT,
+    &glProgramUniformMatrix3dv,
+    &glProgramUniformMatrix3dvEXT,
+    &glProgramUniformMatrix3fv,
+    &glProgramUniformMatrix3fvEXT,
+    &glProgramUniformMatrix3x2dv,
+    &glProgramUniformMatrix3x2dvEXT,
+    &glProgramUniformMatrix3x2fv,
+    &glProgramUniformMatrix3x2fvEXT,
+    &glProgramUniformMatrix3x4dv,
+    &glProgramUniformMatrix3x4dvEXT,
+    &glProgramUniformMatrix3x4fv,
+    &glProgramUniformMatrix3x4fvEXT,
+    &glProgramUniformMatrix4dv,
+    &glProgramUniformMatrix4dvEXT,
+    &glProgramUniformMatrix4fv,
+    &glProgramUniformMatrix4fvEXT,
+    &glProgramUniformMatrix4x2dv,
+    &glProgramUniformMatrix4x2dvEXT,
+    &glProgramUniformMatrix4x2fv,
+    &glProgramUniformMatrix4x2fvEXT,
+    &glProgramUniformMatrix4x3dv,
+    &glProgramUniformMatrix4x3dvEXT,
+    &glProgramUniformMatrix4x3fv,
+    &glProgramUniformMatrix4x3fvEXT,
+    &glProgramUniformui64NV,
+    &glProgramUniformui64vNV,
+    &glProgramVertexLimitNV,
+    &glProvokingVertex,
+    &glProvokingVertexEXT,
+    &glPushClientAttribDefaultEXT,
+    &glPushDebugGroup,
+    &glPushGroupMarkerEXT,
+    &glQueryCounter,
+    &glQueryMatrixxOES,
+    &glQueryObjectParameteruiAMD,
+    &glQueryResourceNV,
+    &glQueryResourceTagNV,
+    &glRasterPos2xOES,
+    &glRasterPos2xvOES,
+    &glRasterPos3xOES,
+    &glRasterPos3xvOES,
+    &glRasterPos4xOES,
+    &glRasterPos4xvOES,
+    &glRasterSamplesEXT,
+    &glReadBufferRegion,
+    &glReadInstrumentsSGIX,
+    &glReadnPixels,
+    &glReadnPixelsARB,
+    &glRectxOES,
+    &glRectxvOES,
+    &glReferencePlaneSGIX,
+    &glReleaseKeyedMutexWin32EXT,
+    &glReleaseShaderCompiler,
+    &glRenderGpuMaskNV,
+    &glRenderbufferStorage,
+    &glRenderbufferStorageEXT,
+    &glRenderbufferStorageMultisample,
+    &glRenderbufferStorageMultisampleAdvancedAMD,
+    &glRenderbufferStorageMultisampleCoverageNV,
+    &glRenderbufferStorageMultisampleEXT,
+    &glReplacementCodePointerSUN,
+    &glReplacementCodeubSUN,
+    &glReplacementCodeubvSUN,
+    &glReplacementCodeuiColor3fVertex3fSUN,
+    &glReplacementCodeuiColor3fVertex3fvSUN,
+    &glReplacementCodeuiColor4fNormal3fVertex3fSUN,
+    &glReplacementCodeuiColor4fNormal3fVertex3fvSUN,
+    &glReplacementCodeuiColor4ubVertex3fSUN,
+    &glReplacementCodeuiColor4ubVertex3fvSUN,
+    &glReplacementCodeuiNormal3fVertex3fSUN,
+    &glReplacementCodeuiNormal3fVertex3fvSUN,
+    &glReplacementCodeuiSUN,
+    &glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN,
+    &glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN,
+    &glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN,
+    &glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN,
+    &glReplacementCodeuiTexCoord2fVertex3fSUN,
+    &glReplacementCodeuiTexCoord2fVertex3fvSUN,
+    &glReplacementCodeuiVertex3fSUN,
+    &glReplacementCodeuiVertex3fvSUN,
+    &glReplacementCodeuivSUN,
+    &glReplacementCodeusSUN,
+    &glReplacementCodeusvSUN,
+    &glRequestResidentProgramsNV,
+    &glResetHistogram,
+    &glResetHistogramEXT,
+    &glResetMemoryObjectParameterNV,
+    &glResetMinmax,
+    &glResetMinmaxEXT,
+    &glResizeBuffersMESA,
+    &glResolveDepthValuesNV,
+    &glResumeTransformFeedback,
+    &glResumeTransformFeedbackNV,
+    &glRotatexOES,
+    &glSampleCoverage,
+    &glSampleCoverageARB,
+    &glSampleMapATI,
+    &glSampleMaskEXT,
+    &glSampleMaskIndexedNV,
+    &glSampleMaskSGIS,
+    &glSampleMaski,
+    &glSamplePatternEXT,
+    &glSamplePatternSGIS,
+    &glSamplerParameterIiv,
+    &glSamplerParameterIuiv,
+    &glSamplerParameterf,
+    &glSamplerParameterfv,
+    &glSamplerParameteri,
+    &glSamplerParameteriv,
+    &glScalexOES,
+    &glScissorArrayv,
+    &glScissorExclusiveArrayvNV,
+    &glScissorExclusiveNV,
+    &glScissorIndexed,
+    &glScissorIndexedv,
+    &glSecondaryColor3b,
+    &glSecondaryColor3bEXT,
+    &glSecondaryColor3bv,
+    &glSecondaryColor3bvEXT,
+    &glSecondaryColor3d,
+    &glSecondaryColor3dEXT,
+    &glSecondaryColor3dv,
+    &glSecondaryColor3dvEXT,
+    &glSecondaryColor3f,
+    &glSecondaryColor3fEXT,
+    &glSecondaryColor3fv,
+    &glSecondaryColor3fvEXT,
+    &glSecondaryColor3hNV,
+    &glSecondaryColor3hvNV,
+    &glSecondaryColor3i,
+    &glSecondaryColor3iEXT,
+    &glSecondaryColor3iv,
+    &glSecondaryColor3ivEXT,
+    &glSecondaryColor3s,
+    &glSecondaryColor3sEXT,
+    &glSecondaryColor3sv,
+    &glSecondaryColor3svEXT,
+    &glSecondaryColor3ub,
+    &glSecondaryColor3ubEXT,
+    &glSecondaryColor3ubv,
+    &glSecondaryColor3ubvEXT,
+    &glSecondaryColor3ui,
+    &glSecondaryColor3uiEXT,
+    &glSecondaryColor3uiv,
+    &glSecondaryColor3uivEXT,
+    &glSecondaryColor3us,
+    &glSecondaryColor3usEXT,
+    &glSecondaryColor3usv,
+    &glSecondaryColor3usvEXT,
+    &glSecondaryColorFormatNV,
+    &glSecondaryColorP3ui,
+    &glSecondaryColorP3uiv,
+    &glSecondaryColorPointer,
+    &glSecondaryColorPointerEXT,
+    &glSecondaryColorPointerListIBM,
+    &glSelectPerfMonitorCountersAMD,
+    &glSelectTextureCoordSetSGIS,
+    &glSelectTextureSGIS,
+    &glSemaphoreParameterui64vEXT,
+    &glSeparableFilter2D,
+    &glSeparableFilter2DEXT,
+    &glSetFenceAPPLE,
+    &glSetFenceNV,
+    &glSetFragmentShaderConstantATI,
+    &glSetInvariantEXT,
+    &glSetLocalConstantEXT,
+    &glSetMultisamplefvAMD,
+    &glShaderBinary,
+    &glShaderOp1EXT,
+    &glShaderOp2EXT,
+    &glShaderOp3EXT,
+    &glShaderSource,
+    &glShaderSourceARB,
+    &glShaderStorageBlockBinding,
+    &glShadingRateImageBarrierNV,
+    &glShadingRateImagePaletteNV,
+    &glShadingRateSampleOrderCustomNV,
+    &glShadingRateSampleOrderNV,
+    &glSharpenTexFuncSGIS,
+    &glSignalSemaphoreEXT,
+    &glSignalSemaphoreui64NVX,
+    &glSignalVkFenceNV,
+    &glSignalVkSemaphoreNV,
+    &glSpecializeShader,
+    &glSpecializeShaderARB,
+    &glSpriteParameterfSGIX,
+    &glSpriteParameterfvSGIX,
+    &glSpriteParameteriSGIX,
+    &glSpriteParameterivSGIX,
+    &glStartInstrumentsSGIX,
+    &glStateCaptureNV,
+    &glStencilClearTagEXT,
+    &glStencilFillPathInstancedNV,
+    &glStencilFillPathNV,
+    &glStencilFuncSeparate,
+    &glStencilFuncSeparateATI,
+    &glStencilMaskSeparate,
+    &glStencilOpSeparate,
+    &glStencilOpSeparateATI,
+    &glStencilOpValueAMD,
+    &glStencilStrokePathInstancedNV,
+    &glStencilStrokePathNV,
+    &glStencilThenCoverFillPathInstancedNV,
+    &glStencilThenCoverFillPathNV,
+    &glStencilThenCoverStrokePathInstancedNV,
+    &glStencilThenCoverStrokePathNV,
+    &glStopInstrumentsSGIX,
+    &glStringMarkerGREMEDY,
+    &glSubpixelPrecisionBiasNV,
+    &glSwizzleEXT,
+    &glSyncTextureINTEL,
+    &glTagSampleBufferSGIX,
+    &glTangent3bEXT,
+    &glTangent3bvEXT,
+    &glTangent3dEXT,
+    &glTangent3dvEXT,
+    &glTangent3fEXT,
+    &glTangent3fvEXT,
+    &glTangent3iEXT,
+    &glTangent3ivEXT,
+    &glTangent3sEXT,
+    &glTangent3svEXT,
+    &glTangentPointerEXT,
+    &glTbufferMask3DFX,
+    &glTessellationFactorAMD,
+    &glTessellationModeAMD,
+    &glTestFenceAPPLE,
+    &glTestFenceNV,
+    &glTestObjectAPPLE,
+    &glTexAttachMemoryNV,
+    &glTexBuffer,
+    &glTexBufferARB,
+    &glTexBufferEXT,
+    &glTexBufferRange,
+    &glTexBumpParameterfvATI,
+    &glTexBumpParameterivATI,
+    &glTexCoord1bOES,
+    &glTexCoord1bvOES,
+    &glTexCoord1hNV,
+    &glTexCoord1hvNV,
+    &glTexCoord1xOES,
+    &glTexCoord1xvOES,
+    &glTexCoord2bOES,
+    &glTexCoord2bvOES,
+    &glTexCoord2fColor3fVertex3fSUN,
+    &glTexCoord2fColor3fVertex3fvSUN,
+    &glTexCoord2fColor4fNormal3fVertex3fSUN,
+    &glTexCoord2fColor4fNormal3fVertex3fvSUN,
+    &glTexCoord2fColor4ubVertex3fSUN,
+    &glTexCoord2fColor4ubVertex3fvSUN,
+    &glTexCoord2fNormal3fVertex3fSUN,
+    &glTexCoord2fNormal3fVertex3fvSUN,
+    &glTexCoord2fVertex3fSUN,
+    &glTexCoord2fVertex3fvSUN,
+    &glTexCoord2hNV,
+    &glTexCoord2hvNV,
+    &glTexCoord2xOES,
+    &glTexCoord2xvOES,
+    &glTexCoord3bOES,
+    &glTexCoord3bvOES,
+    &glTexCoord3hNV,
+    &glTexCoord3hvNV,
+    &glTexCoord3xOES,
+    &glTexCoord3xvOES,
+    &glTexCoord4bOES,
+    &glTexCoord4bvOES,
+    &glTexCoord4fColor4fNormal3fVertex4fSUN,
+    &glTexCoord4fColor4fNormal3fVertex4fvSUN,
+    &glTexCoord4fVertex4fSUN,
+    &glTexCoord4fVertex4fvSUN,
+    &glTexCoord4hNV,
+    &glTexCoord4hvNV,
+    &glTexCoord4xOES,
+    &glTexCoord4xvOES,
+    &glTexCoordFormatNV,
+    &glTexCoordP1ui,
+    &glTexCoordP1uiv,
+    &glTexCoordP2ui,
+    &glTexCoordP2uiv,
+    &glTexCoordP3ui,
+    &glTexCoordP3uiv,
+    &glTexCoordP4ui,
+    &glTexCoordP4uiv,
+    &glTexCoordPointerEXT,
+    &glTexCoordPointerListIBM,
+    &glTexCoordPointervINTEL,
+    &glTexEnvxOES,
+    &glTexEnvxvOES,
+    &glTexFilterFuncSGIS,
+    &glTexGenxOES,
+    &glTexGenxvOES,
+    &glTexImage2DMultisample,
+    &glTexImage2DMultisampleCoverageNV,
+    &glTexImage3D,
+    &glTexImage3DEXT,
+    &glTexImage3DMultisample,
+    &glTexImage3DMultisampleCoverageNV,
+    &glTexImage4DSGIS,
+    &glTexPageCommitmentARB,
+    &glTexParameterIiv,
+    &glTexParameterIivEXT,
+    &glTexParameterIuiv,
+    &glTexParameterIuivEXT,
+    &glTexParameterxOES,
+    &glTexParameterxvOES,
+    &glTexRenderbufferNV,
+    &glTexStorage1D,
+    &glTexStorage2D,
+    &glTexStorage2DMultisample,
+    &glTexStorage3D,
+    &glTexStorage3DMultisample,
+    &glTexStorageMem1DEXT,
+    &glTexStorageMem2DEXT,
+    &glTexStorageMem2DMultisampleEXT,
+    &glTexStorageMem3DEXT,
+    &glTexStorageMem3DMultisampleEXT,
+    &glTexStorageSparseAMD,
+    &glTexSubImage1DEXT,
+    &glTexSubImage2DEXT,
+    &glTexSubImage3D,
+    &glTexSubImage3DEXT,
+    &glTexSubImage4DSGIS,
+    &glTextureAttachMemoryNV,
+    &glTextureBarrier,
+    &glTextureBarrierNV,
+    &glTextureBuffer,
+    &glTextureBufferEXT,
+    &glTextureBufferRange,
+    &glTextureBufferRangeEXT,
+    &glTextureColorMaskSGIS,
+    &glTextureImage1DEXT,
+    &glTextureImage2DEXT,
+    &glTextureImage2DMultisampleCoverageNV,
+    &glTextureImage2DMultisampleNV,
+    &glTextureImage3DEXT,
+    &glTextureImage3DMultisampleCoverageNV,
+    &glTextureImage3DMultisampleNV,
+    &glTextureLightEXT,
+    &glTextureMaterialEXT,
+    &glTextureNormalEXT,
+    &glTexturePageCommitmentEXT,
+    &glTextureParameterIiv,
+    &glTextureParameterIivEXT,
+    &glTextureParameterIuiv,
+    &glTextureParameterIuivEXT,
+    &glTextureParameterf,
+    &glTextureParameterfEXT,
+    &glTextureParameterfv,
+    &glTextureParameterfvEXT,
+    &glTextureParameteri,
+    &glTextureParameteriEXT,
+    &glTextureParameteriv,
+    &glTextureParameterivEXT,
+    &glTextureRangeAPPLE,
+    &glTextureRenderbufferEXT,
+    &glTextureStorage1D,
+    &glTextureStorage1DEXT,
+    &glTextureStorage2D,
+    &glTextureStorage2DEXT,
+    &glTextureStorage2DMultisample,
+    &glTextureStorage2DMultisampleEXT,
+    &glTextureStorage3D,
+    &glTextureStorage3DEXT,
+    &glTextureStorage3DMultisample,
+    &glTextureStorage3DMultisampleEXT,
+    &glTextureStorageMem1DEXT,
+    &glTextureStorageMem2DEXT,
+    &glTextureStorageMem2DMultisampleEXT,
+    &glTextureStorageMem3DEXT,
+    &glTextureStorageMem3DMultisampleEXT,
+    &glTextureStorageSparseAMD,
+    &glTextureSubImage1D,
+    &glTextureSubImage1DEXT,
+    &glTextureSubImage2D,
+    &glTextureSubImage2DEXT,
+    &glTextureSubImage3D,
+    &glTextureSubImage3DEXT,
+    &glTextureView,
+    &glTrackMatrixNV,
+    &glTransformFeedbackAttribsNV,
+    &glTransformFeedbackBufferBase,
+    &glTransformFeedbackBufferRange,
+    &glTransformFeedbackStreamAttribsNV,
+    &glTransformFeedbackVaryings,
+    &glTransformFeedbackVaryingsEXT,
+    &glTransformFeedbackVaryingsNV,
+    &glTransformPathNV,
+    &glTranslatexOES,
+    &glUniform1d,
+    &glUniform1dv,
+    &glUniform1f,
+    &glUniform1fARB,
+    &glUniform1fv,
+    &glUniform1fvARB,
+    &glUniform1i,
+    &glUniform1i64ARB,
+    &glUniform1i64NV,
+    &glUniform1i64vARB,
+    &glUniform1i64vNV,
+    &glUniform1iARB,
+    &glUniform1iv,
+    &glUniform1ivARB,
+    &glUniform1ui,
+    &glUniform1ui64ARB,
+    &glUniform1ui64NV,
+    &glUniform1ui64vARB,
+    &glUniform1ui64vNV,
+    &glUniform1uiEXT,
+    &glUniform1uiv,
+    &glUniform1uivEXT,
+    &glUniform2d,
+    &glUniform2dv,
+    &glUniform2f,
+    &glUniform2fARB,
+    &glUniform2fv,
+    &glUniform2fvARB,
+    &glUniform2i,
+    &glUniform2i64ARB,
+    &glUniform2i64NV,
+    &glUniform2i64vARB,
+    &glUniform2i64vNV,
+    &glUniform2iARB,
+    &glUniform2iv,
+    &glUniform2ivARB,
+    &glUniform2ui,
+    &glUniform2ui64ARB,
+    &glUniform2ui64NV,
+    &glUniform2ui64vARB,
+    &glUniform2ui64vNV,
+    &glUniform2uiEXT,
+    &glUniform2uiv,
+    &glUniform2uivEXT,
+    &glUniform3d,
+    &glUniform3dv,
+    &glUniform3f,
+    &glUniform3fARB,
+    &glUniform3fv,
+    &glUniform3fvARB,
+    &glUniform3i,
+    &glUniform3i64ARB,
+    &glUniform3i64NV,
+    &glUniform3i64vARB,
+    &glUniform3i64vNV,
+    &glUniform3iARB,
+    &glUniform3iv,
+    &glUniform3ivARB,
+    &glUniform3ui,
+    &glUniform3ui64ARB,
+    &glUniform3ui64NV,
+    &glUniform3ui64vARB,
+    &glUniform3ui64vNV,
+    &glUniform3uiEXT,
+    &glUniform3uiv,
+    &glUniform3uivEXT,
+    &glUniform4d,
+    &glUniform4dv,
+    &glUniform4f,
+    &glUniform4fARB,
+    &glUniform4fv,
+    &glUniform4fvARB,
+    &glUniform4i,
+    &glUniform4i64ARB,
+    &glUniform4i64NV,
+    &glUniform4i64vARB,
+    &glUniform4i64vNV,
+    &glUniform4iARB,
+    &glUniform4iv,
+    &glUniform4ivARB,
+    &glUniform4ui,
+    &glUniform4ui64ARB,
+    &glUniform4ui64NV,
+    &glUniform4ui64vARB,
+    &glUniform4ui64vNV,
+    &glUniform4uiEXT,
+    &glUniform4uiv,
+    &glUniform4uivEXT,
+    &glUniformBlockBinding,
+    &glUniformBufferEXT,
+    &glUniformHandleui64ARB,
+    &glUniformHandleui64NV,
+    &glUniformHandleui64vARB,
+    &glUniformHandleui64vNV,
+    &glUniformMatrix2dv,
+    &glUniformMatrix2fv,
+    &glUniformMatrix2fvARB,
+    &glUniformMatrix2x3dv,
+    &glUniformMatrix2x3fv,
+    &glUniformMatrix2x4dv,
+    &glUniformMatrix2x4fv,
+    &glUniformMatrix3dv,
+    &glUniformMatrix3fv,
+    &glUniformMatrix3fvARB,
+    &glUniformMatrix3x2dv,
+    &glUniformMatrix3x2fv,
+    &glUniformMatrix3x4dv,
+    &glUniformMatrix3x4fv,
+    &glUniformMatrix4dv,
+    &glUniformMatrix4fv,
+    &glUniformMatrix4fvARB,
+    &glUniformMatrix4x2dv,
+    &glUniformMatrix4x2fv,
+    &glUniformMatrix4x3dv,
+    &glUniformMatrix4x3fv,
+    &glUniformSubroutinesuiv,
+    &glUniformui64NV,
+    &glUniformui64vNV,
+    &glUnlockArraysEXT,
+    &glUnmapBuffer,
+    &glUnmapBufferARB,
+    &glUnmapNamedBuffer,
+    &glUnmapNamedBufferEXT,
+    &glUnmapObjectBufferATI,
+    &glUnmapTexture2DINTEL,
+    &glUpdateObjectBufferATI,
+    &glUploadGpuMaskNVX,
+    &glUseProgram,
+    &glUseProgramObjectARB,
+    &glUseProgramStages,
+    &glUseShaderProgramEXT,
+    &glVDPAUFiniNV,
+    &glVDPAUGetSurfaceivNV,
+    &glVDPAUInitNV,
+    &glVDPAUIsSurfaceNV,
+    &glVDPAUMapSurfacesNV,
+    &glVDPAURegisterOutputSurfaceNV,
+    &glVDPAURegisterVideoSurfaceNV,
+    &glVDPAURegisterVideoSurfaceWithPictureStructureNV,
+    &glVDPAUSurfaceAccessNV,
+    &glVDPAUUnmapSurfacesNV,
+    &glVDPAUUnregisterSurfaceNV,
+    &glValidateProgram,
+    &glValidateProgramARB,
+    &glValidateProgramPipeline,
+    &glVariantArrayObjectATI,
+    &glVariantPointerEXT,
+    &glVariantbvEXT,
+    &glVariantdvEXT,
+    &glVariantfvEXT,
+    &glVariantivEXT,
+    &glVariantsvEXT,
+    &glVariantubvEXT,
+    &glVariantuivEXT,
+    &glVariantusvEXT,
+    &glVertex2bOES,
+    &glVertex2bvOES,
+    &glVertex2hNV,
+    &glVertex2hvNV,
+    &glVertex2xOES,
+    &glVertex2xvOES,
+    &glVertex3bOES,
+    &glVertex3bvOES,
+    &glVertex3hNV,
+    &glVertex3hvNV,
+    &glVertex3xOES,
+    &glVertex3xvOES,
+    &glVertex4bOES,
+    &glVertex4bvOES,
+    &glVertex4hNV,
+    &glVertex4hvNV,
+    &glVertex4xOES,
+    &glVertex4xvOES,
+    &glVertexArrayAttribBinding,
+    &glVertexArrayAttribFormat,
+    &glVertexArrayAttribIFormat,
+    &glVertexArrayAttribLFormat,
+    &glVertexArrayBindVertexBufferEXT,
+    &glVertexArrayBindingDivisor,
+    &glVertexArrayColorOffsetEXT,
+    &glVertexArrayEdgeFlagOffsetEXT,
+    &glVertexArrayElementBuffer,
+    &glVertexArrayFogCoordOffsetEXT,
+    &glVertexArrayIndexOffsetEXT,
+    &glVertexArrayMultiTexCoordOffsetEXT,
+    &glVertexArrayNormalOffsetEXT,
+    &glVertexArrayParameteriAPPLE,
+    &glVertexArrayRangeAPPLE,
+    &glVertexArrayRangeNV,
+    &glVertexArraySecondaryColorOffsetEXT,
+    &glVertexArrayTexCoordOffsetEXT,
+    &glVertexArrayVertexAttribBindingEXT,
+    &glVertexArrayVertexAttribDivisorEXT,
+    &glVertexArrayVertexAttribFormatEXT,
+    &glVertexArrayVertexAttribIFormatEXT,
+    &glVertexArrayVertexAttribIOffsetEXT,
+    &glVertexArrayVertexAttribLFormatEXT,
+    &glVertexArrayVertexAttribLOffsetEXT,
+    &glVertexArrayVertexAttribOffsetEXT,
+    &glVertexArrayVertexBindingDivisorEXT,
+    &glVertexArrayVertexBuffer,
+    &glVertexArrayVertexBuffers,
+    &glVertexArrayVertexOffsetEXT,
+    &glVertexAttrib1d,
+    &glVertexAttrib1dARB,
+    &glVertexAttrib1dNV,
+    &glVertexAttrib1dv,
+    &glVertexAttrib1dvARB,
+    &glVertexAttrib1dvNV,
+    &glVertexAttrib1f,
+    &glVertexAttrib1fARB,
+    &glVertexAttrib1fNV,
+    &glVertexAttrib1fv,
+    &glVertexAttrib1fvARB,
+    &glVertexAttrib1fvNV,
+    &glVertexAttrib1hNV,
+    &glVertexAttrib1hvNV,
+    &glVertexAttrib1s,
+    &glVertexAttrib1sARB,
+    &glVertexAttrib1sNV,
+    &glVertexAttrib1sv,
+    &glVertexAttrib1svARB,
+    &glVertexAttrib1svNV,
+    &glVertexAttrib2d,
+    &glVertexAttrib2dARB,
+    &glVertexAttrib2dNV,
+    &glVertexAttrib2dv,
+    &glVertexAttrib2dvARB,
+    &glVertexAttrib2dvNV,
+    &glVertexAttrib2f,
+    &glVertexAttrib2fARB,
+    &glVertexAttrib2fNV,
+    &glVertexAttrib2fv,
+    &glVertexAttrib2fvARB,
+    &glVertexAttrib2fvNV,
+    &glVertexAttrib2hNV,
+    &glVertexAttrib2hvNV,
+    &glVertexAttrib2s,
+    &glVertexAttrib2sARB,
+    &glVertexAttrib2sNV,
+    &glVertexAttrib2sv,
+    &glVertexAttrib2svARB,
+    &glVertexAttrib2svNV,
+    &glVertexAttrib3d,
+    &glVertexAttrib3dARB,
+    &glVertexAttrib3dNV,
+    &glVertexAttrib3dv,
+    &glVertexAttrib3dvARB,
+    &glVertexAttrib3dvNV,
+    &glVertexAttrib3f,
+    &glVertexAttrib3fARB,
+    &glVertexAttrib3fNV,
+    &glVertexAttrib3fv,
+    &glVertexAttrib3fvARB,
+    &glVertexAttrib3fvNV,
+    &glVertexAttrib3hNV,
+    &glVertexAttrib3hvNV,
+    &glVertexAttrib3s,
+    &glVertexAttrib3sARB,
+    &glVertexAttrib3sNV,
+    &glVertexAttrib3sv,
+    &glVertexAttrib3svARB,
+    &glVertexAttrib3svNV,
+    &glVertexAttrib4Nbv,
+    &glVertexAttrib4NbvARB,
+    &glVertexAttrib4Niv,
+    &glVertexAttrib4NivARB,
+    &glVertexAttrib4Nsv,
+    &glVertexAttrib4NsvARB,
+    &glVertexAttrib4Nub,
+    &glVertexAttrib4NubARB,
+    &glVertexAttrib4Nubv,
+    &glVertexAttrib4NubvARB,
+    &glVertexAttrib4Nuiv,
+    &glVertexAttrib4NuivARB,
+    &glVertexAttrib4Nusv,
+    &glVertexAttrib4NusvARB,
+    &glVertexAttrib4bv,
+    &glVertexAttrib4bvARB,
+    &glVertexAttrib4d,
+    &glVertexAttrib4dARB,
+    &glVertexAttrib4dNV,
+    &glVertexAttrib4dv,
+    &glVertexAttrib4dvARB,
+    &glVertexAttrib4dvNV,
+    &glVertexAttrib4f,
+    &glVertexAttrib4fARB,
+    &glVertexAttrib4fNV,
+    &glVertexAttrib4fv,
+    &glVertexAttrib4fvARB,
+    &glVertexAttrib4fvNV,
+    &glVertexAttrib4hNV,
+    &glVertexAttrib4hvNV,
+    &glVertexAttrib4iv,
+    &glVertexAttrib4ivARB,
+    &glVertexAttrib4s,
+    &glVertexAttrib4sARB,
+    &glVertexAttrib4sNV,
+    &glVertexAttrib4sv,
+    &glVertexAttrib4svARB,
+    &glVertexAttrib4svNV,
+    &glVertexAttrib4ubNV,
+    &glVertexAttrib4ubv,
+    &glVertexAttrib4ubvARB,
+    &glVertexAttrib4ubvNV,
+    &glVertexAttrib4uiv,
+    &glVertexAttrib4uivARB,
+    &glVertexAttrib4usv,
+    &glVertexAttrib4usvARB,
+    &glVertexAttribArrayObjectATI,
+    &glVertexAttribBinding,
+    &glVertexAttribDivisor,
+    &glVertexAttribDivisorARB,
+    &glVertexAttribFormat,
+    &glVertexAttribFormatNV,
+    &glVertexAttribI1i,
+    &glVertexAttribI1iEXT,
+    &glVertexAttribI1iv,
+    &glVertexAttribI1ivEXT,
+    &glVertexAttribI1ui,
+    &glVertexAttribI1uiEXT,
+    &glVertexAttribI1uiv,
+    &glVertexAttribI1uivEXT,
+    &glVertexAttribI2i,
+    &glVertexAttribI2iEXT,
+    &glVertexAttribI2iv,
+    &glVertexAttribI2ivEXT,
+    &glVertexAttribI2ui,
+    &glVertexAttribI2uiEXT,
+    &glVertexAttribI2uiv,
+    &glVertexAttribI2uivEXT,
+    &glVertexAttribI3i,
+    &glVertexAttribI3iEXT,
+    &glVertexAttribI3iv,
+    &glVertexAttribI3ivEXT,
+    &glVertexAttribI3ui,
+    &glVertexAttribI3uiEXT,
+    &glVertexAttribI3uiv,
+    &glVertexAttribI3uivEXT,
+    &glVertexAttribI4bv,
+    &glVertexAttribI4bvEXT,
+    &glVertexAttribI4i,
+    &glVertexAttribI4iEXT,
+    &glVertexAttribI4iv,
+    &glVertexAttribI4ivEXT,
+    &glVertexAttribI4sv,
+    &glVertexAttribI4svEXT,
+    &glVertexAttribI4ubv,
+    &glVertexAttribI4ubvEXT,
+    &glVertexAttribI4ui,
+    &glVertexAttribI4uiEXT,
+    &glVertexAttribI4uiv,
+    &glVertexAttribI4uivEXT,
+    &glVertexAttribI4usv,
+    &glVertexAttribI4usvEXT,
+    &glVertexAttribIFormat,
+    &glVertexAttribIFormatNV,
+    &glVertexAttribIPointer,
+    &glVertexAttribIPointerEXT,
+    &glVertexAttribL1d,
+    &glVertexAttribL1dEXT,
+    &glVertexAttribL1dv,
+    &glVertexAttribL1dvEXT,
+    &glVertexAttribL1i64NV,
+    &glVertexAttribL1i64vNV,
+    &glVertexAttribL1ui64ARB,
+    &glVertexAttribL1ui64NV,
+    &glVertexAttribL1ui64vARB,
+    &glVertexAttribL1ui64vNV,
+    &glVertexAttribL2d,
+    &glVertexAttribL2dEXT,
+    &glVertexAttribL2dv,
+    &glVertexAttribL2dvEXT,
+    &glVertexAttribL2i64NV,
+    &glVertexAttribL2i64vNV,
+    &glVertexAttribL2ui64NV,
+    &glVertexAttribL2ui64vNV,
+    &glVertexAttribL3d,
+    &glVertexAttribL3dEXT,
+    &glVertexAttribL3dv,
+    &glVertexAttribL3dvEXT,
+    &glVertexAttribL3i64NV,
+    &glVertexAttribL3i64vNV,
+    &glVertexAttribL3ui64NV,
+    &glVertexAttribL3ui64vNV,
+    &glVertexAttribL4d,
+    &glVertexAttribL4dEXT,
+    &glVertexAttribL4dv,
+    &glVertexAttribL4dvEXT,
+    &glVertexAttribL4i64NV,
+    &glVertexAttribL4i64vNV,
+    &glVertexAttribL4ui64NV,
+    &glVertexAttribL4ui64vNV,
+    &glVertexAttribLFormat,
+    &glVertexAttribLFormatNV,
+    &glVertexAttribLPointer,
+    &glVertexAttribLPointerEXT,
+    &glVertexAttribP1ui,
+    &glVertexAttribP1uiv,
+    &glVertexAttribP2ui,
+    &glVertexAttribP2uiv,
+    &glVertexAttribP3ui,
+    &glVertexAttribP3uiv,
+    &glVertexAttribP4ui,
+    &glVertexAttribP4uiv,
+    &glVertexAttribParameteriAMD,
+    &glVertexAttribPointer,
+    &glVertexAttribPointerARB,
+    &glVertexAttribPointerNV,
+    &glVertexAttribs1dvNV,
+    &glVertexAttribs1fvNV,
+    &glVertexAttribs1hvNV,
+    &glVertexAttribs1svNV,
+    &glVertexAttribs2dvNV,
+    &glVertexAttribs2fvNV,
+    &glVertexAttribs2hvNV,
+    &glVertexAttribs2svNV,
+    &glVertexAttribs3dvNV,
+    &glVertexAttribs3fvNV,
+    &glVertexAttribs3hvNV,
+    &glVertexAttribs3svNV,
+    &glVertexAttribs4dvNV,
+    &glVertexAttribs4fvNV,
+    &glVertexAttribs4hvNV,
+    &glVertexAttribs4svNV,
+    &glVertexAttribs4ubvNV,
+    &glVertexBindingDivisor,
+    &glVertexBlendARB,
+    &glVertexBlendEnvfATI,
+    &glVertexBlendEnviATI,
+    &glVertexFormatNV,
+    &glVertexP2ui,
+    &glVertexP2uiv,
+    &glVertexP3ui,
+    &glVertexP3uiv,
+    &glVertexP4ui,
+    &glVertexP4uiv,
+    &glVertexPointerEXT,
+    &glVertexPointerListIBM,
+    &glVertexPointervINTEL,
+    &glVertexStream1dATI,
+    &glVertexStream1dvATI,
+    &glVertexStream1fATI,
+    &glVertexStream1fvATI,
+    &glVertexStream1iATI,
+    &glVertexStream1ivATI,
+    &glVertexStream1sATI,
+    &glVertexStream1svATI,
+    &glVertexStream2dATI,
+    &glVertexStream2dvATI,
+    &glVertexStream2fATI,
+    &glVertexStream2fvATI,
+    &glVertexStream2iATI,
+    &glVertexStream2ivATI,
+    &glVertexStream2sATI,
+    &glVertexStream2svATI,
+    &glVertexStream3dATI,
+    &glVertexStream3dvATI,
+    &glVertexStream3fATI,
+    &glVertexStream3fvATI,
+    &glVertexStream3iATI,
+    &glVertexStream3ivATI,
+    &glVertexStream3sATI,
+    &glVertexStream3svATI,
+    &glVertexStream4dATI,
+    &glVertexStream4dvATI,
+    &glVertexStream4fATI,
+    &glVertexStream4fvATI,
+    &glVertexStream4iATI,
+    &glVertexStream4ivATI,
+    &glVertexStream4sATI,
+    &glVertexStream4svATI,
+    &glVertexWeightPointerEXT,
+    &glVertexWeightfEXT,
+    &glVertexWeightfvEXT,
+    &glVertexWeighthNV,
+    &glVertexWeighthvNV,
+    &glVideoCaptureNV,
+    &glVideoCaptureStreamParameterdvNV,
+    &glVideoCaptureStreamParameterfvNV,
+    &glVideoCaptureStreamParameterivNV,
+    &glViewportArrayv,
+    &glViewportIndexedf,
+    &glViewportIndexedfv,
+    &glViewportPositionWScaleNV,
+    &glViewportSwizzleNV,
+    &glWaitSemaphoreEXT,
+    &glWaitSemaphoreui64NVX,
+    &glWaitSync,
+    &glWaitVkSemaphoreNV,
+    &glWeightPathsNV,
+    &glWeightPointerARB,
+    &glWeightbvARB,
+    &glWeightdvARB,
+    &glWeightfvARB,
+    &glWeightivARB,
+    &glWeightsvARB,
+    &glWeightubvARB,
+    &glWeightuivARB,
+    &glWeightusvARB,
+    &glWindowPos2d,
+    &glWindowPos2dARB,
+    &glWindowPos2dMESA,
+    &glWindowPos2dv,
+    &glWindowPos2dvARB,
+    &glWindowPos2dvMESA,
+    &glWindowPos2f,
+    &glWindowPos2fARB,
+    &glWindowPos2fMESA,
+    &glWindowPos2fv,
+    &glWindowPos2fvARB,
+    &glWindowPos2fvMESA,
+    &glWindowPos2i,
+    &glWindowPos2iARB,
+    &glWindowPos2iMESA,
+    &glWindowPos2iv,
+    &glWindowPos2ivARB,
+    &glWindowPos2ivMESA,
+    &glWindowPos2s,
+    &glWindowPos2sARB,
+    &glWindowPos2sMESA,
+    &glWindowPos2sv,
+    &glWindowPos2svARB,
+    &glWindowPos2svMESA,
+    &glWindowPos3d,
+    &glWindowPos3dARB,
+    &glWindowPos3dMESA,
+    &glWindowPos3dv,
+    &glWindowPos3dvARB,
+    &glWindowPos3dvMESA,
+    &glWindowPos3f,
+    &glWindowPos3fARB,
+    &glWindowPos3fMESA,
+    &glWindowPos3fv,
+    &glWindowPos3fvARB,
+    &glWindowPos3fvMESA,
+    &glWindowPos3i,
+    &glWindowPos3iARB,
+    &glWindowPos3iMESA,
+    &glWindowPos3iv,
+    &glWindowPos3ivARB,
+    &glWindowPos3ivMESA,
+    &glWindowPos3s,
+    &glWindowPos3sARB,
+    &glWindowPos3sMESA,
+    &glWindowPos3sv,
+    &glWindowPos3svARB,
+    &glWindowPos3svMESA,
+    &glWindowPos4dMESA,
+    &glWindowPos4dvMESA,
+    &glWindowPos4fMESA,
+    &glWindowPos4fvMESA,
+    &glWindowPos4iMESA,
+    &glWindowPos4ivMESA,
+    &glWindowPos4sMESA,
+    &glWindowPos4svMESA,
+    &glWindowRectanglesEXT,
+    &glWriteMaskEXT,
+    &wglAllocateMemoryNV,
+    &wglBindTexImageARB,
+    &wglChoosePixelFormatARB,
+    &wglCreateContextAttribsARB,
+    &wglCreatePbufferARB,
+    &wglDestroyPbufferARB,
+    &wglFreeMemoryNV,
+    &wglGetCurrentReadDCARB,
+    &wglGetExtensionsStringARB,
+    &wglGetExtensionsStringEXT,
+    &wglGetPbufferDCARB,
+    &wglGetPixelFormatAttribfvARB,
+    &wglGetPixelFormatAttribivARB,
+    &wglGetSwapIntervalEXT,
+    &wglMakeContextCurrentARB,
+    &wglQueryCurrentRendererIntegerWINE,
+    &wglQueryCurrentRendererStringWINE,
+    &wglQueryPbufferARB,
+    &wglQueryRendererIntegerWINE,
+    &wglQueryRendererStringWINE,
+    &wglReleasePbufferDCARB,
+    &wglReleaseTexImageARB,
+    &wglSetPbufferAttribARB,
+    &wglSetPixelFormatWINE,
+    &wglSwapIntervalEXT,
 };
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
index 41374ed9d74..3306a446c7f 100644
--- a/dlls/opengl32/unix_thunks.c
+++ b/dlls/opengl32/unix_thunks.c
@@ -33283,3 +33283,2702 @@ struct opengl_funcs null_opengl_funcs =
         null_wglSwapIntervalEXT,
     },
 };
+
+const int extension_registry_size = 2694;
+const struct registry_entry extension_registry[2694] =
+{
+    { "glAccumxOES", "GL_OES_fixed_point" },
+    { "glAcquireKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex" },
+    { "glActiveProgramEXT", "GL_EXT_separate_shader_objects" },
+    { "glActiveShaderProgram", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glActiveStencilFaceEXT", "GL_EXT_stencil_two_side" },
+    { "glActiveTexture", "GL_VERSION_1_3" },
+    { "glActiveTextureARB", "GL_ARB_multitexture" },
+    { "glActiveVaryingNV", "GL_NV_transform_feedback" },
+    { "glAlphaFragmentOp1ATI", "GL_ATI_fragment_shader" },
+    { "glAlphaFragmentOp2ATI", "GL_ATI_fragment_shader" },
+    { "glAlphaFragmentOp3ATI", "GL_ATI_fragment_shader" },
+    { "glAlphaFuncxOES", "GL_OES_fixed_point" },
+    { "glAlphaToCoverageDitherControlNV", "GL_NV_alpha_to_coverage_dither_control" },
+    { "glApplyFramebufferAttachmentCMAAINTEL", "GL_INTEL_framebuffer_CMAA" },
+    { "glApplyTextureEXT", "GL_EXT_light_texture" },
+    { "glAreProgramsResidentNV", "GL_NV_vertex_program" },
+    { "glAreTexturesResidentEXT", "GL_EXT_texture_object" },
+    { "glArrayElementEXT", "GL_EXT_vertex_array" },
+    { "glArrayObjectATI", "GL_ATI_vertex_array_object" },
+    { "glAsyncCopyBufferSubDataNVX", "GL_NVX_gpu_multicast2" },
+    { "glAsyncCopyImageSubDataNVX", "GL_NVX_gpu_multicast2" },
+    { "glAsyncMarkerSGIX", "GL_SGIX_async" },
+    { "glAttachObjectARB", "GL_ARB_shader_objects" },
+    { "glAttachShader", "GL_VERSION_2_0" },
+    { "glBeginConditionalRender", "GL_VERSION_3_0" },
+    { "glBeginConditionalRenderNV", "GL_NV_conditional_render" },
+    { "glBeginConditionalRenderNVX", "GL_NVX_conditional_render" },
+    { "glBeginFragmentShaderATI", "GL_ATI_fragment_shader" },
+    { "glBeginOcclusionQueryNV", "GL_NV_occlusion_query" },
+    { "glBeginPerfMonitorAMD", "GL_AMD_performance_monitor" },
+    { "glBeginPerfQueryINTEL", "GL_INTEL_performance_query" },
+    { "glBeginQuery", "GL_VERSION_1_5" },
+    { "glBeginQueryARB", "GL_ARB_occlusion_query" },
+    { "glBeginQueryIndexed", "GL_ARB_transform_feedback3 GL_VERSION_4_0" },
+    { "glBeginTransformFeedback", "GL_VERSION_3_0" },
+    { "glBeginTransformFeedbackEXT", "GL_EXT_transform_feedback" },
+    { "glBeginTransformFeedbackNV", "GL_NV_transform_feedback" },
+    { "glBeginVertexShaderEXT", "GL_EXT_vertex_shader" },
+    { "glBeginVideoCaptureNV", "GL_NV_video_capture" },
+    { "glBindAttribLocation", "GL_VERSION_2_0" },
+    { "glBindAttribLocationARB", "GL_ARB_vertex_shader" },
+    { "glBindBuffer", "GL_VERSION_1_5" },
+    { "glBindBufferARB", "GL_ARB_vertex_buffer_object" },
+    { "glBindBufferBase", "GL_ARB_uniform_buffer_object GL_VERSION_3_0" },
+    { "glBindBufferBaseEXT", "GL_EXT_transform_feedback" },
+    { "glBindBufferBaseNV", "GL_NV_transform_feedback" },
+    { "glBindBufferOffsetEXT", "GL_EXT_transform_feedback" },
+    { "glBindBufferOffsetNV", "GL_NV_transform_feedback" },
+    { "glBindBufferRange", "GL_ARB_uniform_buffer_object GL_VERSION_3_0" },
+    { "glBindBufferRangeEXT", "GL_EXT_transform_feedback" },
+    { "glBindBufferRangeNV", "GL_NV_transform_feedback" },
+    { "glBindBuffersBase", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindBuffersRange", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindFragDataLocation", "GL_VERSION_3_0" },
+    { "glBindFragDataLocationEXT", "GL_EXT_gpu_shader4" },
+    { "glBindFragDataLocationIndexed", "GL_ARB_blend_func_extended GL_VERSION_3_3" },
+    { "glBindFragmentShaderATI", "GL_ATI_fragment_shader" },
+    { "glBindFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glBindFramebufferEXT", "GL_EXT_framebuffer_object" },
+    { "glBindImageTexture", "GL_ARB_shader_image_load_store GL_VERSION_4_2" },
+    { "glBindImageTextureEXT", "GL_EXT_shader_image_load_store" },
+    { "glBindImageTextures", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindLightParameterEXT", "GL_EXT_vertex_shader" },
+    { "glBindMaterialParameterEXT", "GL_EXT_vertex_shader" },
+    { "glBindMultiTextureEXT", "GL_EXT_direct_state_access" },
+    { "glBindParameterEXT", "GL_EXT_vertex_shader" },
+    { "glBindProgramARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glBindProgramNV", "GL_NV_vertex_program" },
+    { "glBindProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glBindRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glBindRenderbufferEXT", "GL_EXT_framebuffer_object" },
+    { "glBindSampler", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glBindSamplers", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindShadingRateImageNV", "GL_NV_shading_rate_image" },
+    { "glBindTexGenParameterEXT", "GL_EXT_vertex_shader" },
+    { "glBindTextureEXT", "GL_EXT_texture_object" },
+    { "glBindTextureUnit", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glBindTextureUnitParameterEXT", "GL_EXT_vertex_shader" },
+    { "glBindTextures", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glBindTransformFeedbackNV", "GL_NV_transform_feedback2" },
+    { "glBindVertexArray", "GL_ARB_vertex_array_object GL_VERSION_3_0" },
+    { "glBindVertexArrayAPPLE", "GL_APPLE_vertex_array_object" },
+    { "glBindVertexBuffer", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glBindVertexBuffers", "GL_ARB_multi_bind GL_VERSION_4_4" },
+    { "glBindVertexShaderEXT", "GL_EXT_vertex_shader" },
+    { "glBindVideoCaptureStreamBufferNV", "GL_NV_video_capture" },
+    { "glBindVideoCaptureStreamTextureNV", "GL_NV_video_capture" },
+    { "glBinormal3bEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3bvEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3dEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3dvEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3fEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3fvEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3iEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3ivEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3sEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormal3svEXT", "GL_EXT_coordinate_frame" },
+    { "glBinormalPointerEXT", "GL_EXT_coordinate_frame" },
+    { "glBitmapxOES", "GL_OES_fixed_point" },
+    { "glBlendBarrierKHR", "GL_KHR_blend_equation_advanced" },
+    { "glBlendBarrierNV", "GL_NV_blend_equation_advanced" },
+    { "glBlendColor", "GL_ARB_imaging GL_VERSION_1_4" },
+    { "glBlendColorEXT", "GL_EXT_blend_color" },
+    { "glBlendColorxOES", "GL_OES_fixed_point" },
+    { "glBlendEquation", "GL_ARB_imaging GL_VERSION_1_4" },
+    { "glBlendEquationEXT", "GL_EXT_blend_minmax" },
+    { "glBlendEquationIndexedAMD", "GL_AMD_draw_buffers_blend" },
+    { "glBlendEquationSeparate", "GL_VERSION_2_0" },
+    { "glBlendEquationSeparateEXT", "GL_EXT_blend_equation_separate" },
+    { "glBlendEquationSeparateIndexedAMD", "GL_AMD_draw_buffers_blend" },
+    { "glBlendEquationSeparatei", "GL_VERSION_4_0" },
+    { "glBlendEquationSeparateiARB", "GL_ARB_draw_buffers_blend" },
+    { "glBlendEquationi", "GL_VERSION_4_0" },
+    { "glBlendEquationiARB", "GL_ARB_draw_buffers_blend" },
+    { "glBlendFuncIndexedAMD", "GL_AMD_draw_buffers_blend" },
+    { "glBlendFuncSeparate", "GL_VERSION_1_4" },
+    { "glBlendFuncSeparateEXT", "GL_EXT_blend_func_separate" },
+    { "glBlendFuncSeparateINGR", "GL_INGR_blend_func_separate" },
+    { "glBlendFuncSeparateIndexedAMD", "GL_AMD_draw_buffers_blend" },
+    { "glBlendFuncSeparatei", "GL_VERSION_4_0" },
+    { "glBlendFuncSeparateiARB", "GL_ARB_draw_buffers_blend" },
+    { "glBlendFunci", "GL_VERSION_4_0" },
+    { "glBlendFunciARB", "GL_ARB_draw_buffers_blend" },
+    { "glBlendParameteriNV", "GL_NV_blend_equation_advanced" },
+    { "glBlitFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glBlitFramebufferEXT", "GL_EXT_framebuffer_blit" },
+    { "glBlitNamedFramebuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glBufferAddressRangeNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glBufferAttachMemoryNV", "GL_NV_memory_attachment" },
+    { "glBufferData", "GL_VERSION_1_5" },
+    { "glBufferDataARB", "GL_ARB_vertex_buffer_object" },
+    { "glBufferPageCommitmentARB", "GL_ARB_sparse_buffer" },
+    { "glBufferParameteriAPPLE", "GL_APPLE_flush_buffer_range" },
+    { "glBufferRegionEnabled", "GL_KTX_buffer_region" },
+    { "glBufferStorage", "GL_ARB_buffer_storage GL_VERSION_4_4" },
+    { "glBufferStorageExternalEXT", "GL_EXT_external_buffer" },
+    { "glBufferStorageMemEXT", "GL_EXT_memory_object" },
+    { "glBufferSubData", "GL_VERSION_1_5" },
+    { "glBufferSubDataARB", "GL_ARB_vertex_buffer_object" },
+    { "glCallCommandListNV", "GL_NV_command_list" },
+    { "glCheckFramebufferStatus", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glCheckFramebufferStatusEXT", "GL_EXT_framebuffer_object" },
+    { "glCheckNamedFramebufferStatus", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCheckNamedFramebufferStatusEXT", "GL_EXT_direct_state_access" },
+    { "glClampColor", "GL_VERSION_3_0" },
+    { "glClampColorARB", "GL_ARB_color_buffer_float" },
+    { "glClearAccumxOES", "GL_OES_fixed_point" },
+    { "glClearBufferData", "GL_ARB_clear_buffer_object GL_VERSION_4_3" },
+    { "glClearBufferSubData", "GL_ARB_clear_buffer_object GL_VERSION_4_3" },
+    { "glClearBufferfi", "GL_VERSION_3_0" },
+    { "glClearBufferfv", "GL_VERSION_3_0" },
+    { "glClearBufferiv", "GL_VERSION_3_0" },
+    { "glClearBufferuiv", "GL_VERSION_3_0" },
+    { "glClearColorIiEXT", "GL_EXT_texture_integer" },
+    { "glClearColorIuiEXT", "GL_EXT_texture_integer" },
+    { "glClearColorxOES", "GL_OES_fixed_point" },
+    { "glClearDepthdNV", "GL_NV_depth_buffer_float" },
+    { "glClearDepthf", "GL_ARB_ES2_compatibility GL_VERSION_4_1" },
+    { "glClearDepthfOES", "GL_OES_single_precision" },
+    { "glClearDepthxOES", "GL_OES_fixed_point" },
+    { "glClearNamedBufferData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearNamedBufferDataEXT", "GL_EXT_direct_state_access" },
+    { "glClearNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearNamedBufferSubDataEXT", "GL_EXT_direct_state_access" },
+    { "glClearNamedFramebufferfi", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearNamedFramebufferfv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearNamedFramebufferiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearNamedFramebufferuiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glClearTexImage", "GL_ARB_clear_texture GL_VERSION_4_4" },
+    { "glClearTexSubImage", "GL_ARB_clear_texture GL_VERSION_4_4" },
+    { "glClientActiveTexture", "GL_VERSION_1_3" },
+    { "glClientActiveTextureARB", "GL_ARB_multitexture" },
+    { "glClientActiveVertexStreamATI", "GL_ATI_vertex_streams" },
+    { "glClientAttribDefaultEXT", "GL_EXT_direct_state_access" },
+    { "glClientWaitSemaphoreui64NVX", "GL_NVX_progress_fence" },
+    { "glClientWaitSync", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glClipControl", "GL_ARB_clip_control GL_VERSION_4_5" },
+    { "glClipPlanefOES", "GL_OES_single_precision" },
+    { "glClipPlanexOES", "GL_OES_fixed_point" },
+    { "glColor3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glColor3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glColor3hNV", "GL_NV_half_float" },
+    { "glColor3hvNV", "GL_NV_half_float" },
+    { "glColor3xOES", "GL_OES_fixed_point" },
+    { "glColor3xvOES", "GL_OES_fixed_point" },
+    { "glColor4fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glColor4hNV", "GL_NV_half_float" },
+    { "glColor4hvNV", "GL_NV_half_float" },
+    { "glColor4ubVertex2fSUN", "GL_SUN_vertex" },
+    { "glColor4ubVertex2fvSUN", "GL_SUN_vertex" },
+    { "glColor4ubVertex3fSUN", "GL_SUN_vertex" },
+    { "glColor4ubVertex3fvSUN", "GL_SUN_vertex" },
+    { "glColor4xOES", "GL_OES_fixed_point" },
+    { "glColor4xvOES", "GL_OES_fixed_point" },
+    { "glColorFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glColorFragmentOp1ATI", "GL_ATI_fragment_shader" },
+    { "glColorFragmentOp2ATI", "GL_ATI_fragment_shader" },
+    { "glColorFragmentOp3ATI", "GL_ATI_fragment_shader" },
+    { "glColorMaskIndexedEXT", "GL_EXT_draw_buffers2" },
+    { "glColorMaski", "GL_VERSION_3_0" },
+    { "glColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glColorP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glColorP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glColorPointerEXT", "GL_EXT_vertex_array" },
+    { "glColorPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glColorPointervINTEL", "GL_INTEL_parallel_arrays" },
+    { "glColorSubTable", "GL_ARB_imaging" },
+    { "glColorSubTableEXT", "GL_EXT_color_subtable" },
+    { "glColorTable", "GL_ARB_imaging" },
+    { "glColorTableEXT", "GL_EXT_paletted_texture" },
+    { "glColorTableParameterfv", "GL_ARB_imaging" },
+    { "glColorTableParameterfvSGI", "GL_SGI_color_table" },
+    { "glColorTableParameteriv", "GL_ARB_imaging" },
+    { "glColorTableParameterivSGI", "GL_SGI_color_table" },
+    { "glColorTableSGI", "GL_SGI_color_table" },
+    { "glCombinerInputNV", "GL_NV_register_combiners" },
+    { "glCombinerOutputNV", "GL_NV_register_combiners" },
+    { "glCombinerParameterfNV", "GL_NV_register_combiners" },
+    { "glCombinerParameterfvNV", "GL_NV_register_combiners" },
+    { "glCombinerParameteriNV", "GL_NV_register_combiners" },
+    { "glCombinerParameterivNV", "GL_NV_register_combiners" },
+    { "glCombinerStageParameterfvNV", "GL_NV_register_combiners2" },
+    { "glCommandListSegmentsNV", "GL_NV_command_list" },
+    { "glCompileCommandListNV", "GL_NV_command_list" },
+    { "glCompileShader", "GL_VERSION_2_0" },
+    { "glCompileShaderARB", "GL_ARB_shader_objects" },
+    { "glCompileShaderIncludeARB", "GL_ARB_shading_language_include" },
+    { "glCompressedMultiTexImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedMultiTexImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedMultiTexImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedMultiTexSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedMultiTexSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedMultiTexSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTexImage1D", "GL_VERSION_1_3" },
+    { "glCompressedTexImage1DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTexImage2D", "GL_VERSION_1_3" },
+    { "glCompressedTexImage2DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTexImage3D", "GL_VERSION_1_3" },
+    { "glCompressedTexImage3DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTexSubImage1D", "GL_VERSION_1_3" },
+    { "glCompressedTexSubImage1DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTexSubImage2D", "GL_VERSION_1_3" },
+    { "glCompressedTexSubImage2DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTexSubImage3D", "GL_VERSION_1_3" },
+    { "glCompressedTexSubImage3DARB", "GL_ARB_texture_compression" },
+    { "glCompressedTextureImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTextureImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTextureImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCompressedTextureSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCompressedTextureSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCompressedTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCompressedTextureSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glConservativeRasterParameterfNV", "GL_NV_conservative_raster_dilate" },
+    { "glConservativeRasterParameteriNV", "GL_NV_conservative_raster_pre_snap_triangles" },
+    { "glConvolutionFilter1D", "GL_ARB_imaging" },
+    { "glConvolutionFilter1DEXT", "GL_EXT_convolution" },
+    { "glConvolutionFilter2D", "GL_ARB_imaging" },
+    { "glConvolutionFilter2DEXT", "GL_EXT_convolution" },
+    { "glConvolutionParameterf", "GL_ARB_imaging" },
+    { "glConvolutionParameterfEXT", "GL_EXT_convolution" },
+    { "glConvolutionParameterfv", "GL_ARB_imaging" },
+    { "glConvolutionParameterfvEXT", "GL_EXT_convolution" },
+    { "glConvolutionParameteri", "GL_ARB_imaging" },
+    { "glConvolutionParameteriEXT", "GL_EXT_convolution" },
+    { "glConvolutionParameteriv", "GL_ARB_imaging" },
+    { "glConvolutionParameterivEXT", "GL_EXT_convolution" },
+    { "glConvolutionParameterxOES", "GL_OES_fixed_point" },
+    { "glConvolutionParameterxvOES", "GL_OES_fixed_point" },
+    { "glCopyBufferSubData", "GL_ARB_copy_buffer GL_VERSION_3_1" },
+    { "glCopyColorSubTable", "GL_ARB_imaging" },
+    { "glCopyColorSubTableEXT", "GL_EXT_color_subtable" },
+    { "glCopyColorTable", "GL_ARB_imaging" },
+    { "glCopyColorTableSGI", "GL_SGI_color_table" },
+    { "glCopyConvolutionFilter1D", "GL_ARB_imaging" },
+    { "glCopyConvolutionFilter1DEXT", "GL_EXT_convolution" },
+    { "glCopyConvolutionFilter2D", "GL_ARB_imaging" },
+    { "glCopyConvolutionFilter2DEXT", "GL_EXT_convolution" },
+    { "glCopyImageSubData", "GL_ARB_copy_image GL_VERSION_4_3" },
+    { "glCopyImageSubDataNV", "GL_NV_copy_image" },
+    { "glCopyMultiTexImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyMultiTexImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyMultiTexSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyMultiTexSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyMultiTexSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCopyPathNV", "GL_NV_path_rendering" },
+    { "glCopyTexImage1DEXT", "GL_EXT_copy_texture" },
+    { "glCopyTexImage2DEXT", "GL_EXT_copy_texture" },
+    { "glCopyTexSubImage1DEXT", "GL_EXT_copy_texture" },
+    { "glCopyTexSubImage2DEXT", "GL_EXT_copy_texture" },
+    { "glCopyTexSubImage3D", "GL_VERSION_1_2" },
+    { "glCopyTexSubImage3DEXT", "GL_EXT_copy_texture" },
+    { "glCopyTextureImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyTextureImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCopyTextureSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCopyTextureSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glCopyTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCopyTextureSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glCoverFillPathInstancedNV", "GL_NV_path_rendering" },
+    { "glCoverFillPathNV", "GL_NV_path_rendering" },
+    { "glCoverStrokePathInstancedNV", "GL_NV_path_rendering" },
+    { "glCoverStrokePathNV", "GL_NV_path_rendering" },
+    { "glCoverageModulationNV", "GL_NV_framebuffer_mixed_samples" },
+    { "glCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples" },
+    { "glCreateBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateCommandListsNV", "GL_NV_command_list" },
+    { "glCreateFramebuffers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateMemoryObjectsEXT", "GL_EXT_memory_object" },
+    { "glCreatePerfQueryINTEL", "GL_INTEL_performance_query" },
+    { "glCreateProgram", "GL_VERSION_2_0" },
+    { "glCreateProgramObjectARB", "GL_ARB_shader_objects" },
+    { "glCreateProgramPipelines", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateProgressFenceNVX", "GL_NVX_progress_fence" },
+    { "glCreateQueries", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateRenderbuffers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateSamplers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateShader", "GL_VERSION_2_0" },
+    { "glCreateShaderObjectARB", "GL_ARB_shader_objects" },
+    { "glCreateShaderProgramEXT", "GL_EXT_separate_shader_objects" },
+    { "glCreateShaderProgramv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glCreateStatesNV", "GL_NV_command_list" },
+    { "glCreateSyncFromCLeventARB", "GL_ARB_cl_event" },
+    { "glCreateTextures", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateTransformFeedbacks", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCreateVertexArrays", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glCullParameterdvEXT", "GL_EXT_cull_vertex" },
+    { "glCullParameterfvEXT", "GL_EXT_cull_vertex" },
+    { "glCurrentPaletteMatrixARB", "GL_ARB_matrix_palette" },
+    { "glDebugMessageCallback", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glDebugMessageCallbackAMD", "GL_AMD_debug_output" },
+    { "glDebugMessageCallbackARB", "GL_ARB_debug_output" },
+    { "glDebugMessageControl", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glDebugMessageControlARB", "GL_ARB_debug_output" },
+    { "glDebugMessageEnableAMD", "GL_AMD_debug_output" },
+    { "glDebugMessageInsert", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glDebugMessageInsertAMD", "GL_AMD_debug_output" },
+    { "glDebugMessageInsertARB", "GL_ARB_debug_output" },
+    { "glDeformSGIX", "GL_SGIX_polynomial_ffd" },
+    { "glDeformationMap3dSGIX", "GL_SGIX_polynomial_ffd" },
+    { "glDeformationMap3fSGIX", "GL_SGIX_polynomial_ffd" },
+    { "glDeleteAsyncMarkersSGIX", "GL_SGIX_async" },
+    { "glDeleteBufferRegion", "GL_KTX_buffer_region" },
+    { "glDeleteBuffers", "GL_VERSION_1_5" },
+    { "glDeleteBuffersARB", "GL_ARB_vertex_buffer_object" },
+    { "glDeleteCommandListsNV", "GL_NV_command_list" },
+    { "glDeleteFencesAPPLE", "GL_APPLE_fence" },
+    { "glDeleteFencesNV", "GL_NV_fence" },
+    { "glDeleteFragmentShaderATI", "GL_ATI_fragment_shader" },
+    { "glDeleteFramebuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glDeleteFramebuffersEXT", "GL_EXT_framebuffer_object" },
+    { "glDeleteMemoryObjectsEXT", "GL_EXT_memory_object" },
+    { "glDeleteNamedStringARB", "GL_ARB_shading_language_include" },
+    { "glDeleteNamesAMD", "GL_AMD_name_gen_delete" },
+    { "glDeleteObjectARB", "GL_ARB_shader_objects" },
+    { "glDeleteObjectBufferATI", "GL_ATI_vertex_array_object" },
+    { "glDeleteOcclusionQueriesNV", "GL_NV_occlusion_query" },
+    { "glDeletePathsNV", "GL_NV_path_rendering" },
+    { "glDeletePerfMonitorsAMD", "GL_AMD_performance_monitor" },
+    { "glDeletePerfQueryINTEL", "GL_INTEL_performance_query" },
+    { "glDeleteProgram", "GL_VERSION_2_0" },
+    { "glDeleteProgramPipelines", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glDeleteProgramsARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glDeleteProgramsNV", "GL_NV_vertex_program" },
+    { "glDeleteQueries", "GL_VERSION_1_5" },
+    { "glDeleteQueriesARB", "GL_ARB_occlusion_query" },
+    { "glDeleteQueryResourceTagNV", "GL_NV_query_resource_tag" },
+    { "glDeleteRenderbuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glDeleteRenderbuffersEXT", "GL_EXT_framebuffer_object" },
+    { "glDeleteSamplers", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glDeleteSemaphoresEXT", "GL_EXT_semaphore" },
+    { "glDeleteShader", "GL_VERSION_2_0" },
+    { "glDeleteStatesNV", "GL_NV_command_list" },
+    { "glDeleteSync", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glDeleteTexturesEXT", "GL_EXT_texture_object" },
+    { "glDeleteTransformFeedbacks", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glDeleteTransformFeedbacksNV", "GL_NV_transform_feedback2" },
+    { "glDeleteVertexArrays", "GL_ARB_vertex_array_object GL_VERSION_3_0" },
+    { "glDeleteVertexArraysAPPLE", "GL_APPLE_vertex_array_object" },
+    { "glDeleteVertexShaderEXT", "GL_EXT_vertex_shader" },
+    { "glDepthBoundsEXT", "GL_EXT_depth_bounds_test" },
+    { "glDepthBoundsdNV", "GL_NV_depth_buffer_float" },
+    { "glDepthRangeArraydvNV", "GL_ARB_viewport_array" },
+    { "glDepthRangeArrayv", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glDepthRangeIndexed", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glDepthRangeIndexeddNV", "GL_ARB_viewport_array" },
+    { "glDepthRangedNV", "GL_NV_depth_buffer_float" },
+    { "glDepthRangef", "GL_ARB_ES2_compatibility GL_VERSION_4_1" },
+    { "glDepthRangefOES", "GL_OES_single_precision" },
+    { "glDepthRangexOES", "GL_OES_fixed_point" },
+    { "glDetachObjectARB", "GL_ARB_shader_objects" },
+    { "glDetachShader", "GL_VERSION_2_0" },
+    { "glDetailTexFuncSGIS", "GL_SGIS_detail_texture" },
+    { "glDisableClientStateIndexedEXT", "GL_EXT_direct_state_access" },
+    { "glDisableClientStateiEXT", "GL_EXT_direct_state_access" },
+    { "glDisableIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2" },
+    { "glDisableVariantClientStateEXT", "GL_EXT_vertex_shader" },
+    { "glDisableVertexArrayAttrib", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glDisableVertexArrayAttribEXT", "GL_EXT_direct_state_access" },
+    { "glDisableVertexArrayEXT", "GL_EXT_direct_state_access" },
+    { "glDisableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glDisableVertexAttribArray", "GL_VERSION_2_0" },
+    { "glDisableVertexAttribArrayARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glDisablei", "GL_VERSION_3_0" },
+    { "glDispatchCompute", "GL_ARB_compute_shader GL_VERSION_4_3" },
+    { "glDispatchComputeGroupSizeARB", "GL_ARB_compute_variable_group_size" },
+    { "glDispatchComputeIndirect", "GL_ARB_compute_shader GL_VERSION_4_3" },
+    { "glDrawArraysEXT", "GL_EXT_vertex_array" },
+    { "glDrawArraysIndirect", "GL_ARB_draw_indirect GL_VERSION_4_0" },
+    { "glDrawArraysInstanced", "GL_VERSION_3_1" },
+    { "glDrawArraysInstancedARB", "GL_ARB_draw_instanced" },
+    { "glDrawArraysInstancedBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2" },
+    { "glDrawArraysInstancedEXT", "GL_EXT_draw_instanced" },
+    { "glDrawBufferRegion", "GL_KTX_buffer_region" },
+    { "glDrawBuffers", "GL_VERSION_2_0" },
+    { "glDrawBuffersARB", "GL_ARB_draw_buffers" },
+    { "glDrawBuffersATI", "GL_ATI_draw_buffers" },
+    { "glDrawCommandsAddressNV", "GL_NV_command_list" },
+    { "glDrawCommandsNV", "GL_NV_command_list" },
+    { "glDrawCommandsStatesAddressNV", "GL_NV_command_list" },
+    { "glDrawCommandsStatesNV", "GL_NV_command_list" },
+    { "glDrawElementArrayAPPLE", "GL_APPLE_element_array" },
+    { "glDrawElementArrayATI", "GL_ATI_element_array" },
+    { "glDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2" },
+    { "glDrawElementsIndirect", "GL_ARB_draw_indirect GL_VERSION_4_0" },
+    { "glDrawElementsInstanced", "GL_VERSION_3_1" },
+    { "glDrawElementsInstancedARB", "GL_ARB_draw_instanced" },
+    { "glDrawElementsInstancedBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2" },
+    { "glDrawElementsInstancedBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2" },
+    { "glDrawElementsInstancedBaseVertexBaseInstance", "GL_ARB_base_instance GL_VERSION_4_2" },
+    { "glDrawElementsInstancedEXT", "GL_EXT_draw_instanced" },
+    { "glDrawMeshArraysSUN", "GL_SUN_mesh_array" },
+    { "glDrawMeshTasksIndirectNV", "GL_NV_mesh_shader" },
+    { "glDrawMeshTasksNV", "GL_NV_mesh_shader" },
+    { "glDrawRangeElementArrayAPPLE", "GL_APPLE_element_array" },
+    { "glDrawRangeElementArrayATI", "GL_ATI_element_array" },
+    { "glDrawRangeElements", "GL_VERSION_1_2" },
+    { "glDrawRangeElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2" },
+    { "glDrawRangeElementsEXT", "GL_EXT_draw_range_elements" },
+    { "glDrawTextureNV", "GL_NV_draw_texture" },
+    { "glDrawTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glDrawTransformFeedbackInstanced", "GL_ARB_transform_feedback_instanced GL_VERSION_4_2" },
+    { "glDrawTransformFeedbackNV", "GL_NV_transform_feedback2" },
+    { "glDrawTransformFeedbackStream", "GL_ARB_transform_feedback3 GL_VERSION_4_0" },
+    { "glDrawTransformFeedbackStreamInstanced", "GL_ARB_transform_feedback_instanced GL_VERSION_4_2" },
+    { "glDrawVkImageNV", "GL_NV_draw_vulkan_image" },
+    { "glEGLImageTargetTexStorageEXT", "GL_EXT_EGL_image_storage" },
+    { "glEGLImageTargetTextureStorageEXT", "GL_EXT_EGL_image_storage" },
+    { "glEdgeFlagFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glEdgeFlagPointerEXT", "GL_EXT_vertex_array" },
+    { "glEdgeFlagPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glElementPointerAPPLE", "GL_APPLE_element_array" },
+    { "glElementPointerATI", "GL_ATI_element_array" },
+    { "glEnableClientStateIndexedEXT", "GL_EXT_direct_state_access" },
+    { "glEnableClientStateiEXT", "GL_EXT_direct_state_access" },
+    { "glEnableIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2" },
+    { "glEnableVariantClientStateEXT", "GL_EXT_vertex_shader" },
+    { "glEnableVertexArrayAttrib", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glEnableVertexArrayAttribEXT", "GL_EXT_direct_state_access" },
+    { "glEnableVertexArrayEXT", "GL_EXT_direct_state_access" },
+    { "glEnableVertexAttribAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glEnableVertexAttribArray", "GL_VERSION_2_0" },
+    { "glEnableVertexAttribArrayARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glEnablei", "GL_VERSION_3_0" },
+    { "glEndConditionalRender", "GL_VERSION_3_0" },
+    { "glEndConditionalRenderNV", "GL_NV_conditional_render" },
+    { "glEndConditionalRenderNVX", "GL_NVX_conditional_render" },
+    { "glEndFragmentShaderATI", "GL_ATI_fragment_shader" },
+    { "glEndOcclusionQueryNV", "GL_NV_occlusion_query" },
+    { "glEndPerfMonitorAMD", "GL_AMD_performance_monitor" },
+    { "glEndPerfQueryINTEL", "GL_INTEL_performance_query" },
+    { "glEndQuery", "GL_VERSION_1_5" },
+    { "glEndQueryARB", "GL_ARB_occlusion_query" },
+    { "glEndQueryIndexed", "GL_ARB_transform_feedback3 GL_VERSION_4_0" },
+    { "glEndTransformFeedback", "GL_VERSION_3_0" },
+    { "glEndTransformFeedbackEXT", "GL_EXT_transform_feedback" },
+    { "glEndTransformFeedbackNV", "GL_NV_transform_feedback" },
+    { "glEndVertexShaderEXT", "GL_EXT_vertex_shader" },
+    { "glEndVideoCaptureNV", "GL_NV_video_capture" },
+    { "glEvalCoord1xOES", "GL_OES_fixed_point" },
+    { "glEvalCoord1xvOES", "GL_OES_fixed_point" },
+    { "glEvalCoord2xOES", "GL_OES_fixed_point" },
+    { "glEvalCoord2xvOES", "GL_OES_fixed_point" },
+    { "glEvalMapsNV", "GL_NV_evaluators" },
+    { "glEvaluateDepthValuesARB", "GL_ARB_sample_locations" },
+    { "glExecuteProgramNV", "GL_NV_vertex_program" },
+    { "glExtractComponentEXT", "GL_EXT_vertex_shader" },
+    { "glFeedbackBufferxOES", "GL_OES_fixed_point" },
+    { "glFenceSync", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glFinalCombinerInputNV", "GL_NV_register_combiners" },
+    { "glFinishAsyncSGIX", "GL_SGIX_async" },
+    { "glFinishFenceAPPLE", "GL_APPLE_fence" },
+    { "glFinishFenceNV", "GL_NV_fence" },
+    { "glFinishObjectAPPLE", "GL_APPLE_fence" },
+    { "glFinishTextureSUNX", "GL_SUNX_constant_data" },
+    { "glFlushMappedBufferRange", "GL_ARB_map_buffer_range GL_VERSION_3_0" },
+    { "glFlushMappedBufferRangeAPPLE", "GL_APPLE_flush_buffer_range" },
+    { "glFlushMappedNamedBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glFlushMappedNamedBufferRangeEXT", "GL_EXT_direct_state_access" },
+    { "glFlushPixelDataRangeNV", "GL_NV_pixel_data_range" },
+    { "glFlushRasterSGIX", "GL_SGIX_flush_raster" },
+    { "glFlushStaticDataIBM", "GL_IBM_static_data" },
+    { "glFlushVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range" },
+    { "glFlushVertexArrayRangeNV", "GL_NV_vertex_array_range" },
+    { "glFogCoordFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glFogCoordPointer", "GL_VERSION_1_4" },
+    { "glFogCoordPointerEXT", "GL_EXT_fog_coord" },
+    { "glFogCoordPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glFogCoordd", "GL_VERSION_1_4" },
+    { "glFogCoorddEXT", "GL_EXT_fog_coord" },
+    { "glFogCoorddv", "GL_VERSION_1_4" },
+    { "glFogCoorddvEXT", "GL_EXT_fog_coord" },
+    { "glFogCoordf", "GL_VERSION_1_4" },
+    { "glFogCoordfEXT", "GL_EXT_fog_coord" },
+    { "glFogCoordfv", "GL_VERSION_1_4" },
+    { "glFogCoordfvEXT", "GL_EXT_fog_coord" },
+    { "glFogCoordhNV", "GL_NV_half_float" },
+    { "glFogCoordhvNV", "GL_NV_half_float" },
+    { "glFogFuncSGIS", "GL_SGIS_fog_function" },
+    { "glFogxOES", "GL_OES_fixed_point" },
+    { "glFogxvOES", "GL_OES_fixed_point" },
+    { "glFragmentColorMaterialSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentCoverageColorNV", "GL_NV_fragment_coverage_to_color" },
+    { "glFragmentLightModelfSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightModelfvSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightModeliSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightModelivSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightfSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightfvSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightiSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentLightivSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentMaterialfSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentMaterialiSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting" },
+    { "glFrameTerminatorGREMEDY", "GL_GREMEDY_frame_terminator" },
+    { "glFrameZoomSGIX", "GL_SGIX_framezoom" },
+    { "glFramebufferDrawBufferEXT", "GL_EXT_direct_state_access" },
+    { "glFramebufferDrawBuffersEXT", "GL_EXT_direct_state_access" },
+    { "glFramebufferFetchBarrierEXT", "GL_EXT_shader_framebuffer_fetch_non_coherent" },
+    { "glFramebufferParameteri", "GL_ARB_framebuffer_no_attachments GL_VERSION_4_3" },
+    { "glFramebufferParameteriMESA", "GL_MESA_framebuffer_flip_y" },
+    { "glFramebufferReadBufferEXT", "GL_EXT_direct_state_access" },
+    { "glFramebufferRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glFramebufferRenderbufferEXT", "GL_EXT_framebuffer_object" },
+    { "glFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations" },
+    { "glFramebufferSampleLocationsfvNV", "GL_NV_sample_locations" },
+    { "glFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions" },
+    { "glFramebufferTexture", "GL_VERSION_3_2" },
+    { "glFramebufferTexture1D", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glFramebufferTexture1DEXT", "GL_EXT_framebuffer_object" },
+    { "glFramebufferTexture2D", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glFramebufferTexture2DEXT", "GL_EXT_framebuffer_object" },
+    { "glFramebufferTexture3D", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glFramebufferTexture3DEXT", "GL_EXT_framebuffer_object" },
+    { "glFramebufferTextureARB", "GL_ARB_geometry_shader4" },
+    { "glFramebufferTextureEXT", "GL_NV_geometry_program4" },
+    { "glFramebufferTextureFaceARB", "GL_ARB_geometry_shader4" },
+    { "glFramebufferTextureFaceEXT", "GL_NV_geometry_program4" },
+    { "glFramebufferTextureLayer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glFramebufferTextureLayerARB", "GL_ARB_geometry_shader4" },
+    { "glFramebufferTextureLayerEXT", "GL_EXT_texture_array GL_NV_geometry_program4" },
+    { "glFramebufferTextureMultiviewOVR", "GL_OVR_multiview" },
+    { "glFreeObjectBufferATI", "GL_ATI_vertex_array_object" },
+    { "glFrustumfOES", "GL_OES_single_precision" },
+    { "glFrustumxOES", "GL_OES_fixed_point" },
+    { "glGenAsyncMarkersSGIX", "GL_SGIX_async" },
+    { "glGenBuffers", "GL_VERSION_1_5" },
+    { "glGenBuffersARB", "GL_ARB_vertex_buffer_object" },
+    { "glGenFencesAPPLE", "GL_APPLE_fence" },
+    { "glGenFencesNV", "GL_NV_fence" },
+    { "glGenFragmentShadersATI", "GL_ATI_fragment_shader" },
+    { "glGenFramebuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glGenFramebuffersEXT", "GL_EXT_framebuffer_object" },
+    { "glGenNamesAMD", "GL_AMD_name_gen_delete" },
+    { "glGenOcclusionQueriesNV", "GL_NV_occlusion_query" },
+    { "glGenPathsNV", "GL_NV_path_rendering" },
+    { "glGenPerfMonitorsAMD", "GL_AMD_performance_monitor" },
+    { "glGenProgramPipelines", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glGenProgramsARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGenProgramsNV", "GL_NV_vertex_program" },
+    { "glGenQueries", "GL_VERSION_1_5" },
+    { "glGenQueriesARB", "GL_ARB_occlusion_query" },
+    { "glGenQueryResourceTagNV", "GL_NV_query_resource_tag" },
+    { "glGenRenderbuffers", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glGenRenderbuffersEXT", "GL_EXT_framebuffer_object" },
+    { "glGenSamplers", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glGenSemaphoresEXT", "GL_EXT_semaphore" },
+    { "glGenSymbolsEXT", "GL_EXT_vertex_shader" },
+    { "glGenTexturesEXT", "GL_EXT_texture_object" },
+    { "glGenTransformFeedbacks", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glGenTransformFeedbacksNV", "GL_NV_transform_feedback2" },
+    { "glGenVertexArrays", "GL_ARB_vertex_array_object GL_VERSION_3_0" },
+    { "glGenVertexArraysAPPLE", "GL_APPLE_vertex_array_object" },
+    { "glGenVertexShadersEXT", "GL_EXT_vertex_shader" },
+    { "glGenerateMipmap", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glGenerateMipmapEXT", "GL_EXT_framebuffer_object" },
+    { "glGenerateMultiTexMipmapEXT", "GL_EXT_direct_state_access" },
+    { "glGenerateTextureMipmap", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGenerateTextureMipmapEXT", "GL_EXT_direct_state_access" },
+    { "glGetActiveAtomicCounterBufferiv", "GL_ARB_shader_atomic_counters GL_VERSION_4_2" },
+    { "glGetActiveAttrib", "GL_VERSION_2_0" },
+    { "glGetActiveAttribARB", "GL_ARB_vertex_shader" },
+    { "glGetActiveSubroutineName", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetActiveSubroutineUniformName", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetActiveSubroutineUniformiv", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetActiveUniform", "GL_VERSION_2_0" },
+    { "glGetActiveUniformARB", "GL_ARB_shader_objects" },
+    { "glGetActiveUniformBlockName", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetActiveUniformBlockiv", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetActiveUniformName", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetActiveUniformsiv", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetActiveVaryingNV", "GL_NV_transform_feedback" },
+    { "glGetArrayObjectfvATI", "GL_ATI_vertex_array_object" },
+    { "glGetArrayObjectivATI", "GL_ATI_vertex_array_object" },
+    { "glGetAttachedObjectsARB", "GL_ARB_shader_objects" },
+    { "glGetAttachedShaders", "GL_VERSION_2_0" },
+    { "glGetAttribLocation", "GL_VERSION_2_0" },
+    { "glGetAttribLocationARB", "GL_ARB_vertex_shader" },
+    { "glGetBooleanIndexedvEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2" },
+    { "glGetBooleani_v", "GL_VERSION_3_0" },
+    { "glGetBufferParameteri64v", "GL_VERSION_3_2" },
+    { "glGetBufferParameteriv", "GL_VERSION_1_5" },
+    { "glGetBufferParameterivARB", "GL_ARB_vertex_buffer_object" },
+    { "glGetBufferParameterui64vNV", "GL_NV_shader_buffer_load" },
+    { "glGetBufferPointerv", "GL_VERSION_1_5" },
+    { "glGetBufferPointervARB", "GL_ARB_vertex_buffer_object" },
+    { "glGetBufferSubData", "GL_VERSION_1_5" },
+    { "glGetBufferSubDataARB", "GL_ARB_vertex_buffer_object" },
+    { "glGetClipPlanefOES", "GL_OES_single_precision" },
+    { "glGetClipPlanexOES", "GL_OES_fixed_point" },
+    { "glGetColorTable", "GL_ARB_imaging" },
+    { "glGetColorTableEXT", "GL_EXT_paletted_texture" },
+    { "glGetColorTableParameterfv", "GL_ARB_imaging" },
+    { "glGetColorTableParameterfvEXT", "GL_EXT_paletted_texture" },
+    { "glGetColorTableParameterfvSGI", "GL_SGI_color_table" },
+    { "glGetColorTableParameteriv", "GL_ARB_imaging" },
+    { "glGetColorTableParameterivEXT", "GL_EXT_paletted_texture" },
+    { "glGetColorTableParameterivSGI", "GL_SGI_color_table" },
+    { "glGetColorTableSGI", "GL_SGI_color_table" },
+    { "glGetCombinerInputParameterfvNV", "GL_NV_register_combiners" },
+    { "glGetCombinerInputParameterivNV", "GL_NV_register_combiners" },
+    { "glGetCombinerOutputParameterfvNV", "GL_NV_register_combiners" },
+    { "glGetCombinerOutputParameterivNV", "GL_NV_register_combiners" },
+    { "glGetCombinerStageParameterfvNV", "GL_NV_register_combiners2" },
+    { "glGetCommandHeaderNV", "GL_NV_command_list" },
+    { "glGetCompressedMultiTexImageEXT", "GL_EXT_direct_state_access" },
+    { "glGetCompressedTexImage", "GL_VERSION_1_3" },
+    { "glGetCompressedTexImageARB", "GL_ARB_texture_compression" },
+    { "glGetCompressedTextureImage", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetCompressedTextureImageEXT", "GL_EXT_direct_state_access" },
+    { "glGetCompressedTextureSubImage", "GL_ARB_get_texture_sub_image GL_VERSION_4_5" },
+    { "glGetConvolutionFilter", "GL_ARB_imaging" },
+    { "glGetConvolutionFilterEXT", "GL_EXT_convolution" },
+    { "glGetConvolutionParameterfv", "GL_ARB_imaging" },
+    { "glGetConvolutionParameterfvEXT", "GL_EXT_convolution" },
+    { "glGetConvolutionParameteriv", "GL_ARB_imaging" },
+    { "glGetConvolutionParameterivEXT", "GL_EXT_convolution" },
+    { "glGetConvolutionParameterxvOES", "GL_OES_fixed_point" },
+    { "glGetCoverageModulationTableNV", "GL_NV_framebuffer_mixed_samples" },
+    { "glGetDebugMessageLog", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glGetDebugMessageLogAMD", "GL_AMD_debug_output" },
+    { "glGetDebugMessageLogARB", "GL_ARB_debug_output" },
+    { "glGetDetailTexFuncSGIS", "GL_SGIS_detail_texture" },
+    { "glGetDoubleIndexedvEXT", "GL_EXT_direct_state_access" },
+    { "glGetDoublei_v", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glGetDoublei_vEXT", "GL_EXT_direct_state_access" },
+    { "glGetFenceivNV", "GL_NV_fence" },
+    { "glGetFinalCombinerInputParameterfvNV", "GL_NV_register_combiners" },
+    { "glGetFinalCombinerInputParameterivNV", "GL_NV_register_combiners" },
+    { "glGetFirstPerfQueryIdINTEL", "GL_INTEL_performance_query" },
+    { "glGetFixedvOES", "GL_OES_fixed_point" },
+    { "glGetFloatIndexedvEXT", "GL_EXT_direct_state_access" },
+    { "glGetFloati_v", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glGetFloati_vEXT", "GL_EXT_direct_state_access" },
+    { "glGetFogFuncSGIS", "GL_SGIS_fog_function" },
+    { "glGetFragDataIndex", "GL_ARB_blend_func_extended GL_VERSION_3_3" },
+    { "glGetFragDataLocation", "GL_VERSION_3_0" },
+    { "glGetFragDataLocationEXT", "GL_EXT_gpu_shader4" },
+    { "glGetFragmentLightfvSGIX", "GL_SGIX_fragment_lighting" },
+    { "glGetFragmentLightivSGIX", "GL_SGIX_fragment_lighting" },
+    { "glGetFragmentMaterialfvSGIX", "GL_SGIX_fragment_lighting" },
+    { "glGetFragmentMaterialivSGIX", "GL_SGIX_fragment_lighting" },
+    { "glGetFramebufferAttachmentParameteriv", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glGetFramebufferAttachmentParameterivEXT", "GL_EXT_framebuffer_object" },
+    { "glGetFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions" },
+    { "glGetFramebufferParameteriv", "GL_ARB_framebuffer_no_attachments GL_VERSION_4_3" },
+    { "glGetFramebufferParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetFramebufferParameterivMESA", "GL_MESA_framebuffer_flip_y" },
+    { "glGetGraphicsResetStatus", "GL_KHR_robustness GL_VERSION_4_5" },
+    { "glGetGraphicsResetStatusARB", "GL_ARB_robustness" },
+    { "glGetHandleARB", "GL_ARB_shader_objects" },
+    { "glGetHistogram", "GL_ARB_imaging" },
+    { "glGetHistogramEXT", "GL_EXT_histogram" },
+    { "glGetHistogramParameterfv", "GL_ARB_imaging" },
+    { "glGetHistogramParameterfvEXT", "GL_EXT_histogram" },
+    { "glGetHistogramParameteriv", "GL_ARB_imaging" },
+    { "glGetHistogramParameterivEXT", "GL_EXT_histogram" },
+    { "glGetHistogramParameterxvOES", "GL_OES_fixed_point" },
+    { "glGetImageHandleARB", "GL_ARB_bindless_texture" },
+    { "glGetImageHandleNV", "GL_NV_bindless_texture" },
+    { "glGetImageTransformParameterfvHP", "GL_HP_image_transform" },
+    { "glGetImageTransformParameterivHP", "GL_HP_image_transform" },
+    { "glGetInfoLogARB", "GL_ARB_shader_objects" },
+    { "glGetInstrumentsSGIX", "GL_SGIX_instruments" },
+    { "glGetInteger64i_v", "GL_VERSION_3_2" },
+    { "glGetInteger64v", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glGetIntegerIndexedvEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2" },
+    { "glGetIntegeri_v", "GL_ARB_uniform_buffer_object GL_VERSION_3_0" },
+    { "glGetIntegerui64i_vNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glGetIntegerui64vNV", "GL_NV_shader_buffer_load" },
+    { "glGetInternalformatSampleivNV", "GL_NV_internalformat_sample_query" },
+    { "glGetInternalformati64v", "GL_ARB_internalformat_query2 GL_VERSION_4_3" },
+    { "glGetInternalformativ", "GL_ARB_internalformat_query GL_VERSION_4_2" },
+    { "glGetInvariantBooleanvEXT", "GL_EXT_vertex_shader" },
+    { "glGetInvariantFloatvEXT", "GL_EXT_vertex_shader" },
+    { "glGetInvariantIntegervEXT", "GL_EXT_vertex_shader" },
+    { "glGetLightxOES", "GL_OES_fixed_point" },
+    { "glGetListParameterfvSGIX", "GL_SGIX_list_priority" },
+    { "glGetListParameterivSGIX", "GL_SGIX_list_priority" },
+    { "glGetLocalConstantBooleanvEXT", "GL_EXT_vertex_shader" },
+    { "glGetLocalConstantFloatvEXT", "GL_EXT_vertex_shader" },
+    { "glGetLocalConstantIntegervEXT", "GL_EXT_vertex_shader" },
+    { "glGetMapAttribParameterfvNV", "GL_NV_evaluators" },
+    { "glGetMapAttribParameterivNV", "GL_NV_evaluators" },
+    { "glGetMapControlPointsNV", "GL_NV_evaluators" },
+    { "glGetMapParameterfvNV", "GL_NV_evaluators" },
+    { "glGetMapParameterivNV", "GL_NV_evaluators" },
+    { "glGetMapxvOES", "GL_OES_fixed_point" },
+    { "glGetMaterialxOES", "GL_OES_fixed_point" },
+    { "glGetMemoryObjectDetachedResourcesuivNV", "GL_NV_memory_attachment" },
+    { "glGetMemoryObjectParameterivEXT", "GL_EXT_memory_object" },
+    { "glGetMinmax", "GL_ARB_imaging" },
+    { "glGetMinmaxEXT", "GL_EXT_histogram" },
+    { "glGetMinmaxParameterfv", "GL_ARB_imaging" },
+    { "glGetMinmaxParameterfvEXT", "GL_EXT_histogram" },
+    { "glGetMinmaxParameteriv", "GL_ARB_imaging" },
+    { "glGetMinmaxParameterivEXT", "GL_EXT_histogram" },
+    { "glGetMultiTexEnvfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexEnvivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexGendvEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexGenfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexGenivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexImageEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexLevelParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexLevelParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexParameterIivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexParameterIuivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultiTexParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetMultisamplefv", "GL_ARB_texture_multisample GL_VERSION_3_2" },
+    { "glGetMultisamplefvNV", "GL_NV_explicit_multisample" },
+    { "glGetNamedBufferParameteri64v", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedBufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedBufferParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedBufferParameterui64vNV", "GL_NV_shader_buffer_load" },
+    { "glGetNamedBufferPointerv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedBufferPointervEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedBufferSubDataEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedFramebufferAttachmentParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedFramebufferAttachmentParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedFramebufferParameterfvAMD", "GL_AMD_framebuffer_sample_positions" },
+    { "glGetNamedFramebufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedFramebufferParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramLocalParameterIivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramLocalParameterIuivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramLocalParameterdvEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramLocalParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramStringEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedProgramivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedRenderbufferParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetNamedRenderbufferParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetNamedStringARB", "GL_ARB_shading_language_include" },
+    { "glGetNamedStringivARB", "GL_ARB_shading_language_include" },
+    { "glGetNextPerfQueryIdINTEL", "GL_INTEL_performance_query" },
+    { "glGetObjectBufferfvATI", "GL_ATI_vertex_array_object" },
+    { "glGetObjectBufferivATI", "GL_ATI_vertex_array_object" },
+    { "glGetObjectLabel", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glGetObjectLabelEXT", "GL_EXT_debug_label" },
+    { "glGetObjectParameterfvARB", "GL_ARB_shader_objects" },
+    { "glGetObjectParameterivAPPLE", "GL_APPLE_object_purgeable" },
+    { "glGetObjectParameterivARB", "GL_ARB_shader_objects" },
+    { "glGetObjectPtrLabel", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glGetOcclusionQueryivNV", "GL_NV_occlusion_query" },
+    { "glGetOcclusionQueryuivNV", "GL_NV_occlusion_query" },
+    { "glGetPathColorGenfvNV", "GL_NV_path_rendering" },
+    { "glGetPathColorGenivNV", "GL_NV_path_rendering" },
+    { "glGetPathCommandsNV", "GL_NV_path_rendering" },
+    { "glGetPathCoordsNV", "GL_NV_path_rendering" },
+    { "glGetPathDashArrayNV", "GL_NV_path_rendering" },
+    { "glGetPathLengthNV", "GL_NV_path_rendering" },
+    { "glGetPathMetricRangeNV", "GL_NV_path_rendering" },
+    { "glGetPathMetricsNV", "GL_NV_path_rendering" },
+    { "glGetPathParameterfvNV", "GL_NV_path_rendering" },
+    { "glGetPathParameterivNV", "GL_NV_path_rendering" },
+    { "glGetPathSpacingNV", "GL_NV_path_rendering" },
+    { "glGetPathTexGenfvNV", "GL_NV_path_rendering" },
+    { "glGetPathTexGenivNV", "GL_NV_path_rendering" },
+    { "glGetPerfCounterInfoINTEL", "GL_INTEL_performance_query" },
+    { "glGetPerfMonitorCounterDataAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfMonitorCounterInfoAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfMonitorCounterStringAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfMonitorCountersAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfMonitorGroupStringAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfMonitorGroupsAMD", "GL_AMD_performance_monitor" },
+    { "glGetPerfQueryDataINTEL", "GL_INTEL_performance_query" },
+    { "glGetPerfQueryIdByNameINTEL", "GL_INTEL_performance_query" },
+    { "glGetPerfQueryInfoINTEL", "GL_INTEL_performance_query" },
+    { "glGetPixelMapxv", "GL_OES_fixed_point" },
+    { "glGetPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture" },
+    { "glGetPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture" },
+    { "glGetPixelTransformParameterfvEXT", "GL_EXT_pixel_transform" },
+    { "glGetPixelTransformParameterivEXT", "GL_EXT_pixel_transform" },
+    { "glGetPointerIndexedvEXT", "GL_EXT_direct_state_access" },
+    { "glGetPointeri_vEXT", "GL_EXT_direct_state_access" },
+    { "glGetPointervEXT", "GL_EXT_vertex_array" },
+    { "glGetProgramBinary", "GL_ARB_get_program_binary GL_VERSION_4_1" },
+    { "glGetProgramEnvParameterIivNV", "GL_NV_gpu_program4" },
+    { "glGetProgramEnvParameterIuivNV", "GL_NV_gpu_program4" },
+    { "glGetProgramEnvParameterdvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramEnvParameterfvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramInfoLog", "GL_VERSION_2_0" },
+    { "glGetProgramInterfaceiv", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramLocalParameterIivNV", "GL_NV_gpu_program4" },
+    { "glGetProgramLocalParameterIuivNV", "GL_NV_gpu_program4" },
+    { "glGetProgramLocalParameterdvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramLocalParameterfvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramNamedParameterdvNV", "GL_NV_fragment_program" },
+    { "glGetProgramNamedParameterfvNV", "GL_NV_fragment_program" },
+    { "glGetProgramParameterdvNV", "GL_NV_vertex_program" },
+    { "glGetProgramParameterfvNV", "GL_NV_vertex_program" },
+    { "glGetProgramPipelineInfoLog", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glGetProgramPipelineiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glGetProgramResourceIndex", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramResourceLocation", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramResourceLocationIndex", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramResourceName", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramResourcefvNV", "GL_NV_path_rendering" },
+    { "glGetProgramResourceiv", "GL_ARB_program_interface_query GL_VERSION_4_3" },
+    { "glGetProgramStageiv", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetProgramStringARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramStringNV", "GL_NV_vertex_program" },
+    { "glGetProgramSubroutineParameteruivNV", "GL_NV_gpu_program5" },
+    { "glGetProgramiv", "GL_VERSION_2_0" },
+    { "glGetProgramivARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glGetProgramivNV", "GL_NV_vertex_program" },
+    { "glGetQueryBufferObjecti64v", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetQueryBufferObjectiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetQueryBufferObjectui64v", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetQueryBufferObjectuiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetQueryIndexediv", "GL_ARB_transform_feedback3 GL_VERSION_4_0" },
+    { "glGetQueryObjecti64v", "GL_ARB_timer_query GL_VERSION_3_3" },
+    { "glGetQueryObjecti64vEXT", "GL_EXT_timer_query" },
+    { "glGetQueryObjectiv", "GL_VERSION_1_5" },
+    { "glGetQueryObjectivARB", "GL_ARB_occlusion_query" },
+    { "glGetQueryObjectui64v", "GL_ARB_timer_query GL_VERSION_3_3" },
+    { "glGetQueryObjectui64vEXT", "GL_EXT_timer_query" },
+    { "glGetQueryObjectuiv", "GL_VERSION_1_5" },
+    { "glGetQueryObjectuivARB", "GL_ARB_occlusion_query" },
+    { "glGetQueryiv", "GL_VERSION_1_5" },
+    { "glGetQueryivARB", "GL_ARB_occlusion_query" },
+    { "glGetRenderbufferParameteriv", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glGetRenderbufferParameterivEXT", "GL_EXT_framebuffer_object" },
+    { "glGetSamplerParameterIiv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glGetSamplerParameterIuiv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glGetSamplerParameterfv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glGetSamplerParameteriv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glGetSemaphoreParameterui64vEXT", "GL_EXT_semaphore" },
+    { "glGetSeparableFilter", "GL_ARB_imaging" },
+    { "glGetSeparableFilterEXT", "GL_EXT_convolution" },
+    { "glGetShaderInfoLog", "GL_VERSION_2_0" },
+    { "glGetShaderPrecisionFormat", "GL_ARB_ES2_compatibility GL_VERSION_4_1" },
+    { "glGetShaderSource", "GL_VERSION_2_0" },
+    { "glGetShaderSourceARB", "GL_ARB_shader_objects" },
+    { "glGetShaderiv", "GL_VERSION_2_0" },
+    { "glGetShadingRateImagePaletteNV", "GL_NV_shading_rate_image" },
+    { "glGetShadingRateSampleLocationivNV", "GL_NV_shading_rate_image" },
+    { "glGetSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture" },
+    { "glGetStageIndexNV", "GL_NV_command_list" },
+    { "glGetStringi", "GL_VERSION_3_0" },
+    { "glGetSubroutineIndex", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetSubroutineUniformLocation", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetSynciv", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glGetTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap" },
+    { "glGetTexBumpParameterivATI", "GL_ATI_envmap_bumpmap" },
+    { "glGetTexEnvxvOES", "GL_OES_fixed_point" },
+    { "glGetTexFilterFuncSGIS", "GL_SGIS_texture_filter4" },
+    { "glGetTexGenxvOES", "GL_OES_fixed_point" },
+    { "glGetTexLevelParameterxvOES", "GL_OES_fixed_point" },
+    { "glGetTexParameterIiv", "GL_VERSION_3_0" },
+    { "glGetTexParameterIivEXT", "GL_EXT_texture_integer" },
+    { "glGetTexParameterIuiv", "GL_VERSION_3_0" },
+    { "glGetTexParameterIuivEXT", "GL_EXT_texture_integer" },
+    { "glGetTexParameterPointervAPPLE", "GL_APPLE_texture_range" },
+    { "glGetTexParameterxvOES", "GL_OES_fixed_point" },
+    { "glGetTextureHandleARB", "GL_ARB_bindless_texture" },
+    { "glGetTextureHandleNV", "GL_NV_bindless_texture" },
+    { "glGetTextureImage", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureImageEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureLevelParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureLevelParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureLevelParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureLevelParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureParameterIiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureParameterIivEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureParameterIuiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureParameterIuivEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTextureParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glGetTextureSamplerHandleARB", "GL_ARB_bindless_texture" },
+    { "glGetTextureSamplerHandleNV", "GL_NV_bindless_texture" },
+    { "glGetTextureSubImage", "GL_ARB_get_texture_sub_image GL_VERSION_4_5" },
+    { "glGetTrackMatrixivNV", "GL_NV_vertex_program" },
+    { "glGetTransformFeedbackVarying", "GL_VERSION_3_0" },
+    { "glGetTransformFeedbackVaryingEXT", "GL_EXT_transform_feedback" },
+    { "glGetTransformFeedbackVaryingNV", "GL_NV_transform_feedback" },
+    { "glGetTransformFeedbacki64_v", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTransformFeedbacki_v", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetTransformFeedbackiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetUniformBlockIndex", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetUniformBufferSizeEXT", "GL_EXT_bindable_uniform" },
+    { "glGetUniformIndices", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glGetUniformLocation", "GL_VERSION_2_0" },
+    { "glGetUniformLocationARB", "GL_ARB_shader_objects" },
+    { "glGetUniformOffsetEXT", "GL_EXT_bindable_uniform" },
+    { "glGetUniformSubroutineuiv", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glGetUniformdv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glGetUniformfv", "GL_VERSION_2_0" },
+    { "glGetUniformfvARB", "GL_ARB_shader_objects" },
+    { "glGetUniformi64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glGetUniformi64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glGetUniformiv", "GL_VERSION_2_0" },
+    { "glGetUniformivARB", "GL_ARB_shader_objects" },
+    { "glGetUniformui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glGetUniformui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_shader_buffer_load" },
+    { "glGetUniformuiv", "GL_VERSION_3_0" },
+    { "glGetUniformuivEXT", "GL_EXT_gpu_shader4" },
+    { "glGetUnsignedBytei_vEXT", "GL_EXT_memory_object GL_EXT_semaphore" },
+    { "glGetUnsignedBytevEXT", "GL_EXT_memory_object GL_EXT_semaphore" },
+    { "glGetVariantArrayObjectfvATI", "GL_ATI_vertex_array_object" },
+    { "glGetVariantArrayObjectivATI", "GL_ATI_vertex_array_object" },
+    { "glGetVariantBooleanvEXT", "GL_EXT_vertex_shader" },
+    { "glGetVariantFloatvEXT", "GL_EXT_vertex_shader" },
+    { "glGetVariantIntegervEXT", "GL_EXT_vertex_shader" },
+    { "glGetVariantPointervEXT", "GL_EXT_vertex_shader" },
+    { "glGetVaryingLocationNV", "GL_NV_transform_feedback" },
+    { "glGetVertexArrayIndexed64iv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetVertexArrayIndexediv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetVertexArrayIntegeri_vEXT", "GL_EXT_direct_state_access" },
+    { "glGetVertexArrayIntegervEXT", "GL_EXT_direct_state_access" },
+    { "glGetVertexArrayPointeri_vEXT", "GL_EXT_direct_state_access" },
+    { "glGetVertexArrayPointervEXT", "GL_EXT_direct_state_access" },
+    { "glGetVertexArrayiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glGetVertexAttribArrayObjectfvATI", "GL_ATI_vertex_attrib_array_object" },
+    { "glGetVertexAttribArrayObjectivATI", "GL_ATI_vertex_attrib_array_object" },
+    { "glGetVertexAttribIiv", "GL_VERSION_3_0" },
+    { "glGetVertexAttribIivEXT", "GL_NV_vertex_program4" },
+    { "glGetVertexAttribIuiv", "GL_VERSION_3_0" },
+    { "glGetVertexAttribIuivEXT", "GL_NV_vertex_program4" },
+    { "glGetVertexAttribLdv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glGetVertexAttribLdvEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glGetVertexAttribLi64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glGetVertexAttribLui64vARB", "GL_ARB_bindless_texture" },
+    { "glGetVertexAttribLui64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glGetVertexAttribPointerv", "GL_VERSION_2_0" },
+    { "glGetVertexAttribPointervARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glGetVertexAttribPointervNV", "GL_NV_vertex_program" },
+    { "glGetVertexAttribdv", "GL_VERSION_2_0" },
+    { "glGetVertexAttribdvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glGetVertexAttribdvNV", "GL_NV_vertex_program" },
+    { "glGetVertexAttribfv", "GL_VERSION_2_0" },
+    { "glGetVertexAttribfvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glGetVertexAttribfvNV", "GL_NV_vertex_program" },
+    { "glGetVertexAttribiv", "GL_VERSION_2_0" },
+    { "glGetVertexAttribivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glGetVertexAttribivNV", "GL_NV_vertex_program" },
+    { "glGetVideoCaptureStreamdvNV", "GL_NV_video_capture" },
+    { "glGetVideoCaptureStreamfvNV", "GL_NV_video_capture" },
+    { "glGetVideoCaptureStreamivNV", "GL_NV_video_capture" },
+    { "glGetVideoCaptureivNV", "GL_NV_video_capture" },
+    { "glGetVideoi64vNV", "GL_NV_present_video" },
+    { "glGetVideoivNV", "GL_NV_present_video" },
+    { "glGetVideoui64vNV", "GL_NV_present_video" },
+    { "glGetVideouivNV", "GL_NV_present_video" },
+    { "glGetVkProcAddrNV", "GL_NV_draw_vulkan_image" },
+    { "glGetnColorTable", "GL_VERSION_4_5" },
+    { "glGetnColorTableARB", "GL_ARB_robustness" },
+    { "glGetnCompressedTexImage", "GL_VERSION_4_5" },
+    { "glGetnCompressedTexImageARB", "GL_ARB_robustness" },
+    { "glGetnConvolutionFilter", "GL_VERSION_4_5" },
+    { "glGetnConvolutionFilterARB", "GL_ARB_robustness" },
+    { "glGetnHistogram", "GL_VERSION_4_5" },
+    { "glGetnHistogramARB", "GL_ARB_robustness" },
+    { "glGetnMapdv", "GL_VERSION_4_5" },
+    { "glGetnMapdvARB", "GL_ARB_robustness" },
+    { "glGetnMapfv", "GL_VERSION_4_5" },
+    { "glGetnMapfvARB", "GL_ARB_robustness" },
+    { "glGetnMapiv", "GL_VERSION_4_5" },
+    { "glGetnMapivARB", "GL_ARB_robustness" },
+    { "glGetnMinmax", "GL_VERSION_4_5" },
+    { "glGetnMinmaxARB", "GL_ARB_robustness" },
+    { "glGetnPixelMapfv", "GL_VERSION_4_5" },
+    { "glGetnPixelMapfvARB", "GL_ARB_robustness" },
+    { "glGetnPixelMapuiv", "GL_VERSION_4_5" },
+    { "glGetnPixelMapuivARB", "GL_ARB_robustness" },
+    { "glGetnPixelMapusv", "GL_VERSION_4_5" },
+    { "glGetnPixelMapusvARB", "GL_ARB_robustness" },
+    { "glGetnPolygonStipple", "GL_VERSION_4_5" },
+    { "glGetnPolygonStippleARB", "GL_ARB_robustness" },
+    { "glGetnSeparableFilter", "GL_VERSION_4_5" },
+    { "glGetnSeparableFilterARB", "GL_ARB_robustness" },
+    { "glGetnTexImage", "GL_VERSION_4_5" },
+    { "glGetnTexImageARB", "GL_ARB_robustness" },
+    { "glGetnUniformdv", "GL_VERSION_4_5" },
+    { "glGetnUniformdvARB", "GL_ARB_robustness" },
+    { "glGetnUniformfv", "GL_KHR_robustness GL_VERSION_4_5" },
+    { "glGetnUniformfvARB", "GL_ARB_robustness" },
+    { "glGetnUniformi64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glGetnUniformiv", "GL_KHR_robustness GL_VERSION_4_5" },
+    { "glGetnUniformivARB", "GL_ARB_robustness" },
+    { "glGetnUniformui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glGetnUniformuiv", "GL_KHR_robustness GL_VERSION_4_5" },
+    { "glGetnUniformuivARB", "GL_ARB_robustness" },
+    { "glGlobalAlphaFactorbSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactordSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactorfSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactoriSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactorsSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactorubSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactoruiSUN", "GL_SUN_global_alpha" },
+    { "glGlobalAlphaFactorusSUN", "GL_SUN_global_alpha" },
+    { "glHintPGI", "GL_PGI_misc_hints" },
+    { "glHistogram", "GL_ARB_imaging" },
+    { "glHistogramEXT", "GL_EXT_histogram" },
+    { "glIglooInterfaceSGIX", "GL_SGIX_igloo_interface" },
+    { "glImageTransformParameterfHP", "GL_HP_image_transform" },
+    { "glImageTransformParameterfvHP", "GL_HP_image_transform" },
+    { "glImageTransformParameteriHP", "GL_HP_image_transform" },
+    { "glImageTransformParameterivHP", "GL_HP_image_transform" },
+    { "glImportMemoryFdEXT", "GL_EXT_memory_object_fd" },
+    { "glImportMemoryWin32HandleEXT", "GL_EXT_memory_object_win32" },
+    { "glImportMemoryWin32NameEXT", "GL_EXT_memory_object_win32" },
+    { "glImportSemaphoreFdEXT", "GL_EXT_semaphore_fd" },
+    { "glImportSemaphoreWin32HandleEXT", "GL_EXT_semaphore_win32" },
+    { "glImportSemaphoreWin32NameEXT", "GL_EXT_semaphore_win32" },
+    { "glImportSyncEXT", "GL_EXT_x11_sync_object" },
+    { "glIndexFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glIndexFuncEXT", "GL_EXT_index_func" },
+    { "glIndexMaterialEXT", "GL_EXT_index_material" },
+    { "glIndexPointerEXT", "GL_EXT_vertex_array" },
+    { "glIndexPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glIndexxOES", "GL_OES_fixed_point" },
+    { "glIndexxvOES", "GL_OES_fixed_point" },
+    { "glInsertComponentEXT", "GL_EXT_vertex_shader" },
+    { "glInsertEventMarkerEXT", "GL_EXT_debug_marker" },
+    { "glInstrumentsBufferSGIX", "GL_SGIX_instruments" },
+    { "glInterpolatePathsNV", "GL_NV_path_rendering" },
+    { "glInvalidateBufferData", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glInvalidateBufferSubData", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glInvalidateFramebuffer", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glInvalidateNamedFramebufferData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glInvalidateNamedFramebufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glInvalidateSubFramebuffer", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glInvalidateTexImage", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glInvalidateTexSubImage", "GL_ARB_invalidate_subdata GL_VERSION_4_3" },
+    { "glIsAsyncMarkerSGIX", "GL_SGIX_async" },
+    { "glIsBuffer", "GL_VERSION_1_5" },
+    { "glIsBufferARB", "GL_ARB_vertex_buffer_object" },
+    { "glIsBufferResidentNV", "GL_NV_shader_buffer_load" },
+    { "glIsCommandListNV", "GL_NV_command_list" },
+    { "glIsEnabledIndexedEXT", "GL_EXT_direct_state_access GL_EXT_draw_buffers2" },
+    { "glIsEnabledi", "GL_VERSION_3_0" },
+    { "glIsFenceAPPLE", "GL_APPLE_fence" },
+    { "glIsFenceNV", "GL_NV_fence" },
+    { "glIsFramebuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glIsFramebufferEXT", "GL_EXT_framebuffer_object" },
+    { "glIsImageHandleResidentARB", "GL_ARB_bindless_texture" },
+    { "glIsImageHandleResidentNV", "GL_NV_bindless_texture" },
+    { "glIsMemoryObjectEXT", "GL_EXT_memory_object" },
+    { "glIsNameAMD", "GL_AMD_name_gen_delete" },
+    { "glIsNamedBufferResidentNV", "GL_NV_shader_buffer_load" },
+    { "glIsNamedStringARB", "GL_ARB_shading_language_include" },
+    { "glIsObjectBufferATI", "GL_ATI_vertex_array_object" },
+    { "glIsOcclusionQueryNV", "GL_NV_occlusion_query" },
+    { "glIsPathNV", "GL_NV_path_rendering" },
+    { "glIsPointInFillPathNV", "GL_NV_path_rendering" },
+    { "glIsPointInStrokePathNV", "GL_NV_path_rendering" },
+    { "glIsProgram", "GL_VERSION_2_0" },
+    { "glIsProgramARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glIsProgramNV", "GL_NV_vertex_program" },
+    { "glIsProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glIsQuery", "GL_VERSION_1_5" },
+    { "glIsQueryARB", "GL_ARB_occlusion_query" },
+    { "glIsRenderbuffer", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glIsRenderbufferEXT", "GL_EXT_framebuffer_object" },
+    { "glIsSampler", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glIsSemaphoreEXT", "GL_EXT_semaphore" },
+    { "glIsShader", "GL_VERSION_2_0" },
+    { "glIsStateNV", "GL_NV_command_list" },
+    { "glIsSync", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glIsTextureEXT", "GL_EXT_texture_object" },
+    { "glIsTextureHandleResidentARB", "GL_ARB_bindless_texture" },
+    { "glIsTextureHandleResidentNV", "GL_NV_bindless_texture" },
+    { "glIsTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glIsTransformFeedbackNV", "GL_NV_transform_feedback2" },
+    { "glIsVariantEnabledEXT", "GL_EXT_vertex_shader" },
+    { "glIsVertexArray", "GL_ARB_vertex_array_object GL_VERSION_3_0" },
+    { "glIsVertexArrayAPPLE", "GL_APPLE_vertex_array_object" },
+    { "glIsVertexAttribEnabledAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glLGPUCopyImageSubDataNVX", "GL_NVX_linked_gpu_multicast" },
+    { "glLGPUInterlockNVX", "GL_NVX_linked_gpu_multicast" },
+    { "glLGPUNamedBufferSubDataNVX", "GL_NVX_linked_gpu_multicast" },
+    { "glLabelObjectEXT", "GL_EXT_debug_label" },
+    { "glLightEnviSGIX", "GL_SGIX_fragment_lighting" },
+    { "glLightModelxOES", "GL_OES_fixed_point" },
+    { "glLightModelxvOES", "GL_OES_fixed_point" },
+    { "glLightxOES", "GL_OES_fixed_point" },
+    { "glLightxvOES", "GL_OES_fixed_point" },
+    { "glLineWidthxOES", "GL_OES_fixed_point" },
+    { "glLinkProgram", "GL_VERSION_2_0" },
+    { "glLinkProgramARB", "GL_ARB_shader_objects" },
+    { "glListDrawCommandsStatesClientNV", "GL_NV_command_list" },
+    { "glListParameterfSGIX", "GL_SGIX_list_priority" },
+    { "glListParameterfvSGIX", "GL_SGIX_list_priority" },
+    { "glListParameteriSGIX", "GL_SGIX_list_priority" },
+    { "glListParameterivSGIX", "GL_SGIX_list_priority" },
+    { "glLoadIdentityDeformationMapSGIX", "GL_SGIX_polynomial_ffd" },
+    { "glLoadMatrixxOES", "GL_OES_fixed_point" },
+    { "glLoadProgramNV", "GL_NV_vertex_program" },
+    { "glLoadTransposeMatrixd", "GL_VERSION_1_3" },
+    { "glLoadTransposeMatrixdARB", "GL_ARB_transpose_matrix" },
+    { "glLoadTransposeMatrixf", "GL_VERSION_1_3" },
+    { "glLoadTransposeMatrixfARB", "GL_ARB_transpose_matrix" },
+    { "glLoadTransposeMatrixxOES", "GL_OES_fixed_point" },
+    { "glLockArraysEXT", "GL_EXT_compiled_vertex_array" },
+    { "glMTexCoord2fSGIS", "GL_SGIS_multitexture" },
+    { "glMTexCoord2fvSGIS", "GL_SGIS_multitexture" },
+    { "glMakeBufferNonResidentNV", "GL_NV_shader_buffer_load" },
+    { "glMakeBufferResidentNV", "GL_NV_shader_buffer_load" },
+    { "glMakeImageHandleNonResidentARB", "GL_ARB_bindless_texture" },
+    { "glMakeImageHandleNonResidentNV", "GL_NV_bindless_texture" },
+    { "glMakeImageHandleResidentARB", "GL_ARB_bindless_texture" },
+    { "glMakeImageHandleResidentNV", "GL_NV_bindless_texture" },
+    { "glMakeNamedBufferNonResidentNV", "GL_NV_shader_buffer_load" },
+    { "glMakeNamedBufferResidentNV", "GL_NV_shader_buffer_load" },
+    { "glMakeTextureHandleNonResidentARB", "GL_ARB_bindless_texture" },
+    { "glMakeTextureHandleNonResidentNV", "GL_NV_bindless_texture" },
+    { "glMakeTextureHandleResidentARB", "GL_ARB_bindless_texture" },
+    { "glMakeTextureHandleResidentNV", "GL_NV_bindless_texture" },
+    { "glMap1xOES", "GL_OES_fixed_point" },
+    { "glMap2xOES", "GL_OES_fixed_point" },
+    { "glMapBuffer", "GL_VERSION_1_5" },
+    { "glMapBufferARB", "GL_ARB_vertex_buffer_object" },
+    { "glMapBufferRange", "GL_ARB_map_buffer_range GL_VERSION_3_0" },
+    { "glMapControlPointsNV", "GL_NV_evaluators" },
+    { "glMapGrid1xOES", "GL_OES_fixed_point" },
+    { "glMapGrid2xOES", "GL_OES_fixed_point" },
+    { "glMapNamedBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glMapNamedBufferEXT", "GL_EXT_direct_state_access" },
+    { "glMapNamedBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glMapNamedBufferRangeEXT", "GL_EXT_direct_state_access" },
+    { "glMapObjectBufferATI", "GL_ATI_map_object_buffer" },
+    { "glMapParameterfvNV", "GL_NV_evaluators" },
+    { "glMapParameterivNV", "GL_NV_evaluators" },
+    { "glMapTexture2DINTEL", "GL_INTEL_map_texture" },
+    { "glMapVertexAttrib1dAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glMapVertexAttrib1fAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glMapVertexAttrib2dAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glMapVertexAttrib2fAPPLE", "GL_APPLE_vertex_program_evaluators" },
+    { "glMaterialxOES", "GL_OES_fixed_point" },
+    { "glMaterialxvOES", "GL_OES_fixed_point" },
+    { "glMatrixFrustumEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixIndexPointerARB", "GL_ARB_matrix_palette" },
+    { "glMatrixIndexubvARB", "GL_ARB_matrix_palette" },
+    { "glMatrixIndexuivARB", "GL_ARB_matrix_palette" },
+    { "glMatrixIndexusvARB", "GL_ARB_matrix_palette" },
+    { "glMatrixLoad3x2fNV", "GL_NV_path_rendering" },
+    { "glMatrixLoad3x3fNV", "GL_NV_path_rendering" },
+    { "glMatrixLoadIdentityEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixLoadTranspose3x3fNV", "GL_NV_path_rendering" },
+    { "glMatrixLoadTransposedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixLoadTransposefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixLoaddEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixLoadfEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixMult3x2fNV", "GL_NV_path_rendering" },
+    { "glMatrixMult3x3fNV", "GL_NV_path_rendering" },
+    { "glMatrixMultTranspose3x3fNV", "GL_NV_path_rendering" },
+    { "glMatrixMultTransposedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixMultTransposefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixMultdEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixMultfEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixOrthoEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixPopEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixPushEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixRotatedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixRotatefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixScaledEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixScalefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixTranslatedEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMatrixTranslatefEXT", "GL_EXT_direct_state_access GL_NV_path_rendering" },
+    { "glMaxShaderCompilerThreadsARB", "GL_ARB_parallel_shader_compile" },
+    { "glMaxShaderCompilerThreadsKHR", "GL_KHR_parallel_shader_compile" },
+    { "glMemoryBarrier", "GL_ARB_shader_image_load_store GL_VERSION_4_2" },
+    { "glMemoryBarrierByRegion", "GL_ARB_ES3_1_compatibility GL_VERSION_4_5" },
+    { "glMemoryBarrierEXT", "GL_EXT_shader_image_load_store" },
+    { "glMemoryObjectParameterivEXT", "GL_EXT_memory_object" },
+    { "glMinSampleShading", "GL_VERSION_4_0" },
+    { "glMinSampleShadingARB", "GL_ARB_sample_shading" },
+    { "glMinmax", "GL_ARB_imaging" },
+    { "glMinmaxEXT", "GL_EXT_histogram" },
+    { "glMultMatrixxOES", "GL_OES_fixed_point" },
+    { "glMultTransposeMatrixd", "GL_VERSION_1_3" },
+    { "glMultTransposeMatrixdARB", "GL_ARB_transpose_matrix" },
+    { "glMultTransposeMatrixf", "GL_VERSION_1_3" },
+    { "glMultTransposeMatrixfARB", "GL_ARB_transpose_matrix" },
+    { "glMultTransposeMatrixxOES", "GL_OES_fixed_point" },
+    { "glMultiDrawArrays", "GL_VERSION_1_4" },
+    { "glMultiDrawArraysEXT", "GL_EXT_multi_draw_arrays" },
+    { "glMultiDrawArraysIndirect", "GL_ARB_multi_draw_indirect GL_VERSION_4_3" },
+    { "glMultiDrawArraysIndirectAMD", "GL_AMD_multi_draw_indirect" },
+    { "glMultiDrawArraysIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count" },
+    { "glMultiDrawArraysIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect" },
+    { "glMultiDrawArraysIndirectCount", "GL_VERSION_4_6" },
+    { "glMultiDrawArraysIndirectCountARB", "GL_ARB_indirect_parameters" },
+    { "glMultiDrawElementArrayAPPLE", "GL_APPLE_element_array" },
+    { "glMultiDrawElements", "GL_VERSION_1_4" },
+    { "glMultiDrawElementsBaseVertex", "GL_ARB_draw_elements_base_vertex GL_VERSION_3_2" },
+    { "glMultiDrawElementsEXT", "GL_EXT_multi_draw_arrays" },
+    { "glMultiDrawElementsIndirect", "GL_ARB_multi_draw_indirect GL_VERSION_4_3" },
+    { "glMultiDrawElementsIndirectAMD", "GL_AMD_multi_draw_indirect" },
+    { "glMultiDrawElementsIndirectBindlessCountNV", "GL_NV_bindless_multi_draw_indirect_count" },
+    { "glMultiDrawElementsIndirectBindlessNV", "GL_NV_bindless_multi_draw_indirect" },
+    { "glMultiDrawElementsIndirectCount", "GL_VERSION_4_6" },
+    { "glMultiDrawElementsIndirectCountARB", "GL_ARB_indirect_parameters" },
+    { "glMultiDrawMeshTasksIndirectCountNV", "GL_NV_mesh_shader" },
+    { "glMultiDrawMeshTasksIndirectNV", "GL_NV_mesh_shader" },
+    { "glMultiDrawRangeElementArrayAPPLE", "GL_APPLE_element_array" },
+    { "glMultiModeDrawArraysIBM", "GL_IBM_multimode_draw_arrays" },
+    { "glMultiModeDrawElementsIBM", "GL_IBM_multimode_draw_arrays" },
+    { "glMultiTexBufferEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexCoord1bOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord1bvOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord1d", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1dARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1dSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1dv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1dvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1dvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1f", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1fARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1fSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1fv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1fvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1fvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1hNV", "GL_NV_half_float" },
+    { "glMultiTexCoord1hvNV", "GL_NV_half_float" },
+    { "glMultiTexCoord1i", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1iARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1iSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1iv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1ivARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1ivSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1s", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1sARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1sSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1sv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord1svARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord1svSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord1xOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord1xvOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord2bOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord2bvOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord2d", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2dARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2dSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2dv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2dvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2dvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2f", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2fARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2fSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2fv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2fvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2fvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2hNV", "GL_NV_half_float" },
+    { "glMultiTexCoord2hvNV", "GL_NV_half_float" },
+    { "glMultiTexCoord2i", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2iARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2iSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2iv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2ivARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2ivSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2s", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2sARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2sSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2sv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord2svARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord2svSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord2xOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord2xvOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord3bOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord3bvOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord3d", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3dARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3dSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3dv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3dvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3dvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3f", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3fARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3fSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3fv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3fvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3fvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3hNV", "GL_NV_half_float" },
+    { "glMultiTexCoord3hvNV", "GL_NV_half_float" },
+    { "glMultiTexCoord3i", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3iARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3iSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3iv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3ivARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3ivSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3s", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3sARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3sSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3sv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord3svARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord3svSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord3xOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord3xvOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord4bOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord4bvOES", "GL_OES_byte_coordinates" },
+    { "glMultiTexCoord4d", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4dARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4dSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4dv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4dvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4dvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4f", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4fARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4fSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4fv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4fvARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4fvSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4hNV", "GL_NV_half_float" },
+    { "glMultiTexCoord4hvNV", "GL_NV_half_float" },
+    { "glMultiTexCoord4i", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4iARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4iSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4iv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4ivARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4ivSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4s", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4sARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4sSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4sv", "GL_VERSION_1_3" },
+    { "glMultiTexCoord4svARB", "GL_ARB_multitexture" },
+    { "glMultiTexCoord4svSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexCoord4xOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoord4xvOES", "GL_OES_fixed_point" },
+    { "glMultiTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glMultiTexCoordPointerEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexCoordPointerSGIS", "GL_SGIS_multitexture" },
+    { "glMultiTexEnvfEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexEnvfvEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexEnviEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexEnvivEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGendEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGendvEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGenfEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGenfvEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGeniEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexGenivEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameterIivEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameterIuivEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameterfEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameteriEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexRenderbufferEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glMultiTexSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glMulticastBarrierNV", "GL_NV_gpu_multicast" },
+    { "glMulticastBlitFramebufferNV", "GL_NV_gpu_multicast" },
+    { "glMulticastBufferSubDataNV", "GL_NV_gpu_multicast" },
+    { "glMulticastCopyBufferSubDataNV", "GL_NV_gpu_multicast" },
+    { "glMulticastCopyImageSubDataNV", "GL_NV_gpu_multicast" },
+    { "glMulticastFramebufferSampleLocationsfvNV", "GL_NV_gpu_multicast" },
+    { "glMulticastGetQueryObjecti64vNV", "GL_NV_gpu_multicast" },
+    { "glMulticastGetQueryObjectivNV", "GL_NV_gpu_multicast" },
+    { "glMulticastGetQueryObjectui64vNV", "GL_NV_gpu_multicast" },
+    { "glMulticastGetQueryObjectuivNV", "GL_NV_gpu_multicast" },
+    { "glMulticastScissorArrayvNVX", "GL_NVX_gpu_multicast2" },
+    { "glMulticastViewportArrayvNVX", "GL_NVX_gpu_multicast2" },
+    { "glMulticastViewportPositionWScaleNVX", "GL_NVX_gpu_multicast2" },
+    { "glMulticastWaitSyncNV", "GL_NV_gpu_multicast" },
+    { "glNamedBufferAttachMemoryNV", "GL_NV_memory_attachment" },
+    { "glNamedBufferData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedBufferDataEXT", "GL_EXT_direct_state_access" },
+    { "glNamedBufferPageCommitmentARB", "GL_ARB_sparse_buffer" },
+    { "glNamedBufferPageCommitmentEXT", "GL_ARB_sparse_buffer" },
+    { "glNamedBufferStorage", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedBufferStorageEXT", "GL_EXT_direct_state_access" },
+    { "glNamedBufferStorageExternalEXT", "GL_EXT_external_buffer" },
+    { "glNamedBufferStorageMemEXT", "GL_EXT_memory_object" },
+    { "glNamedBufferSubData", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedBufferSubDataEXT", "GL_EXT_direct_state_access" },
+    { "glNamedCopyBufferSubDataEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferDrawBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferDrawBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferParameteri", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferParameteriEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferReadBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferRenderbuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferRenderbufferEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferSampleLocationsfvARB", "GL_ARB_sample_locations" },
+    { "glNamedFramebufferSampleLocationsfvNV", "GL_NV_sample_locations" },
+    { "glNamedFramebufferSamplePositionsfvAMD", "GL_AMD_framebuffer_sample_positions" },
+    { "glNamedFramebufferTexture", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferTexture1DEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferTexture2DEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferTexture3DEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferTextureEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferTextureFaceEXT", "GL_EXT_direct_state_access" },
+    { "glNamedFramebufferTextureLayer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedFramebufferTextureLayerEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameter4dEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameter4dvEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameter4fEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameter4fvEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameterI4iEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameterI4ivEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameterI4uiEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameterI4uivEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParameters4fvEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParametersI4ivEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramLocalParametersI4uivEXT", "GL_EXT_direct_state_access" },
+    { "glNamedProgramStringEXT", "GL_EXT_direct_state_access" },
+    { "glNamedRenderbufferStorage", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedRenderbufferStorageEXT", "GL_EXT_direct_state_access" },
+    { "glNamedRenderbufferStorageMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glNamedRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced" },
+    { "glNamedRenderbufferStorageMultisampleCoverageEXT", "GL_EXT_direct_state_access" },
+    { "glNamedRenderbufferStorageMultisampleEXT", "GL_EXT_direct_state_access" },
+    { "glNamedStringARB", "GL_ARB_shading_language_include" },
+    { "glNewBufferRegion", "GL_KTX_buffer_region" },
+    { "glNewObjectBufferATI", "GL_ATI_vertex_array_object" },
+    { "glNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glNormal3hNV", "GL_NV_half_float" },
+    { "glNormal3hvNV", "GL_NV_half_float" },
+    { "glNormal3xOES", "GL_OES_fixed_point" },
+    { "glNormal3xvOES", "GL_OES_fixed_point" },
+    { "glNormalFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glNormalP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glNormalP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glNormalPointerEXT", "GL_EXT_vertex_array" },
+    { "glNormalPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glNormalPointervINTEL", "GL_INTEL_parallel_arrays" },
+    { "glNormalStream3bATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3bvATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3dATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3dvATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3fATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3fvATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3iATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3ivATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3sATI", "GL_ATI_vertex_streams" },
+    { "glNormalStream3svATI", "GL_ATI_vertex_streams" },
+    { "glObjectLabel", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glObjectPtrLabel", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glObjectPurgeableAPPLE", "GL_APPLE_object_purgeable" },
+    { "glObjectUnpurgeableAPPLE", "GL_APPLE_object_purgeable" },
+    { "glOrthofOES", "GL_OES_single_precision" },
+    { "glOrthoxOES", "GL_OES_fixed_point" },
+    { "glPNTrianglesfATI", "GL_ATI_pn_triangles" },
+    { "glPNTrianglesiATI", "GL_ATI_pn_triangles" },
+    { "glPassTexCoordATI", "GL_ATI_fragment_shader" },
+    { "glPassThroughxOES", "GL_OES_fixed_point" },
+    { "glPatchParameterfv", "GL_ARB_tessellation_shader GL_VERSION_4_0" },
+    { "glPatchParameteri", "GL_ARB_tessellation_shader GL_VERSION_4_0" },
+    { "glPathColorGenNV", "GL_NV_path_rendering" },
+    { "glPathCommandsNV", "GL_NV_path_rendering" },
+    { "glPathCoordsNV", "GL_NV_path_rendering" },
+    { "glPathCoverDepthFuncNV", "GL_NV_path_rendering" },
+    { "glPathDashArrayNV", "GL_NV_path_rendering" },
+    { "glPathFogGenNV", "GL_NV_path_rendering" },
+    { "glPathGlyphIndexArrayNV", "GL_NV_path_rendering" },
+    { "glPathGlyphIndexRangeNV", "GL_NV_path_rendering" },
+    { "glPathGlyphRangeNV", "GL_NV_path_rendering" },
+    { "glPathGlyphsNV", "GL_NV_path_rendering" },
+    { "glPathMemoryGlyphIndexArrayNV", "GL_NV_path_rendering" },
+    { "glPathParameterfNV", "GL_NV_path_rendering" },
+    { "glPathParameterfvNV", "GL_NV_path_rendering" },
+    { "glPathParameteriNV", "GL_NV_path_rendering" },
+    { "glPathParameterivNV", "GL_NV_path_rendering" },
+    { "glPathStencilDepthOffsetNV", "GL_NV_path_rendering" },
+    { "glPathStencilFuncNV", "GL_NV_path_rendering" },
+    { "glPathStringNV", "GL_NV_path_rendering" },
+    { "glPathSubCommandsNV", "GL_NV_path_rendering" },
+    { "glPathSubCoordsNV", "GL_NV_path_rendering" },
+    { "glPathTexGenNV", "GL_NV_path_rendering" },
+    { "glPauseTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glPauseTransformFeedbackNV", "GL_NV_transform_feedback2" },
+    { "glPixelDataRangeNV", "GL_NV_pixel_data_range" },
+    { "glPixelMapx", "GL_OES_fixed_point" },
+    { "glPixelStorex", "GL_OES_fixed_point" },
+    { "glPixelTexGenParameterfSGIS", "GL_SGIS_pixel_texture" },
+    { "glPixelTexGenParameterfvSGIS", "GL_SGIS_pixel_texture" },
+    { "glPixelTexGenParameteriSGIS", "GL_SGIS_pixel_texture" },
+    { "glPixelTexGenParameterivSGIS", "GL_SGIS_pixel_texture" },
+    { "glPixelTexGenSGIX", "GL_SGIX_pixel_texture" },
+    { "glPixelTransferxOES", "GL_OES_fixed_point" },
+    { "glPixelTransformParameterfEXT", "GL_EXT_pixel_transform" },
+    { "glPixelTransformParameterfvEXT", "GL_EXT_pixel_transform" },
+    { "glPixelTransformParameteriEXT", "GL_EXT_pixel_transform" },
+    { "glPixelTransformParameterivEXT", "GL_EXT_pixel_transform" },
+    { "glPixelZoomxOES", "GL_OES_fixed_point" },
+    { "glPointAlongPathNV", "GL_NV_path_rendering" },
+    { "glPointParameterf", "GL_VERSION_1_4" },
+    { "glPointParameterfARB", "GL_ARB_point_parameters" },
+    { "glPointParameterfEXT", "GL_EXT_point_parameters" },
+    { "glPointParameterfSGIS", "GL_SGIS_point_parameters" },
+    { "glPointParameterfv", "GL_VERSION_1_4" },
+    { "glPointParameterfvARB", "GL_ARB_point_parameters" },
+    { "glPointParameterfvEXT", "GL_EXT_point_parameters" },
+    { "glPointParameterfvSGIS", "GL_SGIS_point_parameters" },
+    { "glPointParameteri", "GL_VERSION_1_4" },
+    { "glPointParameteriNV", "GL_NV_point_sprite" },
+    { "glPointParameteriv", "GL_VERSION_1_4" },
+    { "glPointParameterivNV", "GL_NV_point_sprite" },
+    { "glPointParameterxvOES", "GL_OES_fixed_point" },
+    { "glPointSizexOES", "GL_OES_fixed_point" },
+    { "glPollAsyncSGIX", "GL_SGIX_async" },
+    { "glPollInstrumentsSGIX", "GL_SGIX_instruments" },
+    { "glPolygonOffsetClamp", "GL_ARB_polygon_offset_clamp GL_VERSION_4_6" },
+    { "glPolygonOffsetClampEXT", "GL_EXT_polygon_offset_clamp" },
+    { "glPolygonOffsetEXT", "GL_EXT_polygon_offset" },
+    { "glPolygonOffsetxOES", "GL_OES_fixed_point" },
+    { "glPopDebugGroup", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glPopGroupMarkerEXT", "GL_EXT_debug_marker" },
+    { "glPresentFrameDualFillNV", "GL_NV_present_video" },
+    { "glPresentFrameKeyedNV", "GL_NV_present_video" },
+    { "glPrimitiveBoundingBoxARB", "GL_ARB_ES3_2_compatibility" },
+    { "glPrimitiveRestartIndex", "GL_VERSION_3_1" },
+    { "glPrimitiveRestartIndexNV", "GL_NV_primitive_restart" },
+    { "glPrimitiveRestartNV", "GL_NV_primitive_restart" },
+    { "glPrioritizeTexturesEXT", "GL_EXT_texture_object" },
+    { "glPrioritizeTexturesxOES", "GL_OES_fixed_point" },
+    { "glProgramBinary", "GL_ARB_get_program_binary GL_VERSION_4_1" },
+    { "glProgramBufferParametersIivNV", "GL_NV_parameter_buffer_object" },
+    { "glProgramBufferParametersIuivNV", "GL_NV_parameter_buffer_object" },
+    { "glProgramBufferParametersfvNV", "GL_NV_parameter_buffer_object" },
+    { "glProgramEnvParameter4dARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramEnvParameter4dvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramEnvParameter4fARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramEnvParameter4fvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramEnvParameterI4iNV", "GL_NV_gpu_program4" },
+    { "glProgramEnvParameterI4ivNV", "GL_NV_gpu_program4" },
+    { "glProgramEnvParameterI4uiNV", "GL_NV_gpu_program4" },
+    { "glProgramEnvParameterI4uivNV", "GL_NV_gpu_program4" },
+    { "glProgramEnvParameters4fvEXT", "GL_EXT_gpu_program_parameters" },
+    { "glProgramEnvParametersI4ivNV", "GL_NV_gpu_program4" },
+    { "glProgramEnvParametersI4uivNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParameter4dARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramLocalParameter4dvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramLocalParameter4fARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramLocalParameter4fvARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramLocalParameterI4iNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParameterI4ivNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParameterI4uiNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParameterI4uivNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParameters4fvEXT", "GL_EXT_gpu_program_parameters" },
+    { "glProgramLocalParametersI4ivNV", "GL_NV_gpu_program4" },
+    { "glProgramLocalParametersI4uivNV", "GL_NV_gpu_program4" },
+    { "glProgramNamedParameter4dNV", "GL_NV_fragment_program" },
+    { "glProgramNamedParameter4dvNV", "GL_NV_fragment_program" },
+    { "glProgramNamedParameter4fNV", "GL_NV_fragment_program" },
+    { "glProgramNamedParameter4fvNV", "GL_NV_fragment_program" },
+    { "glProgramParameter4dNV", "GL_NV_vertex_program" },
+    { "glProgramParameter4dvNV", "GL_NV_vertex_program" },
+    { "glProgramParameter4fNV", "GL_NV_vertex_program" },
+    { "glProgramParameter4fvNV", "GL_NV_vertex_program" },
+    { "glProgramParameteri", "GL_ARB_get_program_binary GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramParameteriARB", "GL_ARB_geometry_shader4" },
+    { "glProgramParameteriEXT", "GL_EXT_geometry_shader4" },
+    { "glProgramParameters4dvNV", "GL_NV_vertex_program" },
+    { "glProgramParameters4fvNV", "GL_NV_vertex_program" },
+    { "glProgramPathFragmentInputGenNV", "GL_NV_path_rendering" },
+    { "glProgramStringARB", "GL_ARB_fragment_program GL_ARB_vertex_program" },
+    { "glProgramSubroutineParametersuivNV", "GL_NV_gpu_program5" },
+    { "glProgramUniform1d", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1dEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1f", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1fEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1i", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform1i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform1i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform1i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform1iEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1ivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform1ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform1ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform1ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform1uiEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform1uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform1uivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2d", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2dEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2f", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2fEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2i", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform2i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform2i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform2i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform2iEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2ivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform2ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform2ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform2ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform2uiEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform2uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform2uivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3d", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3dEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3f", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3fEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3i", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform3i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform3i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform3i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform3iEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3ivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform3ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform3ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform3ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform3uiEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform3uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform3uivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4d", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4dEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4f", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4fEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4i", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform4i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform4i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform4i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform4iEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4iv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4ivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4ui", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform4ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform4ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glProgramUniform4ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glProgramUniform4uiEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniform4uiv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniform4uivEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformHandleui64ARB", "GL_ARB_bindless_texture" },
+    { "glProgramUniformHandleui64NV", "GL_NV_bindless_texture" },
+    { "glProgramUniformHandleui64vARB", "GL_ARB_bindless_texture" },
+    { "glProgramUniformHandleui64vNV", "GL_NV_bindless_texture" },
+    { "glProgramUniformMatrix2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix2x3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2x3dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix2x3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2x3fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix2x4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2x4dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix2x4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix2x4fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3x2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3x2dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3x2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3x2fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3x4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3x4dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix3x4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix3x4fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4x2dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4x2dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4x2fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4x2fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4x3dv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4x3dvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformMatrix4x3fv", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glProgramUniformMatrix4x3fvEXT", "GL_EXT_direct_state_access" },
+    { "glProgramUniformui64NV", "GL_NV_shader_buffer_load" },
+    { "glProgramUniformui64vNV", "GL_NV_shader_buffer_load" },
+    { "glProgramVertexLimitNV", "GL_NV_geometry_program4" },
+    { "glProvokingVertex", "GL_ARB_provoking_vertex GL_VERSION_3_2" },
+    { "glProvokingVertexEXT", "GL_EXT_provoking_vertex" },
+    { "glPushClientAttribDefaultEXT", "GL_EXT_direct_state_access" },
+    { "glPushDebugGroup", "GL_KHR_debug GL_VERSION_4_3" },
+    { "glPushGroupMarkerEXT", "GL_EXT_debug_marker" },
+    { "glQueryCounter", "GL_ARB_timer_query GL_VERSION_3_3" },
+    { "glQueryMatrixxOES", "GL_OES_query_matrix" },
+    { "glQueryObjectParameteruiAMD", "GL_AMD_occlusion_query_event" },
+    { "glQueryResourceNV", "GL_NV_query_resource" },
+    { "glQueryResourceTagNV", "GL_NV_query_resource_tag" },
+    { "glRasterPos2xOES", "GL_OES_fixed_point" },
+    { "glRasterPos2xvOES", "GL_OES_fixed_point" },
+    { "glRasterPos3xOES", "GL_OES_fixed_point" },
+    { "glRasterPos3xvOES", "GL_OES_fixed_point" },
+    { "glRasterPos4xOES", "GL_OES_fixed_point" },
+    { "glRasterPos4xvOES", "GL_OES_fixed_point" },
+    { "glRasterSamplesEXT", "GL_EXT_raster_multisample GL_NV_framebuffer_mixed_samples" },
+    { "glReadBufferRegion", "GL_KTX_buffer_region" },
+    { "glReadInstrumentsSGIX", "GL_SGIX_instruments" },
+    { "glReadnPixels", "GL_KHR_robustness GL_VERSION_4_5" },
+    { "glReadnPixelsARB", "GL_ARB_robustness" },
+    { "glRectxOES", "GL_OES_fixed_point" },
+    { "glRectxvOES", "GL_OES_fixed_point" },
+    { "glReferencePlaneSGIX", "GL_SGIX_reference_plane" },
+    { "glReleaseKeyedMutexWin32EXT", "GL_EXT_win32_keyed_mutex" },
+    { "glReleaseShaderCompiler", "GL_ARB_ES2_compatibility GL_VERSION_4_1" },
+    { "glRenderGpuMaskNV", "GL_NV_gpu_multicast" },
+    { "glRenderbufferStorage", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glRenderbufferStorageEXT", "GL_EXT_framebuffer_object" },
+    { "glRenderbufferStorageMultisample", "GL_ARB_framebuffer_object GL_VERSION_3_0" },
+    { "glRenderbufferStorageMultisampleAdvancedAMD", "GL_AMD_framebuffer_multisample_advanced" },
+    { "glRenderbufferStorageMultisampleCoverageNV", "GL_NV_framebuffer_multisample_coverage" },
+    { "glRenderbufferStorageMultisampleEXT", "GL_EXT_framebuffer_multisample" },
+    { "glReplacementCodePointerSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeubSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeubvSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeuiColor3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiColor3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiColor4fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiColor4ubVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiColor4ubVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiTexCoord2fVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiTexCoord2fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiVertex3fSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuiVertex3fvSUN", "GL_SUN_vertex" },
+    { "glReplacementCodeuivSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeusSUN", "GL_SUN_triangle_list" },
+    { "glReplacementCodeusvSUN", "GL_SUN_triangle_list" },
+    { "glRequestResidentProgramsNV", "GL_NV_vertex_program" },
+    { "glResetHistogram", "GL_ARB_imaging" },
+    { "glResetHistogramEXT", "GL_EXT_histogram" },
+    { "glResetMemoryObjectParameterNV", "GL_NV_memory_attachment" },
+    { "glResetMinmax", "GL_ARB_imaging" },
+    { "glResetMinmaxEXT", "GL_EXT_histogram" },
+    { "glResizeBuffersMESA", "GL_MESA_resize_buffers" },
+    { "glResolveDepthValuesNV", "GL_NV_sample_locations" },
+    { "glResumeTransformFeedback", "GL_ARB_transform_feedback2 GL_VERSION_4_0" },
+    { "glResumeTransformFeedbackNV", "GL_NV_transform_feedback2" },
+    { "glRotatexOES", "GL_OES_fixed_point" },
+    { "glSampleCoverage", "GL_VERSION_1_3" },
+    { "glSampleCoverageARB", "GL_ARB_multisample" },
+    { "glSampleMapATI", "GL_ATI_fragment_shader" },
+    { "glSampleMaskEXT", "GL_EXT_multisample" },
+    { "glSampleMaskIndexedNV", "GL_NV_explicit_multisample" },
+    { "glSampleMaskSGIS", "GL_SGIS_multisample" },
+    { "glSampleMaski", "GL_ARB_texture_multisample GL_VERSION_3_2" },
+    { "glSamplePatternEXT", "GL_EXT_multisample" },
+    { "glSamplePatternSGIS", "GL_SGIS_multisample" },
+    { "glSamplerParameterIiv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glSamplerParameterIuiv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glSamplerParameterf", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glSamplerParameterfv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glSamplerParameteri", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glSamplerParameteriv", "GL_ARB_sampler_objects GL_VERSION_3_3" },
+    { "glScalexOES", "GL_OES_fixed_point" },
+    { "glScissorArrayv", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glScissorExclusiveArrayvNV", "GL_NV_scissor_exclusive" },
+    { "glScissorExclusiveNV", "GL_NV_scissor_exclusive" },
+    { "glScissorIndexed", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glScissorIndexedv", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glSecondaryColor3b", "GL_VERSION_1_4" },
+    { "glSecondaryColor3bEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3bv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3bvEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3d", "GL_VERSION_1_4" },
+    { "glSecondaryColor3dEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3dv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3dvEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3f", "GL_VERSION_1_4" },
+    { "glSecondaryColor3fEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3fv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3fvEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3hNV", "GL_NV_half_float" },
+    { "glSecondaryColor3hvNV", "GL_NV_half_float" },
+    { "glSecondaryColor3i", "GL_VERSION_1_4" },
+    { "glSecondaryColor3iEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3iv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3ivEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3s", "GL_VERSION_1_4" },
+    { "glSecondaryColor3sEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3sv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3svEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3ub", "GL_VERSION_1_4" },
+    { "glSecondaryColor3ubEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3ubv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3ubvEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3ui", "GL_VERSION_1_4" },
+    { "glSecondaryColor3uiEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3uiv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3uivEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3us", "GL_VERSION_1_4" },
+    { "glSecondaryColor3usEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColor3usv", "GL_VERSION_1_4" },
+    { "glSecondaryColor3usvEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColorFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glSecondaryColorP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glSecondaryColorP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glSecondaryColorPointer", "GL_VERSION_1_4" },
+    { "glSecondaryColorPointerEXT", "GL_EXT_secondary_color" },
+    { "glSecondaryColorPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glSelectPerfMonitorCountersAMD", "GL_AMD_performance_monitor" },
+    { "glSelectTextureCoordSetSGIS", "GL_SGIS_multitexture" },
+    { "glSelectTextureSGIS", "GL_SGIS_multitexture" },
+    { "glSemaphoreParameterui64vEXT", "GL_EXT_semaphore" },
+    { "glSeparableFilter2D", "GL_ARB_imaging" },
+    { "glSeparableFilter2DEXT", "GL_EXT_convolution" },
+    { "glSetFenceAPPLE", "GL_APPLE_fence" },
+    { "glSetFenceNV", "GL_NV_fence" },
+    { "glSetFragmentShaderConstantATI", "GL_ATI_fragment_shader" },
+    { "glSetInvariantEXT", "GL_EXT_vertex_shader" },
+    { "glSetLocalConstantEXT", "GL_EXT_vertex_shader" },
+    { "glSetMultisamplefvAMD", "GL_AMD_sample_positions" },
+    { "glShaderBinary", "GL_ARB_ES2_compatibility GL_VERSION_4_1" },
+    { "glShaderOp1EXT", "GL_EXT_vertex_shader" },
+    { "glShaderOp2EXT", "GL_EXT_vertex_shader" },
+    { "glShaderOp3EXT", "GL_EXT_vertex_shader" },
+    { "glShaderSource", "GL_VERSION_2_0" },
+    { "glShaderSourceARB", "GL_ARB_shader_objects" },
+    { "glShaderStorageBlockBinding", "GL_ARB_shader_storage_buffer_object GL_VERSION_4_3" },
+    { "glShadingRateImageBarrierNV", "GL_NV_shading_rate_image GL_NV_shading_rate_image" },
+    { "glShadingRateImagePaletteNV", "GL_NV_shading_rate_image" },
+    { "glShadingRateSampleOrderCustomNV", "GL_NV_shading_rate_image" },
+    { "glShadingRateSampleOrderNV", "GL_NV_shading_rate_image" },
+    { "glSharpenTexFuncSGIS", "GL_SGIS_sharpen_texture" },
+    { "glSignalSemaphoreEXT", "GL_EXT_semaphore" },
+    { "glSignalSemaphoreui64NVX", "GL_NVX_progress_fence" },
+    { "glSignalVkFenceNV", "GL_NV_draw_vulkan_image" },
+    { "glSignalVkSemaphoreNV", "GL_NV_draw_vulkan_image" },
+    { "glSpecializeShader", "GL_VERSION_4_6" },
+    { "glSpecializeShaderARB", "GL_ARB_gl_spirv" },
+    { "glSpriteParameterfSGIX", "GL_SGIX_sprite" },
+    { "glSpriteParameterfvSGIX", "GL_SGIX_sprite" },
+    { "glSpriteParameteriSGIX", "GL_SGIX_sprite" },
+    { "glSpriteParameterivSGIX", "GL_SGIX_sprite" },
+    { "glStartInstrumentsSGIX", "GL_SGIX_instruments" },
+    { "glStateCaptureNV", "GL_NV_command_list" },
+    { "glStencilClearTagEXT", "GL_EXT_stencil_clear_tag" },
+    { "glStencilFillPathInstancedNV", "GL_NV_path_rendering" },
+    { "glStencilFillPathNV", "GL_NV_path_rendering" },
+    { "glStencilFuncSeparate", "GL_VERSION_2_0" },
+    { "glStencilFuncSeparateATI", "GL_ATI_separate_stencil" },
+    { "glStencilMaskSeparate", "GL_VERSION_2_0" },
+    { "glStencilOpSeparate", "GL_VERSION_2_0" },
+    { "glStencilOpSeparateATI", "GL_ATI_separate_stencil" },
+    { "glStencilOpValueAMD", "GL_AMD_stencil_operation_extended" },
+    { "glStencilStrokePathInstancedNV", "GL_NV_path_rendering" },
+    { "glStencilStrokePathNV", "GL_NV_path_rendering" },
+    { "glStencilThenCoverFillPathInstancedNV", "GL_NV_path_rendering" },
+    { "glStencilThenCoverFillPathNV", "GL_NV_path_rendering" },
+    { "glStencilThenCoverStrokePathInstancedNV", "GL_NV_path_rendering" },
+    { "glStencilThenCoverStrokePathNV", "GL_NV_path_rendering" },
+    { "glStopInstrumentsSGIX", "GL_SGIX_instruments" },
+    { "glStringMarkerGREMEDY", "GL_GREMEDY_string_marker" },
+    { "glSubpixelPrecisionBiasNV", "GL_NV_conservative_raster" },
+    { "glSwizzleEXT", "GL_EXT_vertex_shader" },
+    { "glSyncTextureINTEL", "GL_INTEL_map_texture" },
+    { "glTagSampleBufferSGIX", "GL_SGIX_tag_sample_buffer" },
+    { "glTangent3bEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3bvEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3dEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3dvEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3fEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3fvEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3iEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3ivEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3sEXT", "GL_EXT_coordinate_frame" },
+    { "glTangent3svEXT", "GL_EXT_coordinate_frame" },
+    { "glTangentPointerEXT", "GL_EXT_coordinate_frame" },
+    { "glTbufferMask3DFX", "GL_3DFX_tbuffer" },
+    { "glTessellationFactorAMD", "GL_AMD_vertex_shader_tessellator" },
+    { "glTessellationModeAMD", "GL_AMD_vertex_shader_tessellator" },
+    { "glTestFenceAPPLE", "GL_APPLE_fence" },
+    { "glTestFenceNV", "GL_NV_fence" },
+    { "glTestObjectAPPLE", "GL_APPLE_fence" },
+    { "glTexAttachMemoryNV", "GL_NV_memory_attachment" },
+    { "glTexBuffer", "GL_VERSION_3_1" },
+    { "glTexBufferARB", "GL_ARB_texture_buffer_object" },
+    { "glTexBufferEXT", "GL_EXT_texture_buffer_object" },
+    { "glTexBufferRange", "GL_ARB_texture_buffer_range GL_VERSION_4_3" },
+    { "glTexBumpParameterfvATI", "GL_ATI_envmap_bumpmap" },
+    { "glTexBumpParameterivATI", "GL_ATI_envmap_bumpmap" },
+    { "glTexCoord1bOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord1bvOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord1hNV", "GL_NV_half_float" },
+    { "glTexCoord1hvNV", "GL_NV_half_float" },
+    { "glTexCoord1xOES", "GL_OES_fixed_point" },
+    { "glTexCoord1xvOES", "GL_OES_fixed_point" },
+    { "glTexCoord2bOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord2bvOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord2fColor3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fColor3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fColor4fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fColor4fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fColor4ubVertex3fSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fColor4ubVertex3fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fNormal3fVertex3fSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fNormal3fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fVertex3fSUN", "GL_SUN_vertex" },
+    { "glTexCoord2fVertex3fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord2hNV", "GL_NV_half_float" },
+    { "glTexCoord2hvNV", "GL_NV_half_float" },
+    { "glTexCoord2xOES", "GL_OES_fixed_point" },
+    { "glTexCoord2xvOES", "GL_OES_fixed_point" },
+    { "glTexCoord3bOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord3bvOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord3hNV", "GL_NV_half_float" },
+    { "glTexCoord3hvNV", "GL_NV_half_float" },
+    { "glTexCoord3xOES", "GL_OES_fixed_point" },
+    { "glTexCoord3xvOES", "GL_OES_fixed_point" },
+    { "glTexCoord4bOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord4bvOES", "GL_OES_byte_coordinates" },
+    { "glTexCoord4fColor4fNormal3fVertex4fSUN", "GL_SUN_vertex" },
+    { "glTexCoord4fColor4fNormal3fVertex4fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord4fVertex4fSUN", "GL_SUN_vertex" },
+    { "glTexCoord4fVertex4fvSUN", "GL_SUN_vertex" },
+    { "glTexCoord4hNV", "GL_NV_half_float" },
+    { "glTexCoord4hvNV", "GL_NV_half_float" },
+    { "glTexCoord4xOES", "GL_OES_fixed_point" },
+    { "glTexCoord4xvOES", "GL_OES_fixed_point" },
+    { "glTexCoordFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glTexCoordP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glTexCoordPointerEXT", "GL_EXT_vertex_array" },
+    { "glTexCoordPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glTexCoordPointervINTEL", "GL_INTEL_parallel_arrays" },
+    { "glTexEnvxOES", "GL_OES_fixed_point" },
+    { "glTexEnvxvOES", "GL_OES_fixed_point" },
+    { "glTexFilterFuncSGIS", "GL_SGIS_texture_filter4" },
+    { "glTexGenxOES", "GL_OES_fixed_point" },
+    { "glTexGenxvOES", "GL_OES_fixed_point" },
+    { "glTexImage2DMultisample", "GL_ARB_texture_multisample GL_VERSION_3_2" },
+    { "glTexImage2DMultisampleCoverageNV", "GL_NV_texture_multisample" },
+    { "glTexImage3D", "GL_VERSION_1_2" },
+    { "glTexImage3DEXT", "GL_EXT_texture3D" },
+    { "glTexImage3DMultisample", "GL_ARB_texture_multisample GL_VERSION_3_2" },
+    { "glTexImage3DMultisampleCoverageNV", "GL_NV_texture_multisample" },
+    { "glTexImage4DSGIS", "GL_SGIS_texture4D" },
+    { "glTexPageCommitmentARB", "GL_ARB_sparse_texture" },
+    { "glTexParameterIiv", "GL_VERSION_3_0" },
+    { "glTexParameterIivEXT", "GL_EXT_texture_integer" },
+    { "glTexParameterIuiv", "GL_VERSION_3_0" },
+    { "glTexParameterIuivEXT", "GL_EXT_texture_integer" },
+    { "glTexParameterxOES", "GL_OES_fixed_point" },
+    { "glTexParameterxvOES", "GL_OES_fixed_point" },
+    { "glTexRenderbufferNV", "GL_NV_explicit_multisample" },
+    { "glTexStorage1D", "GL_ARB_texture_storage GL_VERSION_4_2" },
+    { "glTexStorage2D", "GL_ARB_texture_storage GL_VERSION_4_2" },
+    { "glTexStorage2DMultisample", "GL_ARB_texture_storage_multisample GL_VERSION_4_3" },
+    { "glTexStorage3D", "GL_ARB_texture_storage GL_VERSION_4_2" },
+    { "glTexStorage3DMultisample", "GL_ARB_texture_storage_multisample GL_VERSION_4_3" },
+    { "glTexStorageMem1DEXT", "GL_EXT_memory_object" },
+    { "glTexStorageMem2DEXT", "GL_EXT_memory_object" },
+    { "glTexStorageMem2DMultisampleEXT", "GL_EXT_memory_object" },
+    { "glTexStorageMem3DEXT", "GL_EXT_memory_object" },
+    { "glTexStorageMem3DMultisampleEXT", "GL_EXT_memory_object" },
+    { "glTexStorageSparseAMD", "GL_AMD_sparse_texture" },
+    { "glTexSubImage1DEXT", "GL_EXT_subtexture" },
+    { "glTexSubImage2DEXT", "GL_EXT_subtexture" },
+    { "glTexSubImage3D", "GL_VERSION_1_2" },
+    { "glTexSubImage3DEXT", "GL_EXT_texture3D" },
+    { "glTexSubImage4DSGIS", "GL_SGIS_texture4D" },
+    { "glTextureAttachMemoryNV", "GL_NV_memory_attachment" },
+    { "glTextureBarrier", "GL_ARB_texture_barrier GL_VERSION_4_5" },
+    { "glTextureBarrierNV", "GL_NV_texture_barrier" },
+    { "glTextureBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureBufferEXT", "GL_EXT_direct_state_access" },
+    { "glTextureBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureBufferRangeEXT", "GL_EXT_direct_state_access" },
+    { "glTextureColorMaskSGIS", "GL_SGIS_texture_color_mask" },
+    { "glTextureImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureImage2DMultisampleCoverageNV", "GL_NV_texture_multisample" },
+    { "glTextureImage2DMultisampleNV", "GL_NV_texture_multisample" },
+    { "glTextureImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureImage3DMultisampleCoverageNV", "GL_NV_texture_multisample" },
+    { "glTextureImage3DMultisampleNV", "GL_NV_texture_multisample" },
+    { "glTextureLightEXT", "GL_EXT_light_texture" },
+    { "glTextureMaterialEXT", "GL_EXT_light_texture" },
+    { "glTextureNormalEXT", "GL_EXT_texture_perturb_normal" },
+    { "glTexturePageCommitmentEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameterIiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameterIivEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameterIuiv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameterIuivEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameterf", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameterfEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameterfv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameterfvEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameteri", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameteriEXT", "GL_EXT_direct_state_access" },
+    { "glTextureParameteriv", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureParameterivEXT", "GL_EXT_direct_state_access" },
+    { "glTextureRangeAPPLE", "GL_APPLE_texture_range" },
+    { "glTextureRenderbufferEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorage1D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureStorage1DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorage2D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureStorage2DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorage2DMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureStorage2DMultisampleEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorage3D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureStorage3DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorage3DMultisample", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureStorage3DMultisampleEXT", "GL_EXT_direct_state_access" },
+    { "glTextureStorageMem1DEXT", "GL_EXT_memory_object" },
+    { "glTextureStorageMem2DEXT", "GL_EXT_memory_object" },
+    { "glTextureStorageMem2DMultisampleEXT", "GL_EXT_memory_object" },
+    { "glTextureStorageMem3DEXT", "GL_EXT_memory_object" },
+    { "glTextureStorageMem3DMultisampleEXT", "GL_EXT_memory_object" },
+    { "glTextureStorageSparseAMD", "GL_AMD_sparse_texture" },
+    { "glTextureSubImage1D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureSubImage1DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureSubImage2D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureSubImage2DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureSubImage3D", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTextureSubImage3DEXT", "GL_EXT_direct_state_access" },
+    { "glTextureView", "GL_ARB_texture_view GL_VERSION_4_3" },
+    { "glTrackMatrixNV", "GL_NV_vertex_program" },
+    { "glTransformFeedbackAttribsNV", "GL_NV_transform_feedback" },
+    { "glTransformFeedbackBufferBase", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTransformFeedbackBufferRange", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glTransformFeedbackStreamAttribsNV", "GL_NV_transform_feedback" },
+    { "glTransformFeedbackVaryings", "GL_VERSION_3_0" },
+    { "glTransformFeedbackVaryingsEXT", "GL_EXT_transform_feedback" },
+    { "glTransformFeedbackVaryingsNV", "GL_NV_transform_feedback" },
+    { "glTransformPathNV", "GL_NV_path_rendering" },
+    { "glTranslatexOES", "GL_OES_fixed_point" },
+    { "glUniform1d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform1dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform1f", "GL_VERSION_2_0" },
+    { "glUniform1fARB", "GL_ARB_shader_objects" },
+    { "glUniform1fv", "GL_VERSION_2_0" },
+    { "glUniform1fvARB", "GL_ARB_shader_objects" },
+    { "glUniform1i", "GL_VERSION_2_0" },
+    { "glUniform1i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform1i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform1i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform1i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform1iARB", "GL_ARB_shader_objects" },
+    { "glUniform1iv", "GL_VERSION_2_0" },
+    { "glUniform1ivARB", "GL_ARB_shader_objects" },
+    { "glUniform1ui", "GL_VERSION_3_0" },
+    { "glUniform1ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform1ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform1ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform1ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform1uiEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform1uiv", "GL_VERSION_3_0" },
+    { "glUniform1uivEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform2d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform2f", "GL_VERSION_2_0" },
+    { "glUniform2fARB", "GL_ARB_shader_objects" },
+    { "glUniform2fv", "GL_VERSION_2_0" },
+    { "glUniform2fvARB", "GL_ARB_shader_objects" },
+    { "glUniform2i", "GL_VERSION_2_0" },
+    { "glUniform2i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform2i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform2i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform2i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform2iARB", "GL_ARB_shader_objects" },
+    { "glUniform2iv", "GL_VERSION_2_0" },
+    { "glUniform2ivARB", "GL_ARB_shader_objects" },
+    { "glUniform2ui", "GL_VERSION_3_0" },
+    { "glUniform2ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform2ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform2ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform2ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform2uiEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform2uiv", "GL_VERSION_3_0" },
+    { "glUniform2uivEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform3d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform3f", "GL_VERSION_2_0" },
+    { "glUniform3fARB", "GL_ARB_shader_objects" },
+    { "glUniform3fv", "GL_VERSION_2_0" },
+    { "glUniform3fvARB", "GL_ARB_shader_objects" },
+    { "glUniform3i", "GL_VERSION_2_0" },
+    { "glUniform3i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform3i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform3i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform3i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform3iARB", "GL_ARB_shader_objects" },
+    { "glUniform3iv", "GL_VERSION_2_0" },
+    { "glUniform3ivARB", "GL_ARB_shader_objects" },
+    { "glUniform3ui", "GL_VERSION_3_0" },
+    { "glUniform3ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform3ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform3ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform3ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform3uiEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform3uiv", "GL_VERSION_3_0" },
+    { "glUniform3uivEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform4d", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniform4f", "GL_VERSION_2_0" },
+    { "glUniform4fARB", "GL_ARB_shader_objects" },
+    { "glUniform4fv", "GL_VERSION_2_0" },
+    { "glUniform4fvARB", "GL_ARB_shader_objects" },
+    { "glUniform4i", "GL_VERSION_2_0" },
+    { "glUniform4i64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform4i64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform4i64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform4i64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform4iARB", "GL_ARB_shader_objects" },
+    { "glUniform4iv", "GL_VERSION_2_0" },
+    { "glUniform4ivARB", "GL_ARB_shader_objects" },
+    { "glUniform4ui", "GL_VERSION_3_0" },
+    { "glUniform4ui64ARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform4ui64NV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform4ui64vARB", "GL_ARB_gpu_shader_int64" },
+    { "glUniform4ui64vNV", "GL_AMD_gpu_shader_int64 GL_NV_gpu_shader5" },
+    { "glUniform4uiEXT", "GL_EXT_gpu_shader4" },
+    { "glUniform4uiv", "GL_VERSION_3_0" },
+    { "glUniform4uivEXT", "GL_EXT_gpu_shader4" },
+    { "glUniformBlockBinding", "GL_ARB_uniform_buffer_object GL_VERSION_3_1" },
+    { "glUniformBufferEXT", "GL_EXT_bindable_uniform" },
+    { "glUniformHandleui64ARB", "GL_ARB_bindless_texture" },
+    { "glUniformHandleui64NV", "GL_NV_bindless_texture" },
+    { "glUniformHandleui64vARB", "GL_ARB_bindless_texture" },
+    { "glUniformHandleui64vNV", "GL_NV_bindless_texture" },
+    { "glUniformMatrix2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix2fv", "GL_VERSION_2_0" },
+    { "glUniformMatrix2fvARB", "GL_ARB_shader_objects" },
+    { "glUniformMatrix2x3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix2x3fv", "GL_VERSION_2_1" },
+    { "glUniformMatrix2x4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix2x4fv", "GL_VERSION_2_1" },
+    { "glUniformMatrix3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix3fv", "GL_VERSION_2_0" },
+    { "glUniformMatrix3fvARB", "GL_ARB_shader_objects" },
+    { "glUniformMatrix3x2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix3x2fv", "GL_VERSION_2_1" },
+    { "glUniformMatrix3x4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix3x4fv", "GL_VERSION_2_1" },
+    { "glUniformMatrix4dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix4fv", "GL_VERSION_2_0" },
+    { "glUniformMatrix4fvARB", "GL_ARB_shader_objects" },
+    { "glUniformMatrix4x2dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix4x2fv", "GL_VERSION_2_1" },
+    { "glUniformMatrix4x3dv", "GL_ARB_gpu_shader_fp64 GL_VERSION_4_0" },
+    { "glUniformMatrix4x3fv", "GL_VERSION_2_1" },
+    { "glUniformSubroutinesuiv", "GL_ARB_shader_subroutine GL_VERSION_4_0" },
+    { "glUniformui64NV", "GL_NV_shader_buffer_load" },
+    { "glUniformui64vNV", "GL_NV_shader_buffer_load" },
+    { "glUnlockArraysEXT", "GL_EXT_compiled_vertex_array" },
+    { "glUnmapBuffer", "GL_VERSION_1_5" },
+    { "glUnmapBufferARB", "GL_ARB_vertex_buffer_object" },
+    { "glUnmapNamedBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glUnmapNamedBufferEXT", "GL_EXT_direct_state_access" },
+    { "glUnmapObjectBufferATI", "GL_ATI_map_object_buffer" },
+    { "glUnmapTexture2DINTEL", "GL_INTEL_map_texture" },
+    { "glUpdateObjectBufferATI", "GL_ATI_vertex_array_object" },
+    { "glUploadGpuMaskNVX", "GL_NVX_gpu_multicast2" },
+    { "glUseProgram", "GL_VERSION_2_0" },
+    { "glUseProgramObjectARB", "GL_ARB_shader_objects" },
+    { "glUseProgramStages", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glUseShaderProgramEXT", "GL_EXT_separate_shader_objects" },
+    { "glVDPAUFiniNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUGetSurfaceivNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUInitNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUIsSurfaceNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUMapSurfacesNV", "GL_NV_vdpau_interop" },
+    { "glVDPAURegisterOutputSurfaceNV", "GL_NV_vdpau_interop" },
+    { "glVDPAURegisterVideoSurfaceNV", "GL_NV_vdpau_interop" },
+    { "glVDPAURegisterVideoSurfaceWithPictureStructureNV", "GL_NV_vdpau_interop2" },
+    { "glVDPAUSurfaceAccessNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUUnmapSurfacesNV", "GL_NV_vdpau_interop" },
+    { "glVDPAUUnregisterSurfaceNV", "GL_NV_vdpau_interop" },
+    { "glValidateProgram", "GL_VERSION_2_0" },
+    { "glValidateProgramARB", "GL_ARB_shader_objects" },
+    { "glValidateProgramPipeline", "GL_ARB_separate_shader_objects GL_VERSION_4_1" },
+    { "glVariantArrayObjectATI", "GL_ATI_vertex_array_object" },
+    { "glVariantPointerEXT", "GL_EXT_vertex_shader" },
+    { "glVariantbvEXT", "GL_EXT_vertex_shader" },
+    { "glVariantdvEXT", "GL_EXT_vertex_shader" },
+    { "glVariantfvEXT", "GL_EXT_vertex_shader" },
+    { "glVariantivEXT", "GL_EXT_vertex_shader" },
+    { "glVariantsvEXT", "GL_EXT_vertex_shader" },
+    { "glVariantubvEXT", "GL_EXT_vertex_shader" },
+    { "glVariantuivEXT", "GL_EXT_vertex_shader" },
+    { "glVariantusvEXT", "GL_EXT_vertex_shader" },
+    { "glVertex2bOES", "GL_OES_byte_coordinates" },
+    { "glVertex2bvOES", "GL_OES_byte_coordinates" },
+    { "glVertex2hNV", "GL_NV_half_float" },
+    { "glVertex2hvNV", "GL_NV_half_float" },
+    { "glVertex2xOES", "GL_OES_fixed_point" },
+    { "glVertex2xvOES", "GL_OES_fixed_point" },
+    { "glVertex3bOES", "GL_OES_byte_coordinates" },
+    { "glVertex3bvOES", "GL_OES_byte_coordinates" },
+    { "glVertex3hNV", "GL_NV_half_float" },
+    { "glVertex3hvNV", "GL_NV_half_float" },
+    { "glVertex3xOES", "GL_OES_fixed_point" },
+    { "glVertex3xvOES", "GL_OES_fixed_point" },
+    { "glVertex4bOES", "GL_OES_byte_coordinates" },
+    { "glVertex4bvOES", "GL_OES_byte_coordinates" },
+    { "glVertex4hNV", "GL_NV_half_float" },
+    { "glVertex4hvNV", "GL_NV_half_float" },
+    { "glVertex4xOES", "GL_OES_fixed_point" },
+    { "glVertex4xvOES", "GL_OES_fixed_point" },
+    { "glVertexArrayAttribBinding", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayAttribFormat", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayAttribIFormat", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayAttribLFormat", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayBindVertexBufferEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayBindingDivisor", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayColorOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayEdgeFlagOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayElementBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayFogCoordOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayIndexOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayMultiTexCoordOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayNormalOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayParameteriAPPLE", "GL_APPLE_vertex_array_range" },
+    { "glVertexArrayRangeAPPLE", "GL_APPLE_vertex_array_range" },
+    { "glVertexArrayRangeNV", "GL_NV_vertex_array_range" },
+    { "glVertexArraySecondaryColorOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayTexCoordOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribBindingEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribDivisorEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribFormatEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribIFormatEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribIOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribLFormatEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribLOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexAttribOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexBindingDivisorEXT", "GL_EXT_direct_state_access" },
+    { "glVertexArrayVertexBuffer", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayVertexBuffers", "GL_ARB_direct_state_access GL_VERSION_4_5" },
+    { "glVertexArrayVertexOffsetEXT", "GL_EXT_direct_state_access" },
+    { "glVertexAttrib1d", "GL_VERSION_2_0" },
+    { "glVertexAttrib1dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1dNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib1dv", "GL_VERSION_2_0" },
+    { "glVertexAttrib1dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib1f", "GL_VERSION_2_0" },
+    { "glVertexAttrib1fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1fNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib1fv", "GL_VERSION_2_0" },
+    { "glVertexAttrib1fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib1hNV", "GL_NV_half_float" },
+    { "glVertexAttrib1hvNV", "GL_NV_half_float" },
+    { "glVertexAttrib1s", "GL_VERSION_2_0" },
+    { "glVertexAttrib1sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1sNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib1sv", "GL_VERSION_2_0" },
+    { "glVertexAttrib1svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib1svNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2d", "GL_VERSION_2_0" },
+    { "glVertexAttrib2dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2dNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2dv", "GL_VERSION_2_0" },
+    { "glVertexAttrib2dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2f", "GL_VERSION_2_0" },
+    { "glVertexAttrib2fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2fNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2fv", "GL_VERSION_2_0" },
+    { "glVertexAttrib2fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2hNV", "GL_NV_half_float" },
+    { "glVertexAttrib2hvNV", "GL_NV_half_float" },
+    { "glVertexAttrib2s", "GL_VERSION_2_0" },
+    { "glVertexAttrib2sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2sNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib2sv", "GL_VERSION_2_0" },
+    { "glVertexAttrib2svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib2svNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3d", "GL_VERSION_2_0" },
+    { "glVertexAttrib3dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3dNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3dv", "GL_VERSION_2_0" },
+    { "glVertexAttrib3dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3f", "GL_VERSION_2_0" },
+    { "glVertexAttrib3fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3fNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3fv", "GL_VERSION_2_0" },
+    { "glVertexAttrib3fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3hNV", "GL_NV_half_float" },
+    { "glVertexAttrib3hvNV", "GL_NV_half_float" },
+    { "glVertexAttrib3s", "GL_VERSION_2_0" },
+    { "glVertexAttrib3sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3sNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib3sv", "GL_VERSION_2_0" },
+    { "glVertexAttrib3svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib3svNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4Nbv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NbvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Niv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Nsv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NsvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Nub", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NubARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Nubv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NubvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Nuiv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NuivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4Nusv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4NusvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4bv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4bvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4d", "GL_VERSION_2_0" },
+    { "glVertexAttrib4dARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4dNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4dv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4dvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4f", "GL_VERSION_2_0" },
+    { "glVertexAttrib4fARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4fNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4fv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4fvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4hNV", "GL_NV_half_float" },
+    { "glVertexAttrib4hvNV", "GL_NV_half_float" },
+    { "glVertexAttrib4iv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4ivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4s", "GL_VERSION_2_0" },
+    { "glVertexAttrib4sARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4sNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4sv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4svARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4svNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4ubNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4ubv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4ubvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4ubvNV", "GL_NV_vertex_program" },
+    { "glVertexAttrib4uiv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4uivARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttrib4usv", "GL_VERSION_2_0" },
+    { "glVertexAttrib4usvARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttribArrayObjectATI", "GL_ATI_vertex_attrib_array_object" },
+    { "glVertexAttribBinding", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glVertexAttribDivisor", "GL_VERSION_3_3" },
+    { "glVertexAttribDivisorARB", "GL_ARB_instanced_arrays" },
+    { "glVertexAttribFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glVertexAttribFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glVertexAttribI1i", "GL_VERSION_3_0" },
+    { "glVertexAttribI1iEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI1iv", "GL_VERSION_3_0" },
+    { "glVertexAttribI1ivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI1ui", "GL_VERSION_3_0" },
+    { "glVertexAttribI1uiEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI1uiv", "GL_VERSION_3_0" },
+    { "glVertexAttribI1uivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI2i", "GL_VERSION_3_0" },
+    { "glVertexAttribI2iEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI2iv", "GL_VERSION_3_0" },
+    { "glVertexAttribI2ivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI2ui", "GL_VERSION_3_0" },
+    { "glVertexAttribI2uiEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI2uiv", "GL_VERSION_3_0" },
+    { "glVertexAttribI2uivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI3i", "GL_VERSION_3_0" },
+    { "glVertexAttribI3iEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI3iv", "GL_VERSION_3_0" },
+    { "glVertexAttribI3ivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI3ui", "GL_VERSION_3_0" },
+    { "glVertexAttribI3uiEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI3uiv", "GL_VERSION_3_0" },
+    { "glVertexAttribI3uivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4bv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4bvEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4i", "GL_VERSION_3_0" },
+    { "glVertexAttribI4iEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4iv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4ivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4sv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4svEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4ubv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4ubvEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4ui", "GL_VERSION_3_0" },
+    { "glVertexAttribI4uiEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4uiv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4uivEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribI4usv", "GL_VERSION_3_0" },
+    { "glVertexAttribI4usvEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribIFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glVertexAttribIFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glVertexAttribIPointer", "GL_VERSION_3_0" },
+    { "glVertexAttribIPointerEXT", "GL_NV_vertex_program4" },
+    { "glVertexAttribL1d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL1dEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL1dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL1dvEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL1i64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL1i64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL1ui64ARB", "GL_ARB_bindless_texture" },
+    { "glVertexAttribL1ui64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL1ui64vARB", "GL_ARB_bindless_texture" },
+    { "glVertexAttribL1ui64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL2d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL2dEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL2dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL2dvEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL2i64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL2i64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL2ui64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL2ui64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL3d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL3dEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL3dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL3dvEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL3i64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL3i64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL3ui64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL3ui64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL4d", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL4dEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL4dv", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribL4dvEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribL4i64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL4i64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL4ui64NV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribL4ui64vNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribLFormat", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glVertexAttribLFormatNV", "GL_NV_vertex_attrib_integer_64bit" },
+    { "glVertexAttribLPointer", "GL_ARB_vertex_attrib_64bit GL_VERSION_4_1" },
+    { "glVertexAttribLPointerEXT", "GL_EXT_vertex_attrib_64bit" },
+    { "glVertexAttribP1ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP1uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexAttribParameteriAMD", "GL_AMD_interleaved_elements" },
+    { "glVertexAttribPointer", "GL_VERSION_2_0" },
+    { "glVertexAttribPointerARB", "GL_ARB_vertex_program GL_ARB_vertex_shader" },
+    { "glVertexAttribPointerNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs1dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs1fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs1hvNV", "GL_NV_half_float" },
+    { "glVertexAttribs1svNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs2dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs2fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs2hvNV", "GL_NV_half_float" },
+    { "glVertexAttribs2svNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs3dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs3fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs3hvNV", "GL_NV_half_float" },
+    { "glVertexAttribs3svNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs4dvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs4fvNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs4hvNV", "GL_NV_half_float" },
+    { "glVertexAttribs4svNV", "GL_NV_vertex_program" },
+    { "glVertexAttribs4ubvNV", "GL_NV_vertex_program" },
+    { "glVertexBindingDivisor", "GL_ARB_vertex_attrib_binding GL_VERSION_4_3" },
+    { "glVertexBlendARB", "GL_ARB_vertex_blend" },
+    { "glVertexBlendEnvfATI", "GL_ATI_vertex_streams" },
+    { "glVertexBlendEnviATI", "GL_ATI_vertex_streams" },
+    { "glVertexFormatNV", "GL_NV_vertex_buffer_unified_memory" },
+    { "glVertexP2ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexP2uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexP3ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexP3uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexP4ui", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexP4uiv", "GL_ARB_vertex_type_2_10_10_10_rev GL_VERSION_3_3" },
+    { "glVertexPointerEXT", "GL_EXT_vertex_array" },
+    { "glVertexPointerListIBM", "GL_IBM_vertex_array_lists" },
+    { "glVertexPointervINTEL", "GL_INTEL_parallel_arrays" },
+    { "glVertexStream1dATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1dvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1fATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1fvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1iATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1ivATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1sATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream1svATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2dATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2dvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2fATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2fvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2iATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2ivATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2sATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream2svATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3dATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3dvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3fATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3fvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3iATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3ivATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3sATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream3svATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4dATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4dvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4fATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4fvATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4iATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4ivATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4sATI", "GL_ATI_vertex_streams" },
+    { "glVertexStream4svATI", "GL_ATI_vertex_streams" },
+    { "glVertexWeightPointerEXT", "GL_EXT_vertex_weighting" },
+    { "glVertexWeightfEXT", "GL_EXT_vertex_weighting" },
+    { "glVertexWeightfvEXT", "GL_EXT_vertex_weighting" },
+    { "glVertexWeighthNV", "GL_NV_half_float" },
+    { "glVertexWeighthvNV", "GL_NV_half_float" },
+    { "glVideoCaptureNV", "GL_NV_video_capture" },
+    { "glVideoCaptureStreamParameterdvNV", "GL_NV_video_capture" },
+    { "glVideoCaptureStreamParameterfvNV", "GL_NV_video_capture" },
+    { "glVideoCaptureStreamParameterivNV", "GL_NV_video_capture" },
+    { "glViewportArrayv", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glViewportIndexedf", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glViewportIndexedfv", "GL_ARB_viewport_array GL_VERSION_4_1" },
+    { "glViewportPositionWScaleNV", "GL_NV_clip_space_w_scaling" },
+    { "glViewportSwizzleNV", "GL_NV_viewport_swizzle" },
+    { "glWaitSemaphoreEXT", "GL_EXT_semaphore" },
+    { "glWaitSemaphoreui64NVX", "GL_NVX_progress_fence" },
+    { "glWaitSync", "GL_ARB_sync GL_VERSION_3_2" },
+    { "glWaitVkSemaphoreNV", "GL_NV_draw_vulkan_image" },
+    { "glWeightPathsNV", "GL_NV_path_rendering" },
+    { "glWeightPointerARB", "GL_ARB_vertex_blend" },
+    { "glWeightbvARB", "GL_ARB_vertex_blend" },
+    { "glWeightdvARB", "GL_ARB_vertex_blend" },
+    { "glWeightfvARB", "GL_ARB_vertex_blend" },
+    { "glWeightivARB", "GL_ARB_vertex_blend" },
+    { "glWeightsvARB", "GL_ARB_vertex_blend" },
+    { "glWeightubvARB", "GL_ARB_vertex_blend" },
+    { "glWeightuivARB", "GL_ARB_vertex_blend" },
+    { "glWeightusvARB", "GL_ARB_vertex_blend" },
+    { "glWindowPos2d", "GL_VERSION_1_4" },
+    { "glWindowPos2dARB", "GL_ARB_window_pos" },
+    { "glWindowPos2dMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2dv", "GL_VERSION_1_4" },
+    { "glWindowPos2dvARB", "GL_ARB_window_pos" },
+    { "glWindowPos2dvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2f", "GL_VERSION_1_4" },
+    { "glWindowPos2fARB", "GL_ARB_window_pos" },
+    { "glWindowPos2fMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2fv", "GL_VERSION_1_4" },
+    { "glWindowPos2fvARB", "GL_ARB_window_pos" },
+    { "glWindowPos2fvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2i", "GL_VERSION_1_4" },
+    { "glWindowPos2iARB", "GL_ARB_window_pos" },
+    { "glWindowPos2iMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2iv", "GL_VERSION_1_4" },
+    { "glWindowPos2ivARB", "GL_ARB_window_pos" },
+    { "glWindowPos2ivMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2s", "GL_VERSION_1_4" },
+    { "glWindowPos2sARB", "GL_ARB_window_pos" },
+    { "glWindowPos2sMESA", "GL_MESA_window_pos" },
+    { "glWindowPos2sv", "GL_VERSION_1_4" },
+    { "glWindowPos2svARB", "GL_ARB_window_pos" },
+    { "glWindowPos2svMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3d", "GL_VERSION_1_4" },
+    { "glWindowPos3dARB", "GL_ARB_window_pos" },
+    { "glWindowPos3dMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3dv", "GL_VERSION_1_4" },
+    { "glWindowPos3dvARB", "GL_ARB_window_pos" },
+    { "glWindowPos3dvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3f", "GL_VERSION_1_4" },
+    { "glWindowPos3fARB", "GL_ARB_window_pos" },
+    { "glWindowPos3fMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3fv", "GL_VERSION_1_4" },
+    { "glWindowPos3fvARB", "GL_ARB_window_pos" },
+    { "glWindowPos3fvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3i", "GL_VERSION_1_4" },
+    { "glWindowPos3iARB", "GL_ARB_window_pos" },
+    { "glWindowPos3iMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3iv", "GL_VERSION_1_4" },
+    { "glWindowPos3ivARB", "GL_ARB_window_pos" },
+    { "glWindowPos3ivMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3s", "GL_VERSION_1_4" },
+    { "glWindowPos3sARB", "GL_ARB_window_pos" },
+    { "glWindowPos3sMESA", "GL_MESA_window_pos" },
+    { "glWindowPos3sv", "GL_VERSION_1_4" },
+    { "glWindowPos3svARB", "GL_ARB_window_pos" },
+    { "glWindowPos3svMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4dMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4dvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4fMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4fvMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4iMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4ivMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4sMESA", "GL_MESA_window_pos" },
+    { "glWindowPos4svMESA", "GL_MESA_window_pos" },
+    { "glWindowRectanglesEXT", "GL_EXT_window_rectangles" },
+    { "glWriteMaskEXT", "GL_EXT_vertex_shader" },
+    { "wglAllocateMemoryNV", "WGL_NV_vertex_array_range" },
+    { "wglBindTexImageARB", "WGL_ARB_render_texture" },
+    { "wglChoosePixelFormatARB", "WGL_ARB_pixel_format" },
+    { "wglCreateContextAttribsARB", "WGL_ARB_create_context" },
+    { "wglCreatePbufferARB", "WGL_ARB_pbuffer" },
+    { "wglDestroyPbufferARB", "WGL_ARB_pbuffer" },
+    { "wglFreeMemoryNV", "WGL_NV_vertex_array_range" },
+    { "wglGetCurrentReadDCARB", "WGL_ARB_make_current_read" },
+    { "wglGetExtensionsStringARB", "WGL_ARB_extensions_string" },
+    { "wglGetExtensionsStringEXT", "WGL_EXT_extensions_string" },
+    { "wglGetPbufferDCARB", "WGL_ARB_pbuffer" },
+    { "wglGetPixelFormatAttribfvARB", "WGL_ARB_pixel_format" },
+    { "wglGetPixelFormatAttribivARB", "WGL_ARB_pixel_format" },
+    { "wglGetSwapIntervalEXT", "WGL_EXT_swap_control" },
+    { "wglMakeContextCurrentARB", "WGL_ARB_make_current_read" },
+    { "wglQueryCurrentRendererIntegerWINE", "WGL_WINE_query_renderer" },
+    { "wglQueryCurrentRendererStringWINE", "WGL_WINE_query_renderer" },
+    { "wglQueryPbufferARB", "WGL_ARB_pbuffer" },
+    { "wglQueryRendererIntegerWINE", "WGL_WINE_query_renderer" },
+    { "wglQueryRendererStringWINE", "WGL_WINE_query_renderer" },
+    { "wglReleasePbufferDCARB", "WGL_ARB_pbuffer" },
+    { "wglReleaseTexImageARB", "WGL_ARB_render_texture" },
+    { "wglSetPbufferAttribARB", "WGL_ARB_render_texture" },
+    { "wglSetPixelFormatWINE", "WGL_WINE_pixel_format_passthrough" },
+    { "wglSwapIntervalEXT", "WGL_EXT_swap_control" },
+};
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index a39bbcdd000..f5a4b034196 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -334,9 +334,10 @@ int WINAPI wglGetLayerPaletteEntries(HDC hdc,
   return 0;
 }

-static int compar(const void *elt_a, const void *elt_b) {
-  return strcmp(((const OpenGL_extension *) elt_a)->name,
-		((const OpenGL_extension *) elt_b)->name);
+static int registry_entry_cmp( const void *a, const void *b )
+{
+    const struct registry_entry *entry_a = a, *entry_b = b;
+    return strcmp( entry_a->name, entry_b->name );
 }

static char *heap_strdup( const char *str )
@@ -369,10 +370,9 @@ static BOOL is_extension_supported( const char *extension )
  */
 PROC WINAPI wglGetProcAddress( LPCSTR name )
 {
+    const struct registry_entry entry = {.name = name}, *found;
     struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    void **func_ptr;
-    OpenGL_extension  ext;
-    const OpenGL_extension *ext_ret;
+    const void **func_ptr, *proc;

if (!name) return NULL;

@@ -385,20 +385,19 @@ PROC WINAPI wglGetProcAddress( LPCSTR name )
         return NULL;
     }

-    ext.name = name;
-    ext_ret = bsearch(&ext, extension_registry, extension_registry_size, sizeof(ext), compar);
-    if (!ext_ret)
+    if (!(found = bsearch( &entry, extension_registry, extension_registry_size,
+                           sizeof(entry), registry_entry_cmp )))
     {
         WARN("Function %s unknown\n", name);
         return NULL;
     }

-    func_ptr = (void **)&funcs->ext + (ext_ret - extension_registry);
+    func_ptr = (const void **)&funcs->ext + (found - extension_registry);
     if (!*func_ptr)
     {
         void *driver_func = funcs->wgl.p_wglGetProcAddress( name );

-        if (!is_extension_supported(ext_ret->extension))
+        if (!is_extension_supported(found->extension))
         {
             unsigned int i;
             static const struct { const char *name, *alt; } alternatives[] =
@@ -410,11 +409,11 @@ PROC WINAPI wglGetProcAddress( LPCSTR name )
             for (i = 0; i < ARRAY_SIZE(alternatives); i++)
             {
                 if (strcmp( name, alternatives[i].name )) continue;
-                WARN("Extension %s required for %s not supported, trying %s\n",
-                    ext_ret->extension, name, alternatives[i].alt );
+                WARN( "Extension %s required for %s not supported, trying %s\n", found->extension,
+                      name, alternatives[i].alt );
                 return wglGetProcAddress( alternatives[i].alt );
             }
-            WARN("Extension %s required for %s not supported\n", ext_ret->extension, name);
+            WARN( "Extension %s required for %s not supported\n", found->extension, name );
             return NULL;
         }

@@ -426,8 +425,9 @@ PROC WINAPI wglGetProcAddress( LPCSTR name )
         *func_ptr = driver_func;
     }

-    TRACE("returning %s -> %p\n", name, ext_ret->func);
-    return ext_ret->func;
+    proc = extension_procs[found - extension_registry];
+    TRACE( "returning %s -> %p\n", name, proc );
+    return proc;
 }

/***********************************************************************

[PATCH v2 7/7] opengl32: Move wglGetProcAddress extension filtering to unix_wgl.c.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/opengl32/make_opengl   |   2 +-
 dlls/opengl32/opengl_ext.h  |   9 ---
 dlls/opengl32/unix_thunks.c |   9 +--
 dlls/opengl32/unix_wgl.c    | 107 +++++++++++++++++++++++++++++++++++-
 dlls/opengl32/wgl.c         |  90 ++----------------------------
 5 files changed, 113 insertions(+), 104 deletions(-)

diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 1ebd6e01bb8..16f582a6f2a 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -508,7 +508,7 @@ sub needs_wrapper($$)
 {
     my ($name, $func) = @_;

-    return 1 if $name =~ /^glDebugMessageCallback|^glGetString|^glGetIntegerv/;
+    return 1 if $name =~ /^glDebugMessageCallback|^glGetString|^glGetIntegerv|^wglGetProcAddress/;

# check if return value needs special handling
     (my $type = $func->[0]->textContent()) =~ s/ $//;
diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h
index 7b19e302e82..c668e92fd9b 100644
--- a/dlls/opengl32/opengl_ext.h
+++ b/dlls/opengl32/opengl_ext.h
@@ -94,15 +94,6 @@ static inline struct wgl_handle *get_current_context_ptr(void)
     return &wgl_handles[LOWORD(NtCurrentTeb()->glCurrentRC) & ~HANDLE_TYPE_MASK];
 }

-static inline enum wgl_handle_type get_current_context_type(void)
-{
-    if (!NtCurrentTeb()->glCurrentRC) return HANDLE_CONTEXT;
-    return LOWORD(NtCurrentTeb()->glCurrentRC) & HANDLE_TYPE_MASK;
-}
-
 extern int WINAPI wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd );

-extern BOOL check_extension_support( const char *extension, const char *available_extensions ) DECLSPEC_HIDDEN;
-extern char *build_extension_list(void) DECLSPEC_HIDDEN;
-
 #endif /* __DLLS_OPENGL32_OPENGL_EXT_H */
diff --git a/dlls/opengl32/unix_thunks.c b/dlls/opengl32/unix_thunks.c
index 3306a446c7f..515a765f0a7 100644
--- a/dlls/opengl32/unix_thunks.c
+++ b/dlls/opengl32/unix_thunks.c
@@ -16,6 +16,7 @@
 extern NTSTATUS wgl_wglCopyContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglCreateContext( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglDeleteContext( void *args ) DECLSPEC_HIDDEN;
+extern NTSTATUS wgl_wglGetProcAddress( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglMakeCurrent( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS wgl_wglShareLists( void *args ) DECLSPEC_HIDDEN;
 extern NTSTATUS gl_glGetIntegerv( void *args ) DECLSPEC_HIDDEN;
@@ -53,14 +54,6 @@ static NTSTATUS wgl_wglGetPixelFormat( void *args )
     return STATUS_SUCCESS;
 }

-static NTSTATUS wgl_wglGetProcAddress( void *args )
-{
-    struct wglGetProcAddress_params *params = args;
-    const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    params->ret = funcs->wgl.p_wglGetProcAddress( params->lpszProc );
-    return STATUS_SUCCESS;
-}
-
 static NTSTATUS wgl_wglSetPixelFormat( void *args )
 {
     struct wglSetPixelFormat_params *params = args;
diff --git a/dlls/opengl32/unix_wgl.c b/dlls/opengl32/unix_wgl.c
index 3213bfcb6bc..ada4dbe5498 100644
--- a/dlls/opengl32/unix_wgl.c
+++ b/dlls/opengl32/unix_wgl.c
@@ -194,6 +194,14 @@ static GLuint *filter_extensions_index( const char *disabled )
     return disabled_index;
 }

+static char *heap_strdup( const char *str )
+{
+    int len = strlen( str ) + 1;
+    char *ret = HeapAlloc( GetProcessHeap(), 0, len );
+    memcpy( ret, str, len );
+    return ret;
+}
+
 /* build the extension string by filtering out the disabled extensions */
 static BOOL filter_extensions( const char *extensions, GLubyte **exts_list, GLuint **disabled_exts )
 {
@@ -238,7 +246,7 @@ static const GLuint *disabled_extensions_index(void)
 }

/* Check if a GL extension is supported */
-BOOL check_extension_support( const char *extension, const char *available_extensions )
+static BOOL check_extension_support( const char *extension, const char *available_extensions )
 {
     const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
     size_t len;
@@ -330,7 +338,7 @@ static const GLubyte * WINAPI wrap_glGetStringi( GLenum name, GLuint index )
     return funcs->ext.p_glGetStringi( name, index );
 }

-char *build_extension_list(void)
+static char *build_extension_list(void)
 {
     GLint len = 0, capacity, i, extensions_count;
     char *extension, *tmp, *available_extensions;
@@ -352,6 +360,94 @@ char *build_extension_list(void)
     return available_extensions;
 }

+static inline enum wgl_handle_type get_current_context_type(void)
+{
+    if (!NtCurrentTeb()->glCurrentRC) return HANDLE_CONTEXT;
+    return LOWORD(NtCurrentTeb()->glCurrentRC) & HANDLE_TYPE_MASK;
+}
+
+/* Check if a GL extension is supported */
+static BOOL is_extension_supported( const char *extension )
+{
+    enum wgl_handle_type type = get_current_context_type();
+    char *available_extensions = NULL;
+    BOOL ret = FALSE;
+
+    if (type == HANDLE_CONTEXT) available_extensions = heap_strdup( (const char *)wrap_glGetString( GL_EXTENSIONS ) );
+    if (!available_extensions) available_extensions = build_extension_list();
+
+    if (!available_extensions) ERR( "No OpenGL extensions found, check if your OpenGL setup is correct!\n" );
+    else ret = check_extension_support( extension, available_extensions );
+
+    HeapFree( GetProcessHeap(), 0, available_extensions );
+    return ret;
+}
+
+static int registry_entry_cmp( const void *a, const void *b )
+{
+    const struct registry_entry *entry_a = a, *entry_b = b;
+    return strcmp( entry_a->name, entry_b->name );
+}
+
+static PROC WINAPI wrap_wglGetProcAddress( LPCSTR name )
+{
+    const struct registry_entry entry = {.name = name}, *found;
+    struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
+    const void **func_ptr;
+
+    /* Without an active context opengl32 doesn't know to what
+     * driver it has to dispatch wglGetProcAddress.
+     */
+    if (!get_current_context_ptr())
+    {
+        WARN( "No active WGL context found\n" );
+        return (void *)-1;
+    }
+
+    if (!(found = bsearch( &entry, extension_registry, extension_registry_size, sizeof(entry), registry_entry_cmp )))
+    {
+        WARN( "Function %s unknown\n", name );
+        return (void *)-1;
+    }
+
+    func_ptr = (const void **)&funcs->ext + (found - extension_registry);
+    if (!*func_ptr)
+    {
+        void *driver_func = funcs->wgl.p_wglGetProcAddress( name );
+
+        if (!is_extension_supported( found->extension ))
+        {
+            unsigned int i;
+            static const struct { const char *name, *alt; } alternatives[] =
+            {
+                { "glCopyTexSubImage3DEXT", "glCopyTexSubImage3D" },     /* needed by RuneScape */
+                { "glVertexAttribDivisor", "glVertexAttribDivisorARB"},  /* needed by Caffeine */
+            };
+
+            for (i = 0; i < ARRAY_SIZE(alternatives); i++)
+            {
+                if (strcmp( name, alternatives[i].name )) continue;
+                WARN( "Extension %s required for %s not supported, trying %s\n", found->extension,
+                      name, alternatives[i].alt );
+                return wrap_wglGetProcAddress( alternatives[i].alt );
+            }
+
+            WARN( "Extension %s required for %s not supported\n", found->extension, name );
+            return (void *)-1;
+        }
+
+        if (driver_func == NULL)
+        {
+            WARN( "Function %s not supported by driver\n", name );
+            return (void *)-1;
+        }
+
+        *func_ptr = driver_func;
+    }
+
+    return (void *)(UINT_PTR)(found - extension_registry);
+}
+
 static BOOL wrap_wglCopyContext( HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask )
 {
     struct wgl_handle *src, *dst;
@@ -724,6 +820,13 @@ NTSTATUS wgl_wglDeleteContext( void *args )
     return STATUS_SUCCESS;
 }

+NTSTATUS wgl_wglGetProcAddress( void *args )
+{
+    struct wglGetProcAddress_params *params = args;
+    params->ret = wrap_wglGetProcAddress( params->lpszProc );
+    return STATUS_SUCCESS;
+}
+
 NTSTATUS wgl_wglMakeCurrent( void *args )
 {
     struct wglMakeCurrent_params *params = args;
diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c
index f5a4b034196..1492f9b20b1 100644
--- a/dlls/opengl32/wgl.c
+++ b/dlls/opengl32/wgl.c
@@ -334,98 +334,20 @@ int WINAPI wglGetLayerPaletteEntries(HDC hdc,
   return 0;
 }

-static int registry_entry_cmp( const void *a, const void *b )
-{
-    const struct registry_entry *entry_a = a, *entry_b = b;
-    return strcmp( entry_a->name, entry_b->name );
-}
-
-static char *heap_strdup( const char *str )
-{
-    int len = strlen( str ) + 1;
-    char *ret = HeapAlloc( GetProcessHeap(), 0, len );
-    memcpy( ret, str, len );
-    return ret;
-}
-
-/* Check if a GL extension is supported */
-static BOOL is_extension_supported( const char *extension )
-{
-    enum wgl_handle_type type = get_current_context_type();
-    char *available_extensions = NULL;
-    BOOL ret = FALSE;
-
-    if (type == HANDLE_CONTEXT) available_extensions = heap_strdup( (const char *)glGetString( GL_EXTENSIONS ) );
-    if (!available_extensions) available_extensions = build_extension_list();
-
-    if (!available_extensions) ERR( "No OpenGL extensions found, check if your OpenGL setup is correct!\n" );
-    else ret = check_extension_support( extension, available_extensions );
-
-    HeapFree( GetProcessHeap(), 0, available_extensions );
-    return ret;
-}
-
 /***********************************************************************
  *		wglGetProcAddress (OPENGL32.@)
  */
 PROC WINAPI wglGetProcAddress( LPCSTR name )
 {
-    const struct registry_entry entry = {.name = name}, *found;
-    struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-    const void **func_ptr, *proc;
+    struct wglGetProcAddress_params args = { .lpszProc = name, };
+    const void *proc;
+    NTSTATUS status;

if (!name) return NULL;
+    if ((status = UNIX_CALL( wglGetProcAddress, &args ))) WARN( "wglGetProcAddress %s returned %#x\n", debugstr_a(name), status );
+    if (args.ret == (void *)-1) return NULL;

-    /* Without an active context opengl32 doesn't know to what
-     * driver it has to dispatch wglGetProcAddress.
-     */
-    if (!get_current_context_ptr())
-    {
-        WARN("No active WGL context found\n");
-        return NULL;
-    }
-
-    if (!(found = bsearch( &entry, extension_registry, extension_registry_size,
-                           sizeof(entry), registry_entry_cmp )))
-    {
-        WARN("Function %s unknown\n", name);
-        return NULL;
-    }
-
-    func_ptr = (const void **)&funcs->ext + (found - extension_registry);
-    if (!*func_ptr)
-    {
-        void *driver_func = funcs->wgl.p_wglGetProcAddress( name );
-
-        if (!is_extension_supported(found->extension))
-        {
-            unsigned int i;
-            static const struct { const char *name, *alt; } alternatives[] =
-            {
-                { "glCopyTexSubImage3DEXT", "glCopyTexSubImage3D" },     /* needed by RuneScape */
-                { "glVertexAttribDivisor", "glVertexAttribDivisorARB"},  /* needed by Caffeine */
-            };
-
-            for (i = 0; i < ARRAY_SIZE(alternatives); i++)
-            {
-                if (strcmp( name, alternatives[i].name )) continue;
-                WARN( "Extension %s required for %s not supported, trying %s\n", found->extension,
-                      name, alternatives[i].alt );
-                return wglGetProcAddress( alternatives[i].alt );
-            }
-            WARN( "Extension %s required for %s not supported\n", found->extension, name );
-            return NULL;
-        }
-
-        if (driver_func == NULL)
-        {
-            WARN("Function %s not supported by driver\n", name);
-            return NULL;
-        }
-        *func_ptr = driver_func;
-    }
-
-    proc = extension_procs[found - extension_registry];
+    proc = extension_procs[(UINT_PTR)args.ret];
     TRACE( "returning %s -> %p\n", name, proc );
     return proc;
 }

[PATCH v2 7/7] opengl32: Move wglGetProcAddress extension filtering to unix_wgl.c.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The tests also ran into some preexisting test failures. If you know how
to fix them that would be helpful. See the TestBot job for the details:

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=125853

Your paranoid android.

=== debian11 (32 bit report) ===

d3d8:
device: Timeout

[Rémi Bernon (＠rbernon)]

I initially wanted to keep the registry access on the PE side but it just complicates things, so I'm now moving all the extension filtering to the unix side.