xref: /dports/mail/thunderbird/thunderbird-91.8.0/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// libGLESv2_autogen.cpp: Implements the exported OpenGL ES functions.

#include "angle_gl.h"

#include "libGLESv2/entry_points_gles_1_0_autogen.h"
#include "libGLESv2/entry_points_gles_2_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_0_autogen.h"
#include "libGLESv2/entry_points_gles_3_1_autogen.h"
#include "libGLESv2/entry_points_gles_3_2_autogen.h"
#include "libGLESv2/entry_points_gles_ext_autogen.h"

#include "common/event_tracer.h"

extern "C" {

// OpenGL ES 2.0
void GL_APIENTRY glActiveTexture(GLenum texture)
{
    return GL_ActiveTexture(texture);
}

void GL_APIENTRY glAttachShader(GLuint program, GLuint shader)
{
    return GL_AttachShader(program, shader);
}

void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
{
    return GL_BindAttribLocation(program, index, name);
}

void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer)
{
    return GL_BindBuffer(target, buffer);
}

void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)
{
    return GL_BindFramebuffer(target, framebuffer);
}

void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
    return GL_BindRenderbuffer(target, renderbuffer);
}

void GL_APIENTRY glBindTexture(GLenum target, GLuint texture)
{
    return GL_BindTexture(target, texture);
}

void GL_APIENTRY glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_BlendColor(red, green, blue, alpha);
}

void GL_APIENTRY glBlendEquation(GLenum mode)
{
    return GL_BlendEquation(mode);
}

void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
    return GL_BlendEquationSeparate(modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
{
    return GL_BlendFunc(sfactor, dfactor);
}

void GL_APIENTRY glBlendFuncSeparate(GLenum sfactorRGB,
                                     GLenum dfactorRGB,
                                     GLenum sfactorAlpha,
                                     GLenum dfactorAlpha)
{
    return GL_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
{
    return GL_BufferData(target, size, data, usage);
}

void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
{
    return GL_BufferSubData(target, offset, size, data);
}

GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target)
{
    return GL_CheckFramebufferStatus(target);
}

void GL_APIENTRY glClear(GLbitfield mask)
{
    return GL_Clear(mask);
}

void GL_APIENTRY glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_ClearColor(red, green, blue, alpha);
}

void GL_APIENTRY glClearDepthf(GLfloat d)
{
    return GL_ClearDepthf(d);
}

void GL_APIENTRY glClearStencil(GLint s)
{
    return GL_ClearStencil(s);
}

void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
    return GL_ColorMask(red, green, blue, alpha);
}

void GL_APIENTRY glCompileShader(GLuint shader)
{
    return GL_CompileShader(shader);
}

void GL_APIENTRY glCompressedTexImage2D(GLenum target,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLint border,
                                        GLsizei imageSize,
                                        const void *data)
{
    return GL_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize,
                                   data);
}

void GL_APIENTRY glCompressedTexSubImage2D(GLenum target,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLsizei width,
                                           GLsizei height,
                                           GLenum format,
                                           GLsizei imageSize,
                                           const void *data)
{
    return GL_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
                                      imageSize, data);
}

void GL_APIENTRY glCopyTexImage2D(GLenum target,
                                  GLint level,
                                  GLenum internalformat,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLsizei height,
                                  GLint border)
{
    return GL_CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}

void GL_APIENTRY glCopyTexSubImage2D(GLenum target,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height)
{
    return GL_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}

GLuint GL_APIENTRY glCreateProgram()
{
    return GL_CreateProgram();
}

GLuint GL_APIENTRY glCreateShader(GLenum type)
{
    return GL_CreateShader(type);
}

void GL_APIENTRY glCullFace(GLenum mode)
{
    return GL_CullFace(mode);
}

void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint *buffers)
{
    return GL_DeleteBuffers(n, buffers);
}

void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
{
    return GL_DeleteFramebuffers(n, framebuffers);
}

void GL_APIENTRY glDeleteProgram(GLuint program)
{
    return GL_DeleteProgram(program);
}

void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
{
    return GL_DeleteRenderbuffers(n, renderbuffers);
}

void GL_APIENTRY glDeleteShader(GLuint shader)
{
    return GL_DeleteShader(shader);
}

void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint *textures)
{
    return GL_DeleteTextures(n, textures);
}

void GL_APIENTRY glDepthFunc(GLenum func)
{
    return GL_DepthFunc(func);
}

void GL_APIENTRY glDepthMask(GLboolean flag)
{
    return GL_DepthMask(flag);
}

void GL_APIENTRY glDepthRangef(GLfloat n, GLfloat f)
{
    return GL_DepthRangef(n, f);
}

void GL_APIENTRY glDetachShader(GLuint program, GLuint shader)
{
    return GL_DetachShader(program, shader);
}

void GL_APIENTRY glDisable(GLenum cap)
{
    return GL_Disable(cap);
}

void GL_APIENTRY glDisableVertexAttribArray(GLuint index)
{
    return GL_DisableVertexAttribArray(index);
}

void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
{
    return GL_DrawArrays(mode, first, count);
}

void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
{
    return GL_DrawElements(mode, count, type, indices);
}

void GL_APIENTRY glEnable(GLenum cap)
{
    return GL_Enable(cap);
}

void GL_APIENTRY glEnableVertexAttribArray(GLuint index)
{
    return GL_EnableVertexAttribArray(index);
}

void GL_APIENTRY glFinish()
{
    return GL_Finish();
}

void GL_APIENTRY glFlush()
{
    return GL_Flush();
}

void GL_APIENTRY glFramebufferRenderbuffer(GLenum target,
                                           GLenum attachment,
                                           GLenum renderbuffertarget,
                                           GLuint renderbuffer)
{
    return GL_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}

void GL_APIENTRY glFramebufferTexture2D(GLenum target,
                                        GLenum attachment,
                                        GLenum textarget,
                                        GLuint texture,
                                        GLint level)
{
    return GL_FramebufferTexture2D(target, attachment, textarget, texture, level);
}

void GL_APIENTRY glFrontFace(GLenum mode)
{
    return GL_FrontFace(mode);
}

void GL_APIENTRY glGenBuffers(GLsizei n, GLuint *buffers)
{
    return GL_GenBuffers(n, buffers);
}

void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint *framebuffers)
{
    return GL_GenFramebuffers(n, framebuffers);
}

void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
{
    return GL_GenRenderbuffers(n, renderbuffers);
}

void GL_APIENTRY glGenTextures(GLsizei n, GLuint *textures)
{
    return GL_GenTextures(n, textures);
}

void GL_APIENTRY glGenerateMipmap(GLenum target)
{
    return GL_GenerateMipmap(target);
}

void GL_APIENTRY glGetActiveAttrib(GLuint program,
                                   GLuint index,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLint *size,
                                   GLenum *type,
                                   GLchar *name)
{
    return GL_GetActiveAttrib(program, index, bufSize, length, size, type, name);
}

void GL_APIENTRY glGetActiveUniform(GLuint program,
                                    GLuint index,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLint *size,
                                    GLenum *type,
                                    GLchar *name)
{
    return GL_GetActiveUniform(program, index, bufSize, length, size, type, name);
}

void GL_APIENTRY glGetAttachedShaders(GLuint program,
                                      GLsizei maxCount,
                                      GLsizei *count,
                                      GLuint *shaders)
{
    return GL_GetAttachedShaders(program, maxCount, count, shaders);
}

GLint GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar *name)
{
    return GL_GetAttribLocation(program, name);
}

void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean *data)
{
    return GL_GetBooleanv(pname, data);
}

void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetBufferParameteriv(target, pname, params);
}

GLenum GL_APIENTRY glGetError()
{
    return GL_GetError();
}

void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat *data)
{
    return GL_GetFloatv(pname, data);
}

void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target,
                                                       GLenum attachment,
                                                       GLenum pname,
                                                       GLint *params)
{
    return GL_GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}

void GL_APIENTRY glGetIntegerv(GLenum pname, GLint *data)
{
    return GL_GetIntegerv(pname, data);
}

void GL_APIENTRY glGetProgramInfoLog(GLuint program,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *infoLog)
{
    return GL_GetProgramInfoLog(program, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint *params)
{
    return GL_GetProgramiv(program, pname, params);
}

void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetRenderbufferParameteriv(target, pname, params);
}

void GL_APIENTRY glGetShaderInfoLog(GLuint shader,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *infoLog)
{
    return GL_GetShaderInfoLog(shader, bufSize, length, infoLog);
}

void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype,
                                            GLenum precisiontype,
                                            GLint *range,
                                            GLint *precision)
{
    return GL_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}

void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
{
    return GL_GetShaderSource(shader, bufSize, length, source);
}

void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
{
    return GL_GetShaderiv(shader, pname, params);
}

const GLubyte *GL_APIENTRY glGetString(GLenum name)
{
    return GL_GetString(name);
}

void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
    return GL_GetTexParameterfv(target, pname, params);
}

void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetTexParameteriv(target, pname, params);
}

GLint GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar *name)
{
    return GL_GetUniformLocation(program, name);
}

void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat *params)
{
    return GL_GetUniformfv(program, location, params);
}

void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint *params)
{
    return GL_GetUniformiv(program, location, params);
}

void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
{
    return GL_GetVertexAttribPointerv(index, pname, pointer);
}

void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
{
    return GL_GetVertexAttribfv(index, pname, params);
}

void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
{
    return GL_GetVertexAttribiv(index, pname, params);
}

void GL_APIENTRY glHint(GLenum target, GLenum mode)
{
    return GL_Hint(target, mode);
}

GLboolean GL_APIENTRY glIsBuffer(GLuint buffer)
{
    return GL_IsBuffer(buffer);
}

GLboolean GL_APIENTRY glIsEnabled(GLenum cap)
{
    return GL_IsEnabled(cap);
}

GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer)
{
    return GL_IsFramebuffer(framebuffer);
}

GLboolean GL_APIENTRY glIsProgram(GLuint program)
{
    return GL_IsProgram(program);
}

GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer)
{
    return GL_IsRenderbuffer(renderbuffer);
}

GLboolean GL_APIENTRY glIsShader(GLuint shader)
{
    return GL_IsShader(shader);
}

GLboolean GL_APIENTRY glIsTexture(GLuint texture)
{
    return GL_IsTexture(texture);
}

void GL_APIENTRY glLineWidth(GLfloat width)
{
    return GL_LineWidth(width);
}

void GL_APIENTRY glLinkProgram(GLuint program)
{
    return GL_LinkProgram(program);
}

void GL_APIENTRY glPixelStorei(GLenum pname, GLint param)
{
    return GL_PixelStorei(pname, param);
}

void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
{
    return GL_PolygonOffset(factor, units);
}

void GL_APIENTRY glReadPixels(GLint x,
                              GLint y,
                              GLsizei width,
                              GLsizei height,
                              GLenum format,
                              GLenum type,
                              void *pixels)
{
    return GL_ReadPixels(x, y, width, height, format, type, pixels);
}

void GL_APIENTRY glReleaseShaderCompiler()
{
    return GL_ReleaseShaderCompiler();
}

void GL_APIENTRY glRenderbufferStorage(GLenum target,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height)
{
    return GL_RenderbufferStorage(target, internalformat, width, height);
}

void GL_APIENTRY glSampleCoverage(GLfloat value, GLboolean invert)
{
    return GL_SampleCoverage(value, invert);
}

void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
    return GL_Scissor(x, y, width, height);
}

void GL_APIENTRY glShaderBinary(GLsizei count,
                                const GLuint *shaders,
                                GLenum binaryformat,
                                const void *binary,
                                GLsizei length)
{
    return GL_ShaderBinary(count, shaders, binaryformat, binary, length);
}

void GL_APIENTRY glShaderSource(GLuint shader,
                                GLsizei count,
                                const GLchar *const *string,
                                const GLint *length)
{
    return GL_ShaderSource(shader, count, string, length);
}

void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
    return GL_StencilFunc(func, ref, mask);
}

void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
    return GL_StencilFuncSeparate(face, func, ref, mask);
}

void GL_APIENTRY glStencilMask(GLuint mask)
{
    return GL_StencilMask(mask);
}

void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)
{
    return GL_StencilMaskSeparate(face, mask);
}

void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
    return GL_StencilOp(fail, zfail, zpass);
}

void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
    return GL_StencilOpSeparate(face, sfail, dpfail, dppass);
}

void GL_APIENTRY glTexImage2D(GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
{
    return GL_TexImage2D(target, level, internalformat, width, height, border, format, type,
                         pixels);
}

void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
    return GL_TexParameterf(target, pname, param);
}

void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
    return GL_TexParameterfv(target, pname, params);
}

void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
{
    return GL_TexParameteri(target, pname, param);
}

void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
{
    return GL_TexParameteriv(target, pname, params);
}

void GL_APIENTRY glTexSubImage2D(GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLsizei width,
                                 GLsizei height,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
{
    return GL_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

void GL_APIENTRY glUniform1f(GLint location, GLfloat v0)
{
    return GL_Uniform1f(location, v0);
}

void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
{
    return GL_Uniform1fv(location, count, value);
}

void GL_APIENTRY glUniform1i(GLint location, GLint v0)
{
    return GL_Uniform1i(location, v0);
}

void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint *value)
{
    return GL_Uniform1iv(location, count, value);
}

void GL_APIENTRY glUniform2f(GLint location, GLfloat v0, GLfloat v1)
{
    return GL_Uniform2f(location, v0, v1);
}

void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
{
    return GL_Uniform2fv(location, count, value);
}

void GL_APIENTRY glUniform2i(GLint location, GLint v0, GLint v1)
{
    return GL_Uniform2i(location, v0, v1);
}

void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint *value)
{
    return GL_Uniform2iv(location, count, value);
}

void GL_APIENTRY glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
    return GL_Uniform3f(location, v0, v1, v2);
}

void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
{
    return GL_Uniform3fv(location, count, value);
}

void GL_APIENTRY glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
    return GL_Uniform3i(location, v0, v1, v2);
}

void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint *value)
{
    return GL_Uniform3iv(location, count, value);
}

void GL_APIENTRY glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
    return GL_Uniform4f(location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
{
    return GL_Uniform4fv(location, count, value);
}

void GL_APIENTRY glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
    return GL_Uniform4i(location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint *value)
{
    return GL_Uniform4iv(location, count, value);
}

void GL_APIENTRY glUniformMatrix2fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value)
{
    return GL_UniformMatrix2fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value)
{
    return GL_UniformMatrix3fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4fv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLfloat *value)
{
    return GL_UniformMatrix4fv(location, count, transpose, value);
}

void GL_APIENTRY glUseProgram(GLuint program)
{
    return GL_UseProgram(program);
}

void GL_APIENTRY glValidateProgram(GLuint program)
{
    return GL_ValidateProgram(program);
}

void GL_APIENTRY glVertexAttrib1f(GLuint index, GLfloat x)
{
    return GL_VertexAttrib1f(index, x);
}

void GL_APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib1fv(index, v);
}

void GL_APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
    return GL_VertexAttrib2f(index, x, y);
}

void GL_APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib2fv(index, v);
}

void GL_APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_VertexAttrib3f(index, x, y, z);
}

void GL_APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib3fv(index, v);
}

void GL_APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    return GL_VertexAttrib4f(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib4fv(index, v);
}

void GL_APIENTRY glVertexAttribPointer(GLuint index,
                                       GLint size,
                                       GLenum type,
                                       GLboolean normalized,
                                       GLsizei stride,
                                       const void *pointer)
{
    return GL_VertexAttribPointer(index, size, type, normalized, stride, pointer);
}

void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
    return GL_Viewport(x, y, width, height);
}

// OpenGL ES 3.0
void GL_APIENTRY glBeginQuery(GLenum target, GLuint id)
{
    return GL_BeginQuery(target, id);
}

void GL_APIENTRY glBeginTransformFeedback(GLenum primitiveMode)
{
    return GL_BeginTransformFeedback(primitiveMode);
}

void GL_APIENTRY glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
{
    return GL_BindBufferBase(target, index, buffer);
}

void GL_APIENTRY
glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
    return GL_BindBufferRange(target, index, buffer, offset, size);
}

void GL_APIENTRY glBindSampler(GLuint unit, GLuint sampler)
{
    return GL_BindSampler(unit, sampler);
}

void GL_APIENTRY glBindTransformFeedback(GLenum target, GLuint id)
{
    return GL_BindTransformFeedback(target, id);
}

void GL_APIENTRY glBindVertexArray(GLuint array)
{
    return GL_BindVertexArray(array);
}

void GL_APIENTRY glBlitFramebuffer(GLint srcX0,
                                   GLint srcY0,
                                   GLint srcX1,
                                   GLint srcY1,
                                   GLint dstX0,
                                   GLint dstY0,
                                   GLint dstX1,
                                   GLint dstY1,
                                   GLbitfield mask,
                                   GLenum filter)
{
    return GL_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void GL_APIENTRY glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
    return GL_ClearBufferfi(buffer, drawbuffer, depth, stencil);
}

void GL_APIENTRY glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
{
    return GL_ClearBufferfv(buffer, drawbuffer, value);
}

void GL_APIENTRY glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
{
    return GL_ClearBufferiv(buffer, drawbuffer, value);
}

void GL_APIENTRY glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
{
    return GL_ClearBufferuiv(buffer, drawbuffer, value);
}

GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
    return GL_ClientWaitSync(sync, flags, timeout);
}

void GL_APIENTRY glCompressedTexImage3D(GLenum target,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        GLsizei depth,
                                        GLint border,
                                        GLsizei imageSize,
                                        const void *data)
{
    return GL_CompressedTexImage3D(target, level, internalformat, width, height, depth, border,
                                   imageSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3D(GLenum target,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLint zoffset,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLenum format,
                                           GLsizei imageSize,
                                           const void *data)
{
    return GL_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
                                      depth, format, imageSize, data);
}

void GL_APIENTRY glCopyBufferSubData(GLenum readTarget,
                                     GLenum writeTarget,
                                     GLintptr readOffset,
                                     GLintptr writeOffset,
                                     GLsizeiptr size)
{
    return GL_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}

void GL_APIENTRY glCopyTexSubImage3D(GLenum target,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLint x,
                                     GLint y,
                                     GLsizei width,
                                     GLsizei height)
{
    return GL_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void GL_APIENTRY glDeleteQueries(GLsizei n, const GLuint *ids)
{
    return GL_DeleteQueries(n, ids);
}

void GL_APIENTRY glDeleteSamplers(GLsizei count, const GLuint *samplers)
{
    return GL_DeleteSamplers(count, samplers);
}

void GL_APIENTRY glDeleteSync(GLsync sync)
{
    return GL_DeleteSync(sync);
}

void GL_APIENTRY glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
{
    return GL_DeleteTransformFeedbacks(n, ids);
}

void GL_APIENTRY glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
{
    return GL_DeleteVertexArrays(n, arrays);
}

void GL_APIENTRY glDrawArraysInstanced(GLenum mode,
                                       GLint first,
                                       GLsizei count,
                                       GLsizei instancecount)
{
    return GL_DrawArraysInstanced(mode, first, count, instancecount);
}

void GL_APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs)
{
    return GL_DrawBuffers(n, bufs);
}

void GL_APIENTRY glDrawElementsInstanced(GLenum mode,
                                         GLsizei count,
                                         GLenum type,
                                         const void *indices,
                                         GLsizei instancecount)
{
    return GL_DrawElementsInstanced(mode, count, type, indices, instancecount);
}

void GL_APIENTRY glDrawRangeElements(GLenum mode,
                                     GLuint start,
                                     GLuint end,
                                     GLsizei count,
                                     GLenum type,
                                     const void *indices)
{
    return GL_DrawRangeElements(mode, start, end, count, type, indices);
}

void GL_APIENTRY glEndQuery(GLenum target)
{
    return GL_EndQuery(target);
}

void GL_APIENTRY glEndTransformFeedback()
{
    return GL_EndTransformFeedback();
}

GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)
{
    return GL_FenceSync(condition, flags);
}

void GL_APIENTRY glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
{
    return GL_FlushMappedBufferRange(target, offset, length);
}

void GL_APIENTRY glFramebufferTextureLayer(GLenum target,
                                           GLenum attachment,
                                           GLuint texture,
                                           GLint level,
                                           GLint layer)
{
    return GL_FramebufferTextureLayer(target, attachment, texture, level, layer);
}

void GL_APIENTRY glGenQueries(GLsizei n, GLuint *ids)
{
    return GL_GenQueries(n, ids);
}

void GL_APIENTRY glGenSamplers(GLsizei count, GLuint *samplers)
{
    return GL_GenSamplers(count, samplers);
}

void GL_APIENTRY glGenTransformFeedbacks(GLsizei n, GLuint *ids)
{
    return GL_GenTransformFeedbacks(n, ids);
}

void GL_APIENTRY glGenVertexArrays(GLsizei n, GLuint *arrays)
{
    return GL_GenVertexArrays(n, arrays);
}

void GL_APIENTRY glGetActiveUniformBlockName(GLuint program,
                                             GLuint uniformBlockIndex,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *uniformBlockName)
{
    return GL_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
                                        uniformBlockName);
}

void GL_APIENTRY glGetActiveUniformBlockiv(GLuint program,
                                           GLuint uniformBlockIndex,
                                           GLenum pname,
                                           GLint *params)
{
    return GL_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}

void GL_APIENTRY glGetActiveUniformsiv(GLuint program,
                                       GLsizei uniformCount,
                                       const GLuint *uniformIndices,
                                       GLenum pname,
                                       GLint *params)
{
    return GL_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}

void GL_APIENTRY glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
{
    return GL_GetBufferParameteri64v(target, pname, params);
}

void GL_APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params)
{
    return GL_GetBufferPointerv(target, pname, params);
}

GLint GL_APIENTRY glGetFragDataLocation(GLuint program, const GLchar *name)
{
    return GL_GetFragDataLocation(program, name);
}

void GL_APIENTRY glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
{
    return GL_GetInteger64i_v(target, index, data);
}

void GL_APIENTRY glGetInteger64v(GLenum pname, GLint64 *data)
{
    return GL_GetInteger64v(pname, data);
}

void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
{
    return GL_GetIntegeri_v(target, index, data);
}

void GL_APIENTRY glGetInternalformativ(GLenum target,
                                       GLenum internalformat,
                                       GLenum pname,
                                       GLsizei bufSize,
                                       GLint *params)
{
    return GL_GetInternalformativ(target, internalformat, pname, bufSize, params);
}

void GL_APIENTRY glGetProgramBinary(GLuint program,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLenum *binaryFormat,
                                    void *binary)
{
    return GL_GetProgramBinary(program, bufSize, length, binaryFormat, binary);
}

void GL_APIENTRY glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
{
    return GL_GetQueryObjectuiv(id, pname, params);
}

void GL_APIENTRY glGetQueryiv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetQueryiv(target, pname, params);
}

void GL_APIENTRY glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
{
    return GL_GetSamplerParameterfv(sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
    return GL_GetSamplerParameteriv(sampler, pname, params);
}

const GLubyte *GL_APIENTRY glGetStringi(GLenum name, GLuint index)
{
    return GL_GetStringi(name, index);
}

void GL_APIENTRY
glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
{
    return GL_GetSynciv(sync, pname, bufSize, length, values);
}

void GL_APIENTRY glGetTransformFeedbackVarying(GLuint program,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLsizei *size,
                                               GLenum *type,
                                               GLchar *name)
{
    return GL_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}

GLuint GL_APIENTRY glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
{
    return GL_GetUniformBlockIndex(program, uniformBlockName);
}

void GL_APIENTRY glGetUniformIndices(GLuint program,
                                     GLsizei uniformCount,
                                     const GLchar *const *uniformNames,
                                     GLuint *uniformIndices)
{
    return GL_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}

void GL_APIENTRY glGetUniformuiv(GLuint program, GLint location, GLuint *params)
{
    return GL_GetUniformuiv(program, location, params);
}

void GL_APIENTRY glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
{
    return GL_GetVertexAttribIiv(index, pname, params);
}

void GL_APIENTRY glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
{
    return GL_GetVertexAttribIuiv(index, pname, params);
}

void GL_APIENTRY glInvalidateFramebuffer(GLenum target,
                                         GLsizei numAttachments,
                                         const GLenum *attachments)
{
    return GL_InvalidateFramebuffer(target, numAttachments, attachments);
}

void GL_APIENTRY glInvalidateSubFramebuffer(GLenum target,
                                            GLsizei numAttachments,
                                            const GLenum *attachments,
                                            GLint x,
                                            GLint y,
                                            GLsizei width,
                                            GLsizei height)
{
    return GL_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
}

GLboolean GL_APIENTRY glIsQuery(GLuint id)
{
    return GL_IsQuery(id);
}

GLboolean GL_APIENTRY glIsSampler(GLuint sampler)
{
    return GL_IsSampler(sampler);
}

GLboolean GL_APIENTRY glIsSync(GLsync sync)
{
    return GL_IsSync(sync);
}

GLboolean GL_APIENTRY glIsTransformFeedback(GLuint id)
{
    return GL_IsTransformFeedback(id);
}

GLboolean GL_APIENTRY glIsVertexArray(GLuint array)
{
    return GL_IsVertexArray(array);
}

void *GL_APIENTRY glMapBufferRange(GLenum target,
                                   GLintptr offset,
                                   GLsizeiptr length,
                                   GLbitfield access)
{
    return GL_MapBufferRange(target, offset, length, access);
}

void GL_APIENTRY glPauseTransformFeedback()
{
    return GL_PauseTransformFeedback();
}

void GL_APIENTRY glProgramBinary(GLuint program,
                                 GLenum binaryFormat,
                                 const void *binary,
                                 GLsizei length)
{
    return GL_ProgramBinary(program, binaryFormat, binary, length);
}

void GL_APIENTRY glProgramParameteri(GLuint program, GLenum pname, GLint value)
{
    return GL_ProgramParameteri(program, pname, value);
}

void GL_APIENTRY glReadBuffer(GLenum src)
{
    return GL_ReadBuffer(src);
}

void GL_APIENTRY glRenderbufferStorageMultisample(GLenum target,
                                                  GLsizei samples,
                                                  GLenum internalformat,
                                                  GLsizei width,
                                                  GLsizei height)
{
    return GL_RenderbufferStorageMultisample(target, samples, internalformat, width, height);
}

void GL_APIENTRY glResumeTransformFeedback()
{
    return GL_ResumeTransformFeedback();
}

void GL_APIENTRY glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
    return GL_SamplerParameterf(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
{
    return GL_SamplerParameterfv(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
    return GL_SamplerParameteri(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
{
    return GL_SamplerParameteriv(sampler, pname, param);
}

void GL_APIENTRY glTexImage3D(GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
                              GLsizei depth,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
{
    return GL_TexImage3D(target, level, internalformat, width, height, depth, border, format, type,
                         pixels);
}

void GL_APIENTRY
glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
    return GL_TexStorage2D(target, levels, internalformat, width, height);
}

void GL_APIENTRY glTexStorage3D(GLenum target,
                                GLsizei levels,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height,
                                GLsizei depth)
{
    return GL_TexStorage3D(target, levels, internalformat, width, height, depth);
}

void GL_APIENTRY glTexSubImage3D(GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
{
    return GL_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format,
                            type, pixels);
}

void GL_APIENTRY glTransformFeedbackVaryings(GLuint program,
                                             GLsizei count,
                                             const GLchar *const *varyings,
                                             GLenum bufferMode)
{
    return GL_TransformFeedbackVaryings(program, count, varyings, bufferMode);
}

void GL_APIENTRY glUniform1ui(GLint location, GLuint v0)
{
    return GL_Uniform1ui(location, v0);
}

void GL_APIENTRY glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
{
    return GL_Uniform1uiv(location, count, value);
}

void GL_APIENTRY glUniform2ui(GLint location, GLuint v0, GLuint v1)
{
    return GL_Uniform2ui(location, v0, v1);
}

void GL_APIENTRY glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
{
    return GL_Uniform2uiv(location, count, value);
}

void GL_APIENTRY glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
    return GL_Uniform3ui(location, v0, v1, v2);
}

void GL_APIENTRY glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
{
    return GL_Uniform3uiv(location, count, value);
}

void GL_APIENTRY glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
    return GL_Uniform4ui(location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
{
    return GL_Uniform4uiv(location, count, value);
}

void GL_APIENTRY glUniformBlockBinding(GLuint program,
                                       GLuint uniformBlockIndex,
                                       GLuint uniformBlockBinding)
{
    return GL_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}

void GL_APIENTRY glUniformMatrix2x3fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix2x3fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix2x4fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix2x4fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x2fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix3x2fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x4fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix3x4fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x2fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix4x2fv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x3fv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLfloat *value)
{
    return GL_UniformMatrix4x3fv(location, count, transpose, value);
}

GLboolean GL_APIENTRY glUnmapBuffer(GLenum target)
{
    return GL_UnmapBuffer(target);
}

void GL_APIENTRY glVertexAttribDivisor(GLuint index, GLuint divisor)
{
    return GL_VertexAttribDivisor(index, divisor);
}

void GL_APIENTRY glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
    return GL_VertexAttribI4i(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttribI4iv(GLuint index, const GLint *v)
{
    return GL_VertexAttribI4iv(index, v);
}

void GL_APIENTRY glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
    return GL_VertexAttribI4ui(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
    return GL_VertexAttribI4uiv(index, v);
}

void GL_APIENTRY
glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return GL_VertexAttribIPointer(index, size, type, stride, pointer);
}

void GL_APIENTRY glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
    return GL_WaitSync(sync, flags, timeout);
}

// OpenGL ES 3.1
void GL_APIENTRY glActiveShaderProgram(GLuint pipeline, GLuint program)
{
    return GL_ActiveShaderProgram(pipeline, program);
}

void GL_APIENTRY glBindImageTexture(GLuint unit,
                                    GLuint texture,
                                    GLint level,
                                    GLboolean layered,
                                    GLint layer,
                                    GLenum access,
                                    GLenum format)
{
    return GL_BindImageTexture(unit, texture, level, layered, layer, access, format);
}

void GL_APIENTRY glBindProgramPipeline(GLuint pipeline)
{
    return GL_BindProgramPipeline(pipeline);
}

void GL_APIENTRY glBindVertexBuffer(GLuint bindingindex,
                                    GLuint buffer,
                                    GLintptr offset,
                                    GLsizei stride)
{
    return GL_BindVertexBuffer(bindingindex, buffer, offset, stride);
}

GLuint GL_APIENTRY glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
{
    return GL_CreateShaderProgramv(type, count, strings);
}

void GL_APIENTRY glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
{
    return GL_DeleteProgramPipelines(n, pipelines);
}

void GL_APIENTRY glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
{
    return GL_DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}

void GL_APIENTRY glDispatchComputeIndirect(GLintptr indirect)
{
    return GL_DispatchComputeIndirect(indirect);
}

void GL_APIENTRY glDrawArraysIndirect(GLenum mode, const void *indirect)
{
    return GL_DrawArraysIndirect(mode, indirect);
}

void GL_APIENTRY glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
{
    return GL_DrawElementsIndirect(mode, type, indirect);
}

void GL_APIENTRY glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
{
    return GL_FramebufferParameteri(target, pname, param);
}

void GL_APIENTRY glGenProgramPipelines(GLsizei n, GLuint *pipelines)
{
    return GL_GenProgramPipelines(n, pipelines);
}

void GL_APIENTRY glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
{
    return GL_GetBooleani_v(target, index, data);
}

void GL_APIENTRY glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetFramebufferParameteriv(target, pname, params);
}

void GL_APIENTRY glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
{
    return GL_GetMultisamplefv(pname, index, val);
}

void GL_APIENTRY glGetProgramInterfaceiv(GLuint program,
                                         GLenum programInterface,
                                         GLenum pname,
                                         GLint *params)
{
    return GL_GetProgramInterfaceiv(program, programInterface, pname, params);
}

void GL_APIENTRY glGetProgramPipelineInfoLog(GLuint pipeline,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *infoLog)
{
    return GL_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
{
    return GL_GetProgramPipelineiv(pipeline, pname, params);
}

GLuint GL_APIENTRY glGetProgramResourceIndex(GLuint program,
                                             GLenum programInterface,
                                             const GLchar *name)
{
    return GL_GetProgramResourceIndex(program, programInterface, name);
}

GLint GL_APIENTRY glGetProgramResourceLocation(GLuint program,
                                               GLenum programInterface,
                                               const GLchar *name)
{
    return GL_GetProgramResourceLocation(program, programInterface, name);
}

void GL_APIENTRY glGetProgramResourceName(GLuint program,
                                          GLenum programInterface,
                                          GLuint index,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLchar *name)
{
    return GL_GetProgramResourceName(program, programInterface, index, bufSize, length, name);
}

void GL_APIENTRY glGetProgramResourceiv(GLuint program,
                                        GLenum programInterface,
                                        GLuint index,
                                        GLsizei propCount,
                                        const GLenum *props,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLint *params)
{
    return GL_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize,
                                   length, params);
}

void GL_APIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
    return GL_GetTexLevelParameterfv(target, level, pname, params);
}

void GL_APIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
    return GL_GetTexLevelParameteriv(target, level, pname, params);
}

GLboolean GL_APIENTRY glIsProgramPipeline(GLuint pipeline)
{
    return GL_IsProgramPipeline(pipeline);
}

void GL_APIENTRY glMemoryBarrier(GLbitfield barriers)
{
    return GL_MemoryBarrier(barriers);
}

void GL_APIENTRY glMemoryBarrierByRegion(GLbitfield barriers)
{
    return GL_MemoryBarrierByRegion(barriers);
}

void GL_APIENTRY glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
{
    return GL_ProgramUniform1f(program, location, v0);
}

void GL_APIENTRY glProgramUniform1fv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value)
{
    return GL_ProgramUniform1fv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform1i(GLuint program, GLint location, GLint v0)
{
    return GL_ProgramUniform1i(program, location, v0);
}

void GL_APIENTRY glProgramUniform1iv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value)
{
    return GL_ProgramUniform1iv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
{
    return GL_ProgramUniform1ui(program, location, v0);
}

void GL_APIENTRY glProgramUniform1uiv(GLuint program,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value)
{
    return GL_ProgramUniform1uiv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
    return GL_ProgramUniform2f(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2fv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value)
{
    return GL_ProgramUniform2fv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
{
    return GL_ProgramUniform2i(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2iv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value)
{
    return GL_ProgramUniform2iv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
{
    return GL_ProgramUniform2ui(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2uiv(GLuint program,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value)
{
    return GL_ProgramUniform2uiv(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
    return GL_ProgramUniform3f(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3fv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value)
{
    return GL_ProgramUniform3fv(program, location, count, value);
}

void GL_APIENTRY glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
    return GL_ProgramUniform3i(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3iv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value)
{
    return GL_ProgramUniform3iv(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
    return GL_ProgramUniform3ui(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3uiv(GLuint program,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value)
{
    return GL_ProgramUniform3uiv(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
    return GL_ProgramUniform4f(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4fv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLfloat *value)
{
    return GL_ProgramUniform4fv(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
    return GL_ProgramUniform4i(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4iv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLint *value)
{
    return GL_ProgramUniform4iv(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
    return GL_ProgramUniform4ui(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4uiv(GLuint program,
                                      GLint location,
                                      GLsizei count,
                                      const GLuint *value)
{
    return GL_ProgramUniform4uiv(program, location, count, value);
}

void GL_APIENTRY glProgramUniformMatrix2fv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return GL_ProgramUniformMatrix2fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix2x3fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix2x4fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3fv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return GL_ProgramUniformMatrix3fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3x2fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3x4fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4fv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLfloat *value)
{
    return GL_ProgramUniformMatrix4fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4x2fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4x3fv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}

void GL_APIENTRY glSampleMaski(GLuint maskNumber, GLbitfield mask)
{
    return GL_SampleMaski(maskNumber, mask);
}

void GL_APIENTRY glTexStorage2DMultisample(GLenum target,
                                           GLsizei samples,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLboolean fixedsamplelocations)
{
    return GL_TexStorage2DMultisample(target, samples, internalformat, width, height,
                                      fixedsamplelocations);
}

void GL_APIENTRY glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
{
    return GL_UseProgramStages(pipeline, stages, program);
}

void GL_APIENTRY glValidateProgramPipeline(GLuint pipeline)
{
    return GL_ValidateProgramPipeline(pipeline);
}

void GL_APIENTRY glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
{
    return GL_VertexAttribBinding(attribindex, bindingindex);
}

void GL_APIENTRY glVertexAttribFormat(GLuint attribindex,
                                      GLint size,
                                      GLenum type,
                                      GLboolean normalized,
                                      GLuint relativeoffset)
{
    return GL_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
}

void GL_APIENTRY glVertexAttribIFormat(GLuint attribindex,
                                       GLint size,
                                       GLenum type,
                                       GLuint relativeoffset)
{
    return GL_VertexAttribIFormat(attribindex, size, type, relativeoffset);
}

void GL_APIENTRY glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
{
    return GL_VertexBindingDivisor(bindingindex, divisor);
}

// OpenGL ES 3.2
void GL_APIENTRY glBlendBarrier()
{
    return GL_BlendBarrier();
}

void GL_APIENTRY glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
    return GL_BlendEquationSeparatei(buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationi(GLuint buf, GLenum mode)
{
    return GL_BlendEquationi(buf, mode);
}

void GL_APIENTRY
glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
    return GL_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFunci(GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunci(buf, src, dst);
}

void GL_APIENTRY glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
    return GL_ColorMaski(index, r, g, b, a);
}

void GL_APIENTRY glCopyImageSubData(GLuint srcName,
                                    GLenum srcTarget,
                                    GLint srcLevel,
                                    GLint srcX,
                                    GLint srcY,
                                    GLint srcZ,
                                    GLuint dstName,
                                    GLenum dstTarget,
                                    GLint dstLevel,
                                    GLint dstX,
                                    GLint dstY,
                                    GLint dstZ,
                                    GLsizei srcWidth,
                                    GLsizei srcHeight,
                                    GLsizei srcDepth)
{
    return GL_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget,
                               dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}

void GL_APIENTRY glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
{
    return GL_DebugMessageCallback(callback, userParam);
}

void GL_APIENTRY glDebugMessageControl(GLenum source,
                                       GLenum type,
                                       GLenum severity,
                                       GLsizei count,
                                       const GLuint *ids,
                                       GLboolean enabled)
{
    return GL_DebugMessageControl(source, type, severity, count, ids, enabled);
}

void GL_APIENTRY glDebugMessageInsert(GLenum source,
                                      GLenum type,
                                      GLuint id,
                                      GLenum severity,
                                      GLsizei length,
                                      const GLchar *buf)
{
    return GL_DebugMessageInsert(source, type, id, severity, length, buf);
}

void GL_APIENTRY glDisablei(GLenum target, GLuint index)
{
    return GL_Disablei(target, index);
}

void GL_APIENTRY glDrawElementsBaseVertex(GLenum mode,
                                          GLsizei count,
                                          GLenum type,
                                          const void *indices,
                                          GLint basevertex)
{
    return GL_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertex(GLenum mode,
                                                   GLsizei count,
                                                   GLenum type,
                                                   const void *indices,
                                                   GLsizei instancecount,
                                                   GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount,
                                              basevertex);
}

void GL_APIENTRY glDrawRangeElementsBaseVertex(GLenum mode,
                                               GLuint start,
                                               GLuint end,
                                               GLsizei count,
                                               GLenum type,
                                               const void *indices,
                                               GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}

void GL_APIENTRY glEnablei(GLenum target, GLuint index)
{
    return GL_Enablei(target, index);
}

void GL_APIENTRY glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
    return GL_FramebufferTexture(target, attachment, texture, level);
}

GLuint GL_APIENTRY glGetDebugMessageLog(GLuint count,
                                        GLsizei bufSize,
                                        GLenum *sources,
                                        GLenum *types,
                                        GLuint *ids,
                                        GLenum *severities,
                                        GLsizei *lengths,
                                        GLchar *messageLog)
{
    return GL_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths,
                                 messageLog);
}

GLenum GL_APIENTRY glGetGraphicsResetStatus()
{
    return GL_GetGraphicsResetStatus();
}

void GL_APIENTRY
glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
{
    return GL_GetObjectLabel(identifier, name, bufSize, length, label);
}

void GL_APIENTRY glGetObjectPtrLabel(const void *ptr,
                                     GLsizei bufSize,
                                     GLsizei *length,
                                     GLchar *label)
{
    return GL_GetObjectPtrLabel(ptr, bufSize, length, label);
}

void GL_APIENTRY glGetPointerv(GLenum pname, void **params)
{
    return GL_GetPointerv(pname, params);
}

void GL_APIENTRY glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
{
    return GL_GetSamplerParameterIiv(sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
{
    return GL_GetSamplerParameterIuiv(sampler, pname, params);
}

void GL_APIENTRY glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetTexParameterIiv(target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
{
    return GL_GetTexParameterIuiv(target, pname, params);
}

void GL_APIENTRY glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
{
    return GL_GetnUniformfv(program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
{
    return GL_GetnUniformiv(program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
{
    return GL_GetnUniformuiv(program, location, bufSize, params);
}

GLboolean GL_APIENTRY glIsEnabledi(GLenum target, GLuint index)
{
    return GL_IsEnabledi(target, index);
}

void GL_APIENTRY glMinSampleShading(GLfloat value)
{
    return GL_MinSampleShading(value);
}

void GL_APIENTRY glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
{
    return GL_ObjectLabel(identifier, name, length, label);
}

void GL_APIENTRY glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
{
    return GL_ObjectPtrLabel(ptr, length, label);
}

void GL_APIENTRY glPatchParameteri(GLenum pname, GLint value)
{
    return GL_PatchParameteri(pname, value);
}

void GL_APIENTRY glPopDebugGroup()
{
    return GL_PopDebugGroup();
}

void GL_APIENTRY glPrimitiveBoundingBox(GLfloat minX,
                                        GLfloat minY,
                                        GLfloat minZ,
                                        GLfloat minW,
                                        GLfloat maxX,
                                        GLfloat maxY,
                                        GLfloat maxZ,
                                        GLfloat maxW)
{
    return GL_PrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}

void GL_APIENTRY glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
{
    return GL_PushDebugGroup(source, id, length, message);
}

void GL_APIENTRY glReadnPixels(GLint x,
                               GLint y,
                               GLsizei width,
                               GLsizei height,
                               GLenum format,
                               GLenum type,
                               GLsizei bufSize,
                               void *data)
{
    return GL_ReadnPixels(x, y, width, height, format, type, bufSize, data);
}

void GL_APIENTRY glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
{
    return GL_SamplerParameterIiv(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
{
    return GL_SamplerParameterIuiv(sampler, pname, param);
}

void GL_APIENTRY glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
    return GL_TexBuffer(target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferRange(GLenum target,
                                  GLenum internalformat,
                                  GLuint buffer,
                                  GLintptr offset,
                                  GLsizeiptr size)
{
    return GL_TexBufferRange(target, internalformat, buffer, offset, size);
}

void GL_APIENTRY glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
{
    return GL_TexParameterIiv(target, pname, params);
}

void GL_APIENTRY glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
{
    return GL_TexParameterIuiv(target, pname, params);
}

void GL_APIENTRY glTexStorage3DMultisample(GLenum target,
                                           GLsizei samples,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLboolean fixedsamplelocations)
{
    return GL_TexStorage3DMultisample(target, samples, internalformat, width, height, depth,
                                      fixedsamplelocations);
}

// OpenGL ES 1.0
void GL_APIENTRY glAlphaFunc(GLenum func, GLfloat ref)
{
    return GL_AlphaFunc(func, ref);
}

void GL_APIENTRY glAlphaFuncx(GLenum func, GLfixed ref)
{
    return GL_AlphaFuncx(func, ref);
}

void GL_APIENTRY glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
    return GL_ClearColorx(red, green, blue, alpha);
}

void GL_APIENTRY glClearDepthx(GLfixed depth)
{
    return GL_ClearDepthx(depth);
}

void GL_APIENTRY glClientActiveTexture(GLenum texture)
{
    return GL_ClientActiveTexture(texture);
}

void GL_APIENTRY glClipPlanef(GLenum p, const GLfloat *eqn)
{
    return GL_ClipPlanef(p, eqn);
}

void GL_APIENTRY glClipPlanex(GLenum plane, const GLfixed *equation)
{
    return GL_ClipPlanex(plane, equation);
}

void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_Color4f(red, green, blue, alpha);
}

void GL_APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
    return GL_Color4ub(red, green, blue, alpha);
}

void GL_APIENTRY glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
    return GL_Color4x(red, green, blue, alpha);
}

void GL_APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return GL_ColorPointer(size, type, stride, pointer);
}

void GL_APIENTRY glDepthRangex(GLfixed n, GLfixed f)
{
    return GL_DepthRangex(n, f);
}

void GL_APIENTRY glDisableClientState(GLenum array)
{
    return GL_DisableClientState(array);
}

void GL_APIENTRY glEnableClientState(GLenum array)
{
    return GL_EnableClientState(array);
}

void GL_APIENTRY glFogf(GLenum pname, GLfloat param)
{
    return GL_Fogf(pname, param);
}

void GL_APIENTRY glFogfv(GLenum pname, const GLfloat *params)
{
    return GL_Fogfv(pname, params);
}

void GL_APIENTRY glFogx(GLenum pname, GLfixed param)
{
    return GL_Fogx(pname, param);
}

void GL_APIENTRY glFogxv(GLenum pname, const GLfixed *param)
{
    return GL_Fogxv(pname, param);
}

void GL_APIENTRY glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
    return GL_Frustumf(l, r, b, t, n, f);
}

void GL_APIENTRY glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
    return GL_Frustumx(l, r, b, t, n, f);
}

void GL_APIENTRY glGetClipPlanef(GLenum plane, GLfloat *equation)
{
    return GL_GetClipPlanef(plane, equation);
}

void GL_APIENTRY glGetClipPlanex(GLenum plane, GLfixed *equation)
{
    return GL_GetClipPlanex(plane, equation);
}

void GL_APIENTRY glGetFixedv(GLenum pname, GLfixed *params)
{
    return GL_GetFixedv(pname, params);
}

void GL_APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
    return GL_GetLightfv(light, pname, params);
}

void GL_APIENTRY glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
{
    return GL_GetLightxv(light, pname, params);
}

void GL_APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
    return GL_GetMaterialfv(face, pname, params);
}

void GL_APIENTRY glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
{
    return GL_GetMaterialxv(face, pname, params);
}

void GL_APIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
    return GL_GetTexEnvfv(target, pname, params);
}

void GL_APIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetTexEnviv(target, pname, params);
}

void GL_APIENTRY glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
{
    return GL_GetTexEnvxv(target, pname, params);
}

void GL_APIENTRY glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
{
    return GL_GetTexParameterxv(target, pname, params);
}

void GL_APIENTRY glLightModelf(GLenum pname, GLfloat param)
{
    return GL_LightModelf(pname, param);
}

void GL_APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
{
    return GL_LightModelfv(pname, params);
}

void GL_APIENTRY glLightModelx(GLenum pname, GLfixed param)
{
    return GL_LightModelx(pname, param);
}

void GL_APIENTRY glLightModelxv(GLenum pname, const GLfixed *param)
{
    return GL_LightModelxv(pname, param);
}

void GL_APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
{
    return GL_Lightf(light, pname, param);
}

void GL_APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
    return GL_Lightfv(light, pname, params);
}

void GL_APIENTRY glLightx(GLenum light, GLenum pname, GLfixed param)
{
    return GL_Lightx(light, pname, param);
}

void GL_APIENTRY glLightxv(GLenum light, GLenum pname, const GLfixed *params)
{
    return GL_Lightxv(light, pname, params);
}

void GL_APIENTRY glLineWidthx(GLfixed width)
{
    return GL_LineWidthx(width);
}

void GL_APIENTRY glLoadIdentity()
{
    return GL_LoadIdentity();
}

void GL_APIENTRY glLoadMatrixf(const GLfloat *m)
{
    return GL_LoadMatrixf(m);
}

void GL_APIENTRY glLoadMatrixx(const GLfixed *m)
{
    return GL_LoadMatrixx(m);
}

void GL_APIENTRY glLogicOp(GLenum opcode)
{
    return GL_LogicOp(opcode);
}

void GL_APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
{
    return GL_Materialf(face, pname, param);
}

void GL_APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
    return GL_Materialfv(face, pname, params);
}

void GL_APIENTRY glMaterialx(GLenum face, GLenum pname, GLfixed param)
{
    return GL_Materialx(face, pname, param);
}

void GL_APIENTRY glMaterialxv(GLenum face, GLenum pname, const GLfixed *param)
{
    return GL_Materialxv(face, pname, param);
}

void GL_APIENTRY glMatrixMode(GLenum mode)
{
    return GL_MatrixMode(mode);
}

void GL_APIENTRY glMultMatrixf(const GLfloat *m)
{
    return GL_MultMatrixf(m);
}

void GL_APIENTRY glMultMatrixx(const GLfixed *m)
{
    return GL_MultMatrixx(m);
}

void GL_APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
    return GL_MultiTexCoord4f(target, s, t, r, q);
}

void GL_APIENTRY glMultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
    return GL_MultiTexCoord4x(texture, s, t, r, q);
}

void GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
    return GL_Normal3f(nx, ny, nz);
}

void GL_APIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
{
    return GL_Normal3x(nx, ny, nz);
}

void GL_APIENTRY glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
{
    return GL_NormalPointer(type, stride, pointer);
}

void GL_APIENTRY glOrthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
    return GL_Orthof(l, r, b, t, n, f);
}

void GL_APIENTRY glOrthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
    return GL_Orthox(l, r, b, t, n, f);
}

void GL_APIENTRY glPointParameterf(GLenum pname, GLfloat param)
{
    return GL_PointParameterf(pname, param);
}

void GL_APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params)
{
    return GL_PointParameterfv(pname, params);
}

void GL_APIENTRY glPointParameterx(GLenum pname, GLfixed param)
{
    return GL_PointParameterx(pname, param);
}

void GL_APIENTRY glPointParameterxv(GLenum pname, const GLfixed *params)
{
    return GL_PointParameterxv(pname, params);
}

void GL_APIENTRY glPointSize(GLfloat size)
{
    return GL_PointSize(size);
}

void GL_APIENTRY glPointSizex(GLfixed size)
{
    return GL_PointSizex(size);
}

void GL_APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units)
{
    return GL_PolygonOffsetx(factor, units);
}

void GL_APIENTRY glPopMatrix()
{
    return GL_PopMatrix();
}

void GL_APIENTRY glPushMatrix()
{
    return GL_PushMatrix();
}

void GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_Rotatef(angle, x, y, z);
}

void GL_APIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
    return GL_Rotatex(angle, x, y, z);
}

void GL_APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert)
{
    return GL_SampleCoveragex(value, invert);
}

void GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
{
    return GL_Scalef(x, y, z);
}

void GL_APIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z)
{
    return GL_Scalex(x, y, z);
}

void GL_APIENTRY glShadeModel(GLenum mode)
{
    return GL_ShadeModel(mode);
}

void GL_APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return GL_TexCoordPointer(size, type, stride, pointer);
}

void GL_APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
    return GL_TexEnvf(target, pname, param);
}

void GL_APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
    return GL_TexEnvfv(target, pname, params);
}

void GL_APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)
{
    return GL_TexEnvi(target, pname, param);
}

void GL_APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params)
{
    return GL_TexEnviv(target, pname, params);
}

void GL_APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param)
{
    return GL_TexEnvx(target, pname, param);
}

void GL_APIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
{
    return GL_TexEnvxv(target, pname, params);
}

void GL_APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param)
{
    return GL_TexParameterx(target, pname, param);
}

void GL_APIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
{
    return GL_TexParameterxv(target, pname, params);
}

void GL_APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
    return GL_Translatef(x, y, z);
}

void GL_APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z)
{
    return GL_Translatex(x, y, z);
}

void GL_APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return GL_VertexPointer(size, type, stride, pointer);
}

// GL_ANGLE_base_vertex_base_instance
void GL_APIENTRY glDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
                                                        GLint first,
                                                        GLsizei count,
                                                        GLsizei instanceCount,
                                                        GLuint baseInstance)
{
    return GL_DrawArraysInstancedBaseInstanceANGLE(mode, first, count, instanceCount, baseInstance);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
                                                                    GLsizei count,
                                                                    GLenum type,
                                                                    const GLvoid *indices,
                                                                    GLsizei instanceCounts,
                                                                    GLint baseVertex,
                                                                    GLuint baseInstance)
{
    return GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(
        mode, count, type, indices, instanceCounts, baseVertex, baseInstance);
}

void GL_APIENTRY glMultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode,
                                                             const GLint *firsts,
                                                             const GLsizei *counts,
                                                             const GLsizei *instanceCounts,
                                                             const GLuint *baseInstances,
                                                             GLsizei drawcount)
{
    return GL_MultiDrawArraysInstancedBaseInstanceANGLE(mode, firsts, counts, instanceCounts,
                                                        baseInstances, drawcount);
}

void GL_APIENTRY
glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode,
                                                        const GLsizei *counts,
                                                        GLenum type,
                                                        const GLvoid *const *indices,
                                                        const GLsizei *instanceCounts,
                                                        const GLint *baseVertices,
                                                        const GLuint *baseInstances,
                                                        GLsizei drawcount)
{
    return GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(
        mode, counts, type, indices, instanceCounts, baseVertices, baseInstances, drawcount);
}

// GL_ANGLE_copy_texture_3d
void GL_APIENTRY glCopyTexture3DANGLE(GLuint sourceId,
                                      GLint sourceLevel,
                                      GLenum destTarget,
                                      GLuint destId,
                                      GLint destLevel,
                                      GLint internalFormat,
                                      GLenum destType,
                                      GLboolean unpackFlipY,
                                      GLboolean unpackPremultiplyAlpha,
                                      GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopyTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel,
                                 internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
                                 unpackUnmultiplyAlpha);
}

void GL_APIENTRY glCopySubTexture3DANGLE(GLuint sourceId,
                                         GLint sourceLevel,
                                         GLenum destTarget,
                                         GLuint destId,
                                         GLint destLevel,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLint x,
                                         GLint y,
                                         GLint z,
                                         GLint width,
                                         GLint height,
                                         GLint depth,
                                         GLboolean unpackFlipY,
                                         GLboolean unpackPremultiplyAlpha,
                                         GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopySubTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset,
                                    yoffset, zoffset, x, y, z, width, height, depth, unpackFlipY,
                                    unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

// GL_ANGLE_framebuffer_blit
void GL_APIENTRY glBlitFramebufferANGLE(GLint srcX0,
                                        GLint srcY0,
                                        GLint srcX1,
                                        GLint srcY1,
                                        GLint dstX0,
                                        GLint dstY0,
                                        GLint dstX1,
                                        GLint dstY1,
                                        GLbitfield mask,
                                        GLenum filter)
{
    return GL_BlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
                                   filter);
}

// GL_ANGLE_framebuffer_multisample
void GL_APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height)
{
    return GL_RenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
}

// GL_ANGLE_get_image
void GL_APIENTRY
glGetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
    return GL_GetTexImageANGLE(target, level, format, type, pixels);
}

void GL_APIENTRY glGetRenderbufferImageANGLE(GLenum target,
                                             GLenum format,
                                             GLenum type,
                                             void *pixels)
{
    return GL_GetRenderbufferImageANGLE(target, format, type, pixels);
}

// GL_ANGLE_get_tex_level_parameter
void GL_APIENTRY glGetTexLevelParameterivANGLE(GLenum target,
                                               GLint level,
                                               GLenum pname,
                                               GLint *params)
{
    return GL_GetTexLevelParameterivANGLE(target, level, pname, params);
}

void GL_APIENTRY glGetTexLevelParameterfvANGLE(GLenum target,
                                               GLint level,
                                               GLenum pname,
                                               GLfloat *params)
{
    return GL_GetTexLevelParameterfvANGLE(target, level, pname, params);
}

// GL_ANGLE_instanced_arrays
void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode,
                                            GLint first,
                                            GLsizei count,
                                            GLsizei primcount)
{
    return GL_DrawArraysInstancedANGLE(mode, first, count, primcount);
}

void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode,
                                              GLsizei count,
                                              GLenum type,
                                              const void *indices,
                                              GLsizei primcount)
{
    return GL_DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
}

void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor)
{
    return GL_VertexAttribDivisorANGLE(index, divisor);
}

// GL_ANGLE_memory_object_flags
void GL_APIENTRY glTexStorageMemFlags2DANGLE(GLenum target,
                                             GLsizei levels,
                                             GLenum internalFormat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLuint memory,
                                             GLuint64 offset,
                                             GLbitfield createFlags,
                                             GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags2DANGLE(target, levels, internalFormat, width, height, memory,
                                        offset, createFlags, usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags2DMultisampleANGLE(GLenum target,
                                                        GLsizei samples,
                                                        GLenum internalFormat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLboolean fixedSampleLocations,
                                                        GLuint memory,
                                                        GLuint64 offset,
                                                        GLbitfield createFlags,
                                                        GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags2DMultisampleANGLE(target, samples, internalFormat, width, height,
                                                   fixedSampleLocations, memory, offset,
                                                   createFlags, usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags3DANGLE(GLenum target,
                                             GLsizei levels,
                                             GLenum internalFormat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLuint memory,
                                             GLuint64 offset,
                                             GLbitfield createFlags,
                                             GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags3DANGLE(target, levels, internalFormat, width, height, depth,
                                        memory, offset, createFlags, usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags3DMultisampleANGLE(GLenum target,
                                                        GLsizei samples,
                                                        GLenum internalFormat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLsizei depth,
                                                        GLboolean fixedSampleLocations,
                                                        GLuint memory,
                                                        GLuint64 offset,
                                                        GLbitfield createFlags,
                                                        GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags3DMultisampleANGLE(target, samples, internalFormat, width, height,
                                                   depth, fixedSampleLocations, memory, offset,
                                                   createFlags, usageFlags);
}

// GL_ANGLE_memory_object_fuchsia
void GL_APIENTRY glImportMemoryZirconHandleANGLE(GLuint memory,
                                                 GLuint64 size,
                                                 GLenum handleType,
                                                 GLuint handle)
{
    return GL_ImportMemoryZirconHandleANGLE(memory, size, handleType, handle);
}

// GL_ANGLE_multi_draw
void GL_APIENTRY glMultiDrawArraysANGLE(GLenum mode,
                                        const GLint *firsts,
                                        const GLsizei *counts,
                                        GLsizei drawcount)
{
    return GL_MultiDrawArraysANGLE(mode, firsts, counts, drawcount);
}

void GL_APIENTRY glMultiDrawArraysInstancedANGLE(GLenum mode,
                                                 const GLint *firsts,
                                                 const GLsizei *counts,
                                                 const GLsizei *instanceCounts,
                                                 GLsizei drawcount)
{
    return GL_MultiDrawArraysInstancedANGLE(mode, firsts, counts, instanceCounts, drawcount);
}

void GL_APIENTRY glMultiDrawElementsANGLE(GLenum mode,
                                          const GLsizei *counts,
                                          GLenum type,
                                          const GLvoid *const *indices,
                                          GLsizei drawcount)
{
    return GL_MultiDrawElementsANGLE(mode, counts, type, indices, drawcount);
}

void GL_APIENTRY glMultiDrawElementsInstancedANGLE(GLenum mode,
                                                   const GLsizei *counts,
                                                   GLenum type,
                                                   const GLvoid *const *indices,
                                                   const GLsizei *instanceCounts,
                                                   GLsizei drawcount)
{
    return GL_MultiDrawElementsInstancedANGLE(mode, counts, type, indices, instanceCounts,
                                              drawcount);
}

// GL_ANGLE_program_binary

// GL_ANGLE_provoking_vertex
void GL_APIENTRY glProvokingVertexANGLE(GLenum mode)
{
    return GL_ProvokingVertexANGLE(mode);
}

// GL_ANGLE_request_extension
void GL_APIENTRY glRequestExtensionANGLE(const GLchar *name)
{
    return GL_RequestExtensionANGLE(name);
}

void GL_APIENTRY glDisableExtensionANGLE(const GLchar *name)
{
    return GL_DisableExtensionANGLE(name);
}

// GL_ANGLE_robust_client_memory
void GL_APIENTRY glGetBooleanvRobustANGLE(GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLboolean *params)
{
    return GL_GetBooleanvRobustANGLE(pname, bufSize, length, params);
}

void GL_APIENTRY glGetBufferParameterivRobustANGLE(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLint *params)
{
    return GL_GetBufferParameterivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetFloatvRobustANGLE(GLenum pname,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLfloat *params)
{
    return GL_GetFloatvRobustANGLE(pname, bufSize, length, params);
}

void GL_APIENTRY glGetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
                                                                  GLenum attachment,
                                                                  GLenum pname,
                                                                  GLsizei bufSize,
                                                                  GLsizei *length,
                                                                  GLint *params)
{
    return GL_GetFramebufferAttachmentParameterivRobustANGLE(target, attachment, pname, bufSize,
                                                             length, params);
}

void GL_APIENTRY glGetIntegervRobustANGLE(GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *data)
{
    return GL_GetIntegervRobustANGLE(pname, bufSize, length, data);
}

void GL_APIENTRY glGetProgramivRobustANGLE(GLuint program,
                                           GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params)
{
    return GL_GetProgramivRobustANGLE(program, pname, bufSize, length, params);
}

void GL_APIENTRY glGetRenderbufferParameterivRobustANGLE(GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLint *params)
{
    return GL_GetRenderbufferParameterivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetShaderivRobustANGLE(GLuint shader,
                                          GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLint *params)
{
    return GL_GetShaderivRobustANGLE(shader, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexParameterfvRobustANGLE(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params)
{
    return GL_GetTexParameterfvRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexParameterivRobustANGLE(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params)
{
    return GL_GetTexParameterivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetUniformfvRobustANGLE(GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLfloat *params)
{
    return GL_GetUniformfvRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glGetUniformivRobustANGLE(GLuint program,
                                           GLint location,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLint *params)
{
    return GL_GetUniformivRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribfvRobustANGLE(GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLfloat *params)
{
    return GL_GetVertexAttribfvRobustANGLE(index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribivRobustANGLE(GLuint index,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *params)
{
    return GL_GetVertexAttribivRobustANGLE(index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribPointervRobustANGLE(GLuint index,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      void **pointer)
{
    return GL_GetVertexAttribPointervRobustANGLE(index, pname, bufSize, length, pointer);
}

void GL_APIENTRY glReadPixelsRobustANGLE(GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLsizei *columns,
                                         GLsizei *rows,
                                         void *pixels)
{
    return GL_ReadPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns,
                                    rows, pixels);
}

void GL_APIENTRY glTexImage2DRobustANGLE(GLenum target,
                                         GLint level,
                                         GLint internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         const void *pixels)
{
    return GL_TexImage2DRobustANGLE(target, level, internalformat, width, height, border, format,
                                    type, bufSize, pixels);
}

void GL_APIENTRY glTexParameterfvRobustANGLE(GLenum target,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLfloat *params)
{
    return GL_TexParameterfvRobustANGLE(target, pname, bufSize, params);
}

void GL_APIENTRY glTexParameterivRobustANGLE(GLenum target,
                                             GLenum pname,
                                             GLsizei bufSize,
                                             const GLint *params)
{
    return GL_TexParameterivRobustANGLE(target, pname, bufSize, params);
}

void GL_APIENTRY glTexSubImage2DRobustANGLE(GLenum target,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLenum format,
                                            GLenum type,
                                            GLsizei bufSize,
                                            const void *pixels)
{
    return GL_TexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, format, type,
                                       bufSize, pixels);
}

void GL_APIENTRY glTexImage3DRobustANGLE(GLenum target,
                                         GLint level,
                                         GLint internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLint border,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         const void *pixels)
{
    return GL_TexImage3DRobustANGLE(target, level, internalformat, width, height, depth, border,
                                    format, type, bufSize, pixels);
}

void GL_APIENTRY glTexSubImage3DRobustANGLE(GLenum target,
                                            GLint level,
                                            GLint xoffset,
                                            GLint yoffset,
                                            GLint zoffset,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLenum format,
                                            GLenum type,
                                            GLsizei bufSize,
                                            const void *pixels)
{
    return GL_TexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, height,
                                       depth, format, type, bufSize, pixels);
}

void GL_APIENTRY glCompressedTexImage2DRobustANGLE(GLenum target,
                                                   GLint level,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height,
                                                   GLint border,
                                                   GLsizei imageSize,
                                                   GLsizei dataSize,
                                                   const GLvoid *data)
{
    return GL_CompressedTexImage2DRobustANGLE(target, level, internalformat, width, height, border,
                                              imageSize, dataSize, data);
}

void GL_APIENTRY glCompressedTexSubImage2DRobustANGLE(GLenum target,
                                                      GLint level,
                                                      GLsizei xoffset,
                                                      GLsizei yoffset,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLenum format,
                                                      GLsizei imageSize,
                                                      GLsizei dataSize,
                                                      const GLvoid *data)
{
    return GL_CompressedTexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height,
                                                 format, imageSize, dataSize, data);
}

void GL_APIENTRY glCompressedTexImage3DRobustANGLE(GLenum target,
                                                   GLint level,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height,
                                                   GLsizei depth,
                                                   GLint border,
                                                   GLsizei imageSize,
                                                   GLsizei dataSize,
                                                   const GLvoid *data)
{
    return GL_CompressedTexImage3DRobustANGLE(target, level, internalformat, width, height, depth,
                                              border, imageSize, dataSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3DRobustANGLE(GLenum target,
                                                      GLint level,
                                                      GLint xoffset,
                                                      GLint yoffset,
                                                      GLint zoffset,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLsizei depth,
                                                      GLenum format,
                                                      GLsizei imageSize,
                                                      GLsizei dataSize,
                                                      const GLvoid *data)
{
    return GL_CompressedTexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width,
                                                 height, depth, format, imageSize, dataSize, data);
}

void GL_APIENTRY glGetQueryivRobustANGLE(GLenum target,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *params)
{
    return GL_GetQueryivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjectuivRobustANGLE(GLuint id,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLuint *params)
{
    return GL_GetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetBufferPointervRobustANGLE(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                void **params)
{
    return GL_GetBufferPointervRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetIntegeri_vRobustANGLE(GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *data)
{
    return GL_GetIntegeri_vRobustANGLE(target, index, bufSize, length, data);
}

void GL_APIENTRY glGetInternalformativRobustANGLE(GLenum target,
                                                  GLenum internalformat,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLint *params)
{
    return GL_GetInternalformativRobustANGLE(target, internalformat, pname, bufSize, length,
                                             params);
}

void GL_APIENTRY glGetVertexAttribIivRobustANGLE(GLuint index,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params)
{
    return GL_GetVertexAttribIivRobustANGLE(index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribIuivRobustANGLE(GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params)
{
    return GL_GetVertexAttribIuivRobustANGLE(index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetUniformuivRobustANGLE(GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLuint *params)
{
    return GL_GetUniformuivRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glGetActiveUniformBlockivRobustANGLE(GLuint program,
                                                      GLuint uniformBlockIndex,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params)
{
    return GL_GetActiveUniformBlockivRobustANGLE(program, uniformBlockIndex, pname, bufSize, length,
                                                 params);
}

void GL_APIENTRY glGetInteger64vRobustANGLE(GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint64 *data)
{
    return GL_GetInteger64vRobustANGLE(pname, bufSize, length, data);
}

void GL_APIENTRY glGetInteger64i_vRobustANGLE(GLenum target,
                                              GLuint index,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLint64 *data)
{
    return GL_GetInteger64i_vRobustANGLE(target, index, bufSize, length, data);
}

void GL_APIENTRY glGetBufferParameteri64vRobustANGLE(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint64 *params)
{
    return GL_GetBufferParameteri64vRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glSamplerParameterivRobustANGLE(GLuint sampler,
                                                 GLuint pname,
                                                 GLsizei bufSize,
                                                 const GLint *param)
{
    return GL_SamplerParameterivRobustANGLE(sampler, pname, bufSize, param);
}

void GL_APIENTRY glSamplerParameterfvRobustANGLE(GLuint sampler,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 const GLfloat *param)
{
    return GL_SamplerParameterfvRobustANGLE(sampler, pname, bufSize, param);
}

void GL_APIENTRY glGetSamplerParameterivRobustANGLE(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params)
{
    return GL_GetSamplerParameterivRobustANGLE(sampler, pname, bufSize, length, params);
}

void GL_APIENTRY glGetSamplerParameterfvRobustANGLE(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params)
{
    return GL_GetSamplerParameterfvRobustANGLE(sampler, pname, bufSize, length, params);
}

void GL_APIENTRY glGetFramebufferParameterivRobustANGLE(GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params)
{
    return GL_GetFramebufferParameterivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetProgramInterfaceivRobustANGLE(GLuint program,
                                                    GLenum programInterface,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params)
{
    return GL_GetProgramInterfaceivRobustANGLE(program, programInterface, pname, bufSize, length,
                                               params);
}

void GL_APIENTRY glGetBooleani_vRobustANGLE(GLenum target,
                                            GLuint index,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLboolean *data)
{
    return GL_GetBooleani_vRobustANGLE(target, index, bufSize, length, data);
}

void GL_APIENTRY glGetMultisamplefvRobustANGLE(GLenum pname,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLfloat *val)
{
    return GL_GetMultisamplefvRobustANGLE(pname, index, bufSize, length, val);
}

void GL_APIENTRY glGetTexLevelParameterivRobustANGLE(GLenum target,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params)
{
    return GL_GetTexLevelParameterivRobustANGLE(target, level, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexLevelParameterfvRobustANGLE(GLenum target,
                                                     GLint level,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLfloat *params)
{
    return GL_GetTexLevelParameterfvRobustANGLE(target, level, pname, bufSize, length, params);
}

void GL_APIENTRY glGetPointervRobustANGLERobustANGLE(GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     void **params)
{
    return GL_GetPointervRobustANGLERobustANGLE(pname, bufSize, length, params);
}

void GL_APIENTRY glReadnPixelsRobustANGLE(GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLsizei *columns,
                                          GLsizei *rows,
                                          void *data)
{
    return GL_ReadnPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns,
                                     rows, data);
}

void GL_APIENTRY glGetnUniformfvRobustANGLE(GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLfloat *params)
{
    return GL_GetnUniformfvRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glGetnUniformivRobustANGLE(GLuint program,
                                            GLint location,
                                            GLsizei bufSize,
                                            GLsizei *length,
                                            GLint *params)
{
    return GL_GetnUniformivRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glGetnUniformuivRobustANGLE(GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLuint *params)
{
    return GL_GetnUniformuivRobustANGLE(program, location, bufSize, length, params);
}

void GL_APIENTRY glTexParameterIivRobustANGLE(GLenum target,
                                              GLenum pname,
                                              GLsizei bufSize,
                                              const GLint *params)
{
    return GL_TexParameterIivRobustANGLE(target, pname, bufSize, params);
}

void GL_APIENTRY glTexParameterIuivRobustANGLE(GLenum target,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               const GLuint *params)
{
    return GL_TexParameterIuivRobustANGLE(target, pname, bufSize, params);
}

void GL_APIENTRY glGetTexParameterIivRobustANGLE(GLenum target,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint *params)
{
    return GL_GetTexParameterIivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexParameterIuivRobustANGLE(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint *params)
{
    return GL_GetTexParameterIuivRobustANGLE(target, pname, bufSize, length, params);
}

void GL_APIENTRY glSamplerParameterIivRobustANGLE(GLuint sampler,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  const GLint *param)
{
    return GL_SamplerParameterIivRobustANGLE(sampler, pname, bufSize, param);
}

void GL_APIENTRY glSamplerParameterIuivRobustANGLE(GLuint sampler,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   const GLuint *param)
{
    return GL_SamplerParameterIuivRobustANGLE(sampler, pname, bufSize, param);
}

void GL_APIENTRY glGetSamplerParameterIivRobustANGLE(GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params)
{
    return GL_GetSamplerParameterIivRobustANGLE(sampler, pname, bufSize, length, params);
}

void GL_APIENTRY glGetSamplerParameterIuivRobustANGLE(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLuint *params)
{
    return GL_GetSamplerParameterIuivRobustANGLE(sampler, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjectivRobustANGLE(GLuint id,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *params)
{
    return GL_GetQueryObjectivRobustANGLE(id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjecti64vRobustANGLE(GLuint id,
                                                 GLenum pname,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLint64 *params)
{
    return GL_GetQueryObjecti64vRobustANGLE(id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjectui64vRobustANGLE(GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLuint64 *params)
{
    return GL_GetQueryObjectui64vRobustANGLE(id, pname, bufSize, length, params);
}

// GL_ANGLE_semaphore_fuchsia
void GL_APIENTRY glImportSemaphoreZirconHandleANGLE(GLuint semaphore,
                                                    GLenum handleType,
                                                    GLuint handle)
{
    return GL_ImportSemaphoreZirconHandleANGLE(semaphore, handleType, handle);
}

// GL_ANGLE_texture_external_update
void GL_APIENTRY glTexImage2DExternalANGLE(GLenum target,
                                           GLint level,
                                           GLint internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLint border,
                                           GLenum format,
                                           GLenum type)
{
    return GL_TexImage2DExternalANGLE(target, level, internalformat, width, height, border, format,
                                      type);
}

void GL_APIENTRY glInvalidateTextureANGLE(GLenum target)
{
    return GL_InvalidateTextureANGLE(target);
}

// GL_ANGLE_texture_multisample
void GL_APIENTRY glTexStorage2DMultisampleANGLE(GLenum target,
                                                GLsizei samples,
                                                GLenum internalformat,
                                                GLsizei width,
                                                GLsizei height,
                                                GLboolean fixedsamplelocations)
{
    return GL_TexStorage2DMultisampleANGLE(target, samples, internalformat, width, height,
                                           fixedsamplelocations);
}

void GL_APIENTRY glGetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
{
    return GL_GetMultisamplefvANGLE(pname, index, val);
}

void GL_APIENTRY glSampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
{
    return GL_SampleMaskiANGLE(maskNumber, mask);
}

// GL_ANGLE_translated_shader_source
void GL_APIENTRY glGetTranslatedShaderSourceANGLE(GLuint shader,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *source)
{
    return GL_GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
}

// GL_CHROMIUM_bind_uniform_location
void GL_APIENTRY glBindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
{
    return GL_BindUniformLocationCHROMIUM(program, location, name);
}

// GL_CHROMIUM_copy_compressed_texture
void GL_APIENTRY glCompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
{
    return GL_CompressedCopyTextureCHROMIUM(sourceId, destId);
}

// GL_CHROMIUM_copy_texture
void GL_APIENTRY glCopyTextureCHROMIUM(GLuint sourceId,
                                       GLint sourceLevel,
                                       GLenum destTarget,
                                       GLuint destId,
                                       GLint destLevel,
                                       GLint internalFormat,
                                       GLenum destType,
                                       GLboolean unpackFlipY,
                                       GLboolean unpackPremultiplyAlpha,
                                       GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopyTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel,
                                  internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
                                  unpackUnmultiplyAlpha);
}

void GL_APIENTRY glCopySubTextureCHROMIUM(GLuint sourceId,
                                          GLint sourceLevel,
                                          GLenum destTarget,
                                          GLuint destId,
                                          GLint destLevel,
                                          GLint xoffset,
                                          GLint yoffset,
                                          GLint x,
                                          GLint y,
                                          GLint width,
                                          GLint height,
                                          GLboolean unpackFlipY,
                                          GLboolean unpackPremultiplyAlpha,
                                          GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopySubTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset,
                                     yoffset, x, y, width, height, unpackFlipY,
                                     unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

// GL_CHROMIUM_framebuffer_mixed_samples
void GL_APIENTRY glCoverageModulationCHROMIUM(GLenum components)
{
    return GL_CoverageModulationCHROMIUM(components);
}

// GL_CHROMIUM_lose_context
void GL_APIENTRY glLoseContextCHROMIUM(GLenum current, GLenum other)
{
    return GL_LoseContextCHROMIUM(current, other);
}

// GL_EXT_EGL_image_array

// GL_EXT_YUV_target

// GL_EXT_blend_func_extended
void GL_APIENTRY glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
{
    return GL_BindFragDataLocationEXT(program, color, name);
}

void GL_APIENTRY glBindFragDataLocationIndexedEXT(GLuint program,
                                                  GLuint colorNumber,
                                                  GLuint index,
                                                  const GLchar *name)
{
    return GL_BindFragDataLocationIndexedEXT(program, colorNumber, index, name);
}

GLint GL_APIENTRY glGetFragDataIndexEXT(GLuint program, const GLchar *name)
{
    return GL_GetFragDataIndexEXT(program, name);
}

GLint GL_APIENTRY glGetProgramResourceLocationIndexEXT(GLuint program,
                                                       GLenum programInterface,
                                                       const GLchar *name)
{
    return GL_GetProgramResourceLocationIndexEXT(program, programInterface, name);
}

// GL_EXT_buffer_storage
void GL_APIENTRY glBufferStorageEXT(GLenum target,
                                    GLsizeiptr size,
                                    const void *data,
                                    GLbitfield flags)
{
    return GL_BufferStorageEXT(target, size, data, flags);
}

// GL_EXT_clip_control
void GL_APIENTRY glClipControlEXT(GLenum origin, GLenum depth)
{
    return GL_ClipControlEXT(origin, depth);
}

// GL_EXT_copy_image
void GL_APIENTRY glCopyImageSubDataEXT(GLuint srcName,
                                       GLenum srcTarget,
                                       GLint srcLevel,
                                       GLint srcX,
                                       GLint srcY,
                                       GLint srcZ,
                                       GLuint dstName,
                                       GLenum dstTarget,
                                       GLint dstLevel,
                                       GLint dstX,
                                       GLint dstY,
                                       GLint dstZ,
                                       GLsizei srcWidth,
                                       GLsizei srcHeight,
                                       GLsizei srcDepth)
{
    return GL_CopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
                                  dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                  srcDepth);
}

// GL_EXT_debug_label
void GL_APIENTRY
glGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
{
    return GL_GetObjectLabelEXT(type, object, bufSize, length, label);
}

void GL_APIENTRY glLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
{
    return GL_LabelObjectEXT(type, object, length, label);
}

// GL_EXT_debug_marker
void GL_APIENTRY glInsertEventMarkerEXT(GLsizei length, const GLchar *marker)
{
    return GL_InsertEventMarkerEXT(length, marker);
}

void GL_APIENTRY glPopGroupMarkerEXT()
{
    return GL_PopGroupMarkerEXT();
}

void GL_APIENTRY glPushGroupMarkerEXT(GLsizei length, const GLchar *marker)
{
    return GL_PushGroupMarkerEXT(length, marker);
}

// GL_EXT_discard_framebuffer
void GL_APIENTRY glDiscardFramebufferEXT(GLenum target,
                                         GLsizei numAttachments,
                                         const GLenum *attachments)
{
    return GL_DiscardFramebufferEXT(target, numAttachments, attachments);
}

// GL_EXT_disjoint_timer_query
void GL_APIENTRY glBeginQueryEXT(GLenum target, GLuint id)
{
    return GL_BeginQueryEXT(target, id);
}

void GL_APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
{
    return GL_DeleteQueriesEXT(n, ids);
}

void GL_APIENTRY glEndQueryEXT(GLenum target)
{
    return GL_EndQueryEXT(target);
}

void GL_APIENTRY glGenQueriesEXT(GLsizei n, GLuint *ids)
{
    return GL_GenQueriesEXT(n, ids);
}

void GL_APIENTRY glGetInteger64vEXT(GLenum pname, GLint64 *data)
{
    return GL_GetInteger64vEXT(pname, data);
}

void GL_APIENTRY glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
{
    return GL_GetQueryObjecti64vEXT(id, pname, params);
}

void GL_APIENTRY glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
{
    return GL_GetQueryObjectivEXT(id, pname, params);
}

void GL_APIENTRY glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
{
    return GL_GetQueryObjectui64vEXT(id, pname, params);
}

void GL_APIENTRY glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
{
    return GL_GetQueryObjectuivEXT(id, pname, params);
}

void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetQueryivEXT(target, pname, params);
}

GLboolean GL_APIENTRY glIsQueryEXT(GLuint id)
{
    return GL_IsQueryEXT(id);
}

void GL_APIENTRY glQueryCounterEXT(GLuint id, GLenum target)
{
    return GL_QueryCounterEXT(id, target);
}

// GL_EXT_draw_buffers
void GL_APIENTRY glDrawBuffersEXT(GLsizei n, const GLenum *bufs)
{
    return GL_DrawBuffersEXT(n, bufs);
}

// GL_EXT_draw_buffers_indexed
void GL_APIENTRY glBlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
    return GL_BlendEquationSeparateiEXT(buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationiEXT(GLuint buf, GLenum mode)
{
    return GL_BlendEquationiEXT(buf, mode);
}

void GL_APIENTRY
glBlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
    return GL_BlendFuncSeparateiEXT(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFunciEXT(GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunciEXT(buf, src, dst);
}

void GL_APIENTRY glColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
    return GL_ColorMaskiEXT(index, r, g, b, a);
}

void GL_APIENTRY glDisableiEXT(GLenum target, GLuint index)
{
    return GL_DisableiEXT(target, index);
}

void GL_APIENTRY glEnableiEXT(GLenum target, GLuint index)
{
    return GL_EnableiEXT(target, index);
}

GLboolean GL_APIENTRY glIsEnablediEXT(GLenum target, GLuint index)
{
    return GL_IsEnablediEXT(target, index);
}

// GL_EXT_draw_elements_base_vertex
void GL_APIENTRY glDrawElementsBaseVertexEXT(GLenum mode,
                                             GLsizei count,
                                             GLenum type,
                                             const void *indices,
                                             GLint basevertex)
{
    return GL_DrawElementsBaseVertexEXT(mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexEXT(GLenum mode,
                                                      GLsizei count,
                                                      GLenum type,
                                                      const void *indices,
                                                      GLsizei instancecount,
                                                      GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount,
                                                 basevertex);
}

void GL_APIENTRY glDrawRangeElementsBaseVertexEXT(GLenum mode,
                                                  GLuint start,
                                                  GLuint end,
                                                  GLsizei count,
                                                  GLenum type,
                                                  const void *indices,
                                                  GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex);
}

void GL_APIENTRY glMultiDrawElementsBaseVertexEXT(GLenum mode,
                                                  const GLsizei *count,
                                                  GLenum type,
                                                  const void *const *indices,
                                                  GLsizei primcount,
                                                  const GLint *basevertex)
{
    return GL_MultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex);
}

// GL_EXT_external_buffer
void GL_APIENTRY glBufferStorageExternalEXT(GLenum target,
                                            GLintptr offset,
                                            GLsizeiptr size,
                                            GLeglClientBufferEXT clientBuffer,
                                            GLbitfield flags)
{
    return GL_BufferStorageExternalEXT(target, offset, size, clientBuffer, flags);
}

void GL_APIENTRY glNamedBufferStorageExternalEXT(GLuint buffer,
                                                 GLintptr offset,
                                                 GLsizeiptr size,
                                                 GLeglClientBufferEXT clientBuffer,
                                                 GLbitfield flags)
{
    return GL_NamedBufferStorageExternalEXT(buffer, offset, size, clientBuffer, flags);
}

// GL_EXT_geometry_shader
void GL_APIENTRY glFramebufferTextureEXT(GLenum target,
                                         GLenum attachment,
                                         GLuint texture,
                                         GLint level)
{
    return GL_FramebufferTextureEXT(target, attachment, texture, level);
}

// GL_EXT_instanced_arrays
void GL_APIENTRY glDrawArraysInstancedEXT(GLenum mode,
                                          GLint start,
                                          GLsizei count,
                                          GLsizei primcount)
{
    return GL_DrawArraysInstancedEXT(mode, start, count, primcount);
}

void GL_APIENTRY glDrawElementsInstancedEXT(GLenum mode,
                                            GLsizei count,
                                            GLenum type,
                                            const void *indices,
                                            GLsizei primcount)
{
    return GL_DrawElementsInstancedEXT(mode, count, type, indices, primcount);
}

void GL_APIENTRY glVertexAttribDivisorEXT(GLuint index, GLuint divisor)
{
    return GL_VertexAttribDivisorEXT(index, divisor);
}

// GL_EXT_map_buffer_range
void GL_APIENTRY glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
{
    return GL_FlushMappedBufferRangeEXT(target, offset, length);
}

void *GL_APIENTRY glMapBufferRangeEXT(GLenum target,
                                      GLintptr offset,
                                      GLsizeiptr length,
                                      GLbitfield access)
{
    return GL_MapBufferRangeEXT(target, offset, length, access);
}

// GL_EXT_memory_object
void GL_APIENTRY glBufferStorageMemEXT(GLenum target,
                                       GLsizeiptr size,
                                       GLuint memory,
                                       GLuint64 offset)
{
    return GL_BufferStorageMemEXT(target, size, memory, offset);
}

void GL_APIENTRY glCreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
{
    return GL_CreateMemoryObjectsEXT(n, memoryObjects);
}

void GL_APIENTRY glDeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
{
    return GL_DeleteMemoryObjectsEXT(n, memoryObjects);
}

void GL_APIENTRY glGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
{
    return GL_GetMemoryObjectParameterivEXT(memoryObject, pname, params);
}

void GL_APIENTRY glGetUnsignedBytevEXT(GLenum pname, GLubyte *data)
{
    return GL_GetUnsignedBytevEXT(pname, data);
}

void GL_APIENTRY glGetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
{
    return GL_GetUnsignedBytei_vEXT(target, index, data);
}

GLboolean GL_APIENTRY glIsMemoryObjectEXT(GLuint memoryObject)
{
    return GL_IsMemoryObjectEXT(memoryObject);
}

void GL_APIENTRY glMemoryObjectParameterivEXT(GLuint memoryObject,
                                              GLenum pname,
                                              const GLint *params)
{
    return GL_MemoryObjectParameterivEXT(memoryObject, pname, params);
}

void GL_APIENTRY glTexStorageMem2DEXT(GLenum target,
                                      GLsizei levels,
                                      GLenum internalFormat,
                                      GLsizei width,
                                      GLsizei height,
                                      GLuint memory,
                                      GLuint64 offset)
{
    return GL_TexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset);
}

void GL_APIENTRY glTexStorageMem2DMultisampleEXT(GLenum target,
                                                 GLsizei samples,
                                                 GLenum internalFormat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLboolean fixedSampleLocations,
                                                 GLuint memory,
                                                 GLuint64 offset)
{
    return GL_TexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height,
                                            fixedSampleLocations, memory, offset);
}

void GL_APIENTRY glTexStorageMem3DEXT(GLenum target,
                                      GLsizei levels,
                                      GLenum internalFormat,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLuint memory,
                                      GLuint64 offset)
{
    return GL_TexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory,
                                 offset);
}

void GL_APIENTRY glTexStorageMem3DMultisampleEXT(GLenum target,
                                                 GLsizei samples,
                                                 GLenum internalFormat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 GLboolean fixedSampleLocations,
                                                 GLuint memory,
                                                 GLuint64 offset)
{
    return GL_TexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth,
                                            fixedSampleLocations, memory, offset);
}

// GL_EXT_memory_object_fd
void GL_APIENTRY glImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
{
    return GL_ImportMemoryFdEXT(memory, size, handleType, fd);
}

// GL_EXT_multisampled_render_to_texture
void GL_APIENTRY glFramebufferTexture2DMultisampleEXT(GLenum target,
                                                      GLenum attachment,
                                                      GLenum textarget,
                                                      GLuint texture,
                                                      GLint level,
                                                      GLsizei samples)
{
    return GL_FramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level,
                                                 samples);
}

void GL_APIENTRY glRenderbufferStorageMultisampleEXT(GLenum target,
                                                     GLsizei samples,
                                                     GLenum internalformat,
                                                     GLsizei width,
                                                     GLsizei height)
{
    return GL_RenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
}

// GL_EXT_occlusion_query_boolean

// GL_EXT_primitive_bounding_box
void GL_APIENTRY glPrimitiveBoundingBoxEXT(GLfloat minX,
                                           GLfloat minY,
                                           GLfloat minZ,
                                           GLfloat minW,
                                           GLfloat maxX,
                                           GLfloat maxY,
                                           GLfloat maxZ,
                                           GLfloat maxW)
{
    return GL_PrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}

// GL_EXT_read_format_bgra

// GL_EXT_robustness
GLenum GL_APIENTRY glGetGraphicsResetStatusEXT()
{
    return GL_GetGraphicsResetStatusEXT();
}

void GL_APIENTRY glGetnUniformfvEXT(GLuint program,
                                    GLint location,
                                    GLsizei bufSize,
                                    GLfloat *params)
{
    return GL_GetnUniformfvEXT(program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
{
    return GL_GetnUniformivEXT(program, location, bufSize, params);
}

void GL_APIENTRY glReadnPixelsEXT(GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLsizei height,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  void *data)
{
    return GL_ReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
}

// GL_EXT_sRGB

// GL_EXT_semaphore
void GL_APIENTRY glDeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
{
    return GL_DeleteSemaphoresEXT(n, semaphores);
}

void GL_APIENTRY glGenSemaphoresEXT(GLsizei n, GLuint *semaphores)
{
    return GL_GenSemaphoresEXT(n, semaphores);
}

void GL_APIENTRY glGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
{
    return GL_GetSemaphoreParameterui64vEXT(semaphore, pname, params);
}

GLboolean GL_APIENTRY glIsSemaphoreEXT(GLuint semaphore)
{
    return GL_IsSemaphoreEXT(semaphore);
}

void GL_APIENTRY glSemaphoreParameterui64vEXT(GLuint semaphore,
                                              GLenum pname,
                                              const GLuint64 *params)
{
    return GL_SemaphoreParameterui64vEXT(semaphore, pname, params);
}

void GL_APIENTRY glSignalSemaphoreEXT(GLuint semaphore,
                                      GLuint numBufferBarriers,
                                      const GLuint *buffers,
                                      GLuint numTextureBarriers,
                                      const GLuint *textures,
                                      const GLenum *dstLayouts)
{
    return GL_SignalSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers,
                                 textures, dstLayouts);
}

void GL_APIENTRY glWaitSemaphoreEXT(GLuint semaphore,
                                    GLuint numBufferBarriers,
                                    const GLuint *buffers,
                                    GLuint numTextureBarriers,
                                    const GLuint *textures,
                                    const GLenum *srcLayouts)
{
    return GL_WaitSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures,
                               srcLayouts);
}

// GL_EXT_semaphore_fd
void GL_APIENTRY glImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
{
    return GL_ImportSemaphoreFdEXT(semaphore, handleType, fd);
}

// GL_EXT_separate_shader_objects
void GL_APIENTRY glActiveShaderProgramEXT(GLuint pipeline, GLuint program)
{
    return GL_ActiveShaderProgramEXT(pipeline, program);
}

void GL_APIENTRY glBindProgramPipelineEXT(GLuint pipeline)
{
    return GL_BindProgramPipelineEXT(pipeline);
}

GLuint GL_APIENTRY glCreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings)
{
    return GL_CreateShaderProgramvEXT(type, count, strings);
}

void GL_APIENTRY glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
{
    return GL_DeleteProgramPipelinesEXT(n, pipelines);
}

void GL_APIENTRY glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
{
    return GL_GenProgramPipelinesEXT(n, pipelines);
}

void GL_APIENTRY glGetProgramPipelineInfoLogEXT(GLuint pipeline,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *infoLog)
{
    return GL_GetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params)
{
    return GL_GetProgramPipelineivEXT(pipeline, pname, params);
}

GLboolean GL_APIENTRY glIsProgramPipelineEXT(GLuint pipeline)
{
    return GL_IsProgramPipelineEXT(pipeline);
}

void GL_APIENTRY glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
{
    return GL_ProgramParameteriEXT(program, pname, value);
}

void GL_APIENTRY glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
{
    return GL_ProgramUniform1fEXT(program, location, v0);
}

void GL_APIENTRY glProgramUniform1fvEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLfloat *value)
{
    return GL_ProgramUniform1fvEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
{
    return GL_ProgramUniform1iEXT(program, location, v0);
}

void GL_APIENTRY glProgramUniform1ivEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLint *value)
{
    return GL_ProgramUniform1ivEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
{
    return GL_ProgramUniform1uiEXT(program, location, v0);
}

void GL_APIENTRY glProgramUniform1uivEXT(GLuint program,
                                         GLint location,
                                         GLsizei count,
                                         const GLuint *value)
{
    return GL_ProgramUniform1uivEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
    return GL_ProgramUniform2fEXT(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2fvEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLfloat *value)
{
    return GL_ProgramUniform2fvEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
{
    return GL_ProgramUniform2iEXT(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2ivEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLint *value)
{
    return GL_ProgramUniform2ivEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
{
    return GL_ProgramUniform2uiEXT(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2uivEXT(GLuint program,
                                         GLint location,
                                         GLsizei count,
                                         const GLuint *value)
{
    return GL_ProgramUniform2uivEXT(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
    return GL_ProgramUniform3fEXT(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3fvEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLfloat *value)
{
    return GL_ProgramUniform3fvEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
    return GL_ProgramUniform3iEXT(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3ivEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLint *value)
{
    return GL_ProgramUniform3ivEXT(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
    return GL_ProgramUniform3uiEXT(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3uivEXT(GLuint program,
                                         GLint location,
                                         GLsizei count,
                                         const GLuint *value)
{
    return GL_ProgramUniform3uivEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniform4fEXT(GLuint program,
                                       GLint location,
                                       GLfloat v0,
                                       GLfloat v1,
                                       GLfloat v2,
                                       GLfloat v3)
{
    return GL_ProgramUniform4fEXT(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4fvEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLfloat *value)
{
    return GL_ProgramUniform4fvEXT(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
    return GL_ProgramUniform4iEXT(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4ivEXT(GLuint program,
                                        GLint location,
                                        GLsizei count,
                                        const GLint *value)
{
    return GL_ProgramUniform4ivEXT(program, location, count, value);
}

void GL_APIENTRY
glProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
    return GL_ProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4uivEXT(GLuint program,
                                         GLint location,
                                         GLsizei count,
                                         const GLuint *value)
{
    return GL_ProgramUniform4uivEXT(program, location, count, value);
}

void GL_APIENTRY glProgramUniformMatrix2fvEXT(GLuint program,
                                              GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{
    return GL_ProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix2x3fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix2x4fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3fvEXT(GLuint program,
                                              GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{
    return GL_ProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3x2fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3x4fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4fvEXT(GLuint program,
                                              GLint location,
                                              GLsizei count,
                                              GLboolean transpose,
                                              const GLfloat *value)
{
    return GL_ProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4x2fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4x3fvEXT(GLuint program,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
}

void GL_APIENTRY glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program)
{
    return GL_UseProgramStagesEXT(pipeline, stages, program);
}

void GL_APIENTRY glValidateProgramPipelineEXT(GLuint pipeline)
{
    return GL_ValidateProgramPipelineEXT(pipeline);
}

// GL_EXT_shader_framebuffer_fetch_non_coherent
void GL_APIENTRY glFramebufferFetchBarrierEXT()
{
    return GL_FramebufferFetchBarrierEXT();
}

// GL_EXT_shader_io_blocks

// GL_EXT_tessellation_shader
void GL_APIENTRY glPatchParameteriEXT(GLenum pname, GLint value)
{
    return GL_PatchParameteriEXT(pname, value);
}

// GL_EXT_texture_border_clamp
void GL_APIENTRY glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params)
{
    return GL_GetSamplerParameterIivEXT(sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params)
{
    return GL_GetSamplerParameterIuivEXT(sampler, pname, params);
}

void GL_APIENTRY glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetTexParameterIivEXT(target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
{
    return GL_GetTexParameterIuivEXT(target, pname, params);
}

void GL_APIENTRY glSamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param)
{
    return GL_SamplerParameterIivEXT(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param)
{
    return GL_SamplerParameterIuivEXT(sampler, pname, param);
}

void GL_APIENTRY glTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
{
    return GL_TexParameterIivEXT(target, pname, params);
}

void GL_APIENTRY glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
{
    return GL_TexParameterIuivEXT(target, pname, params);
}

// GL_EXT_texture_buffer
void GL_APIENTRY glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
{
    return GL_TexBufferEXT(target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferRangeEXT(GLenum target,
                                     GLenum internalformat,
                                     GLuint buffer,
                                     GLintptr offset,
                                     GLsizeiptr size)
{
    return GL_TexBufferRangeEXT(target, internalformat, buffer, offset, size);
}

// GL_EXT_texture_compression_bptc

// GL_EXT_texture_compression_dxt1

// GL_EXT_texture_compression_rgtc

// GL_EXT_texture_compression_s3tc

// GL_EXT_texture_compression_s3tc_srgb

// GL_EXT_texture_cube_map_array

// GL_EXT_texture_filter_anisotropic

// GL_EXT_texture_format_BGRA8888

// GL_EXT_texture_sRGB_R8

// GL_EXT_texture_sRGB_RG8

// GL_EXT_texture_storage
void GL_APIENTRY glTexStorage1DEXT(GLenum target,
                                   GLsizei levels,
                                   GLenum internalformat,
                                   GLsizei width)
{
    return GL_TexStorage1DEXT(target, levels, internalformat, width);
}

void GL_APIENTRY glTexStorage2DEXT(GLenum target,
                                   GLsizei levels,
                                   GLenum internalformat,
                                   GLsizei width,
                                   GLsizei height)
{
    return GL_TexStorage2DEXT(target, levels, internalformat, width, height);
}

void GL_APIENTRY glTexStorage3DEXT(GLenum target,
                                   GLsizei levels,
                                   GLenum internalformat,
                                   GLsizei width,
                                   GLsizei height,
                                   GLsizei depth)
{
    return GL_TexStorage3DEXT(target, levels, internalformat, width, height, depth);
}

// GL_KHR_blend_equation_advanced
void GL_APIENTRY glBlendBarrierKHR()
{
    return GL_BlendBarrierKHR();
}

// GL_KHR_debug
void GL_APIENTRY glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
{
    return GL_DebugMessageCallbackKHR(callback, userParam);
}

void GL_APIENTRY glDebugMessageControlKHR(GLenum source,
                                          GLenum type,
                                          GLenum severity,
                                          GLsizei count,
                                          const GLuint *ids,
                                          GLboolean enabled)
{
    return GL_DebugMessageControlKHR(source, type, severity, count, ids, enabled);
}

void GL_APIENTRY glDebugMessageInsertKHR(GLenum source,
                                         GLenum type,
                                         GLuint id,
                                         GLenum severity,
                                         GLsizei length,
                                         const GLchar *buf)
{
    return GL_DebugMessageInsertKHR(source, type, id, severity, length, buf);
}

GLuint GL_APIENTRY glGetDebugMessageLogKHR(GLuint count,
                                           GLsizei bufSize,
                                           GLenum *sources,
                                           GLenum *types,
                                           GLuint *ids,
                                           GLenum *severities,
                                           GLsizei *lengths,
                                           GLchar *messageLog)
{
    return GL_GetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths,
                                    messageLog);
}

void GL_APIENTRY
glGetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
{
    return GL_GetObjectLabelKHR(identifier, name, bufSize, length, label);
}

void GL_APIENTRY glGetObjectPtrLabelKHR(const void *ptr,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *label)
{
    return GL_GetObjectPtrLabelKHR(ptr, bufSize, length, label);
}

void GL_APIENTRY glGetPointervKHR(GLenum pname, void **params)
{
    return GL_GetPointervKHR(pname, params);
}

void GL_APIENTRY glObjectLabelKHR(GLenum identifier,
                                  GLuint name,
                                  GLsizei length,
                                  const GLchar *label)
{
    return GL_ObjectLabelKHR(identifier, name, length, label);
}

void GL_APIENTRY glObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
{
    return GL_ObjectPtrLabelKHR(ptr, length, label);
}

void GL_APIENTRY glPopDebugGroupKHR()
{
    return GL_PopDebugGroupKHR();
}

void GL_APIENTRY glPushDebugGroupKHR(GLenum source,
                                     GLuint id,
                                     GLsizei length,
                                     const GLchar *message)
{
    return GL_PushDebugGroupKHR(source, id, length, message);
}

// GL_KHR_parallel_shader_compile
void GL_APIENTRY glMaxShaderCompilerThreadsKHR(GLuint count)
{
    return GL_MaxShaderCompilerThreadsKHR(count);
}

// GL_NV_fence
void GL_APIENTRY glDeleteFencesNV(GLsizei n, const GLuint *fences)
{
    return GL_DeleteFencesNV(n, fences);
}

void GL_APIENTRY glFinishFenceNV(GLuint fence)
{
    return GL_FinishFenceNV(fence);
}

void GL_APIENTRY glGenFencesNV(GLsizei n, GLuint *fences)
{
    return GL_GenFencesNV(n, fences);
}

void GL_APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
{
    return GL_GetFenceivNV(fence, pname, params);
}

GLboolean GL_APIENTRY glIsFenceNV(GLuint fence)
{
    return GL_IsFenceNV(fence);
}

void GL_APIENTRY glSetFenceNV(GLuint fence, GLenum condition)
{
    return GL_SetFenceNV(fence, condition);
}

GLboolean GL_APIENTRY glTestFenceNV(GLuint fence)
{
    return GL_TestFenceNV(fence);
}

// GL_NV_framebuffer_blit
void GL_APIENTRY glBlitFramebufferNV(GLint srcX0,
                                     GLint srcY0,
                                     GLint srcX1,
                                     GLint srcY1,
                                     GLint dstX0,
                                     GLint dstY0,
                                     GLint dstX1,
                                     GLint dstY1,
                                     GLbitfield mask,
                                     GLenum filter)
{
    return GL_BlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
                                filter);
}

// GL_OES_EGL_image
void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
{
    return GL_EGLImageTargetRenderbufferStorageOES(target, image);
}

void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
{
    return GL_EGLImageTargetTexture2DOES(target, image);
}

// GL_OES_compressed_ETC1_RGB8_texture

// GL_OES_copy_image
void GL_APIENTRY glCopyImageSubDataOES(GLuint srcName,
                                       GLenum srcTarget,
                                       GLint srcLevel,
                                       GLint srcX,
                                       GLint srcY,
                                       GLint srcZ,
                                       GLuint dstName,
                                       GLenum dstTarget,
                                       GLint dstLevel,
                                       GLint dstX,
                                       GLint dstY,
                                       GLint dstZ,
                                       GLsizei srcWidth,
                                       GLsizei srcHeight,
                                       GLsizei srcDepth)
{
    return GL_CopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
                                  dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                  srcDepth);
}

// GL_OES_depth32

// GL_OES_draw_buffers_indexed
void GL_APIENTRY glBlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
    return GL_BlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationiOES(GLuint buf, GLenum mode)
{
    return GL_BlendEquationiOES(buf, mode);
}

void GL_APIENTRY
glBlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
    return GL_BlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFunciOES(GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunciOES(buf, src, dst);
}

void GL_APIENTRY glColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
    return GL_ColorMaskiOES(index, r, g, b, a);
}

void GL_APIENTRY glDisableiOES(GLenum target, GLuint index)
{
    return GL_DisableiOES(target, index);
}

void GL_APIENTRY glEnableiOES(GLenum target, GLuint index)
{
    return GL_EnableiOES(target, index);
}

GLboolean GL_APIENTRY glIsEnablediOES(GLenum target, GLuint index)
{
    return GL_IsEnablediOES(target, index);
}

// GL_OES_draw_elements_base_vertex
void GL_APIENTRY glDrawElementsBaseVertexOES(GLenum mode,
                                             GLsizei count,
                                             GLenum type,
                                             const void *indices,
                                             GLint basevertex)
{
    return GL_DrawElementsBaseVertexOES(mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexOES(GLenum mode,
                                                      GLsizei count,
                                                      GLenum type,
                                                      const void *indices,
                                                      GLsizei instancecount,
                                                      GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount,
                                                 basevertex);
}

void GL_APIENTRY glDrawRangeElementsBaseVertexOES(GLenum mode,
                                                  GLuint start,
                                                  GLuint end,
                                                  GLsizei count,
                                                  GLenum type,
                                                  const void *indices,
                                                  GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex);
}

// GL_OES_draw_texture
void GL_APIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
{
    return GL_DrawTexfOES(x, y, z, width, height);
}

void GL_APIENTRY glDrawTexfvOES(const GLfloat *coords)
{
    return GL_DrawTexfvOES(coords);
}

void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
{
    return GL_DrawTexiOES(x, y, z, width, height);
}

void GL_APIENTRY glDrawTexivOES(const GLint *coords)
{
    return GL_DrawTexivOES(coords);
}

void GL_APIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
{
    return GL_DrawTexsOES(x, y, z, width, height);
}

void GL_APIENTRY glDrawTexsvOES(const GLshort *coords)
{
    return GL_DrawTexsvOES(coords);
}

void GL_APIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
{
    return GL_DrawTexxOES(x, y, z, width, height);
}

void GL_APIENTRY glDrawTexxvOES(const GLfixed *coords)
{
    return GL_DrawTexxvOES(coords);
}

// GL_OES_framebuffer_object
void GL_APIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer)
{
    return GL_BindFramebufferOES(target, framebuffer);
}

void GL_APIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
{
    return GL_BindRenderbufferOES(target, renderbuffer);
}

GLenum GL_APIENTRY glCheckFramebufferStatusOES(GLenum target)
{
    return GL_CheckFramebufferStatusOES(target);
}

void GL_APIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
{
    return GL_DeleteFramebuffersOES(n, framebuffers);
}

void GL_APIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
{
    return GL_DeleteRenderbuffersOES(n, renderbuffers);
}

void GL_APIENTRY glFramebufferRenderbufferOES(GLenum target,
                                              GLenum attachment,
                                              GLenum renderbuffertarget,
                                              GLuint renderbuffer)
{
    return GL_FramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
}

void GL_APIENTRY glFramebufferTexture2DOES(GLenum target,
                                           GLenum attachment,
                                           GLenum textarget,
                                           GLuint texture,
                                           GLint level)
{
    return GL_FramebufferTexture2DOES(target, attachment, textarget, texture, level);
}

void GL_APIENTRY glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
{
    return GL_GenFramebuffersOES(n, framebuffers);
}

void GL_APIENTRY glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
{
    return GL_GenRenderbuffersOES(n, renderbuffers);
}

void GL_APIENTRY glGenerateMipmapOES(GLenum target)
{
    return GL_GenerateMipmapOES(target);
}

void GL_APIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target,
                                                          GLenum attachment,
                                                          GLenum pname,
                                                          GLint *params)
{
    return GL_GetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
}

void GL_APIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetRenderbufferParameterivOES(target, pname, params);
}

GLboolean GL_APIENTRY glIsFramebufferOES(GLuint framebuffer)
{
    return GL_IsFramebufferOES(framebuffer);
}

GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer)
{
    return GL_IsRenderbufferOES(renderbuffer);
}

void GL_APIENTRY glRenderbufferStorageOES(GLenum target,
                                          GLenum internalformat,
                                          GLsizei width,
                                          GLsizei height)
{
    return GL_RenderbufferStorageOES(target, internalformat, width, height);
}

// GL_OES_get_program_binary
void GL_APIENTRY glGetProgramBinaryOES(GLuint program,
                                       GLsizei bufSize,
                                       GLsizei *length,
                                       GLenum *binaryFormat,
                                       void *binary)
{
    return GL_GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
}

void GL_APIENTRY glProgramBinaryOES(GLuint program,
                                    GLenum binaryFormat,
                                    const void *binary,
                                    GLint length)
{
    return GL_ProgramBinaryOES(program, binaryFormat, binary, length);
}

// GL_OES_mapbuffer
void GL_APIENTRY glGetBufferPointervOES(GLenum target, GLenum pname, void **params)
{
    return GL_GetBufferPointervOES(target, pname, params);
}

void *GL_APIENTRY glMapBufferOES(GLenum target, GLenum access)
{
    return GL_MapBufferOES(target, access);
}

GLboolean GL_APIENTRY glUnmapBufferOES(GLenum target)
{
    return GL_UnmapBufferOES(target);
}

// GL_OES_matrix_palette
void GL_APIENTRY glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
{
    return GL_CurrentPaletteMatrixOES(matrixpaletteindex);
}

void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES()
{
    return GL_LoadPaletteFromModelViewMatrixOES();
}

void GL_APIENTRY glMatrixIndexPointerOES(GLint size,
                                         GLenum type,
                                         GLsizei stride,
                                         const void *pointer)
{
    return GL_MatrixIndexPointerOES(size, type, stride, pointer);
}

void GL_APIENTRY glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return GL_WeightPointerOES(size, type, stride, pointer);
}

// GL_OES_point_size_array
void GL_APIENTRY glPointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
{
    return GL_PointSizePointerOES(type, stride, pointer);
}

// GL_OES_query_matrix
GLbitfield GL_APIENTRY glQueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
{
    return GL_QueryMatrixxOES(mantissa, exponent);
}

// GL_OES_sample_shading
void GL_APIENTRY glMinSampleShadingOES(GLfloat value)
{
    return GL_MinSampleShadingOES(value);
}

// GL_OES_shader_io_blocks

// GL_OES_texture_3D
void GL_APIENTRY glCompressedTexImage3DOES(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth,
                                           GLint border,
                                           GLsizei imageSize,
                                           const void *data)
{
    return GL_CompressedTexImage3DOES(target, level, internalformat, width, height, depth, border,
                                      imageSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3DOES(GLenum target,
                                              GLint level,
                                              GLint xoffset,
                                              GLint yoffset,
                                              GLint zoffset,
                                              GLsizei width,
                                              GLsizei height,
                                              GLsizei depth,
                                              GLenum format,
                                              GLsizei imageSize,
                                              const void *data)
{
    return GL_CompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height,
                                         depth, format, imageSize, data);
}

void GL_APIENTRY glCopyTexSubImage3DOES(GLenum target,
                                        GLint level,
                                        GLint xoffset,
                                        GLint yoffset,
                                        GLint zoffset,
                                        GLint x,
                                        GLint y,
                                        GLsizei width,
                                        GLsizei height)
{
    return GL_CopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void GL_APIENTRY glFramebufferTexture3DOES(GLenum target,
                                           GLenum attachment,
                                           GLenum textarget,
                                           GLuint texture,
                                           GLint level,
                                           GLint zoffset)
{
    return GL_FramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
}

void GL_APIENTRY glTexImage3DOES(GLenum target,
                                 GLint level,
                                 GLenum internalformat,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLint border,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
{
    return GL_TexImage3DOES(target, level, internalformat, width, height, depth, border, format,
                            type, pixels);
}

void GL_APIENTRY glTexSubImage3DOES(GLenum target,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLint zoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLenum format,
                                    GLenum type,
                                    const void *pixels)
{
    return GL_TexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth,
                               format, type, pixels);
}

// GL_OES_texture_border_clamp
void GL_APIENTRY glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
{
    return GL_GetSamplerParameterIivOES(sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
{
    return GL_GetSamplerParameterIuivOES(sampler, pname, params);
}

void GL_APIENTRY glGetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
{
    return GL_GetTexParameterIivOES(target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
{
    return GL_GetTexParameterIuivOES(target, pname, params);
}

void GL_APIENTRY glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
{
    return GL_SamplerParameterIivOES(sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
{
    return GL_SamplerParameterIuivOES(sampler, pname, param);
}

void GL_APIENTRY glTexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
{
    return GL_TexParameterIivOES(target, pname, params);
}

void GL_APIENTRY glTexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
{
    return GL_TexParameterIuivOES(target, pname, params);
}

// GL_OES_texture_buffer
void GL_APIENTRY glTexBufferOES(GLenum target, GLenum internalformat, GLuint buffer)
{
    return GL_TexBufferOES(target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferRangeOES(GLenum target,
                                     GLenum internalformat,
                                     GLuint buffer,
                                     GLintptr offset,
                                     GLsizeiptr size)
{
    return GL_TexBufferRangeOES(target, internalformat, buffer, offset, size);
}

// GL_OES_texture_cube_map
void GL_APIENTRY glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
{
    return GL_GetTexGenfvOES(coord, pname, params);
}

void GL_APIENTRY glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
{
    return GL_GetTexGenivOES(coord, pname, params);
}

void GL_APIENTRY glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
{
    return GL_GetTexGenxvOES(coord, pname, params);
}

void GL_APIENTRY glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
{
    return GL_TexGenfOES(coord, pname, param);
}

void GL_APIENTRY glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
{
    return GL_TexGenfvOES(coord, pname, params);
}

void GL_APIENTRY glTexGeniOES(GLenum coord, GLenum pname, GLint param)
{
    return GL_TexGeniOES(coord, pname, param);
}

void GL_APIENTRY glTexGenivOES(GLenum coord, GLenum pname, const GLint *params)
{
    return GL_TexGenivOES(coord, pname, params);
}

void GL_APIENTRY glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
{
    return GL_TexGenxOES(coord, pname, param);
}

void GL_APIENTRY glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
{
    return GL_TexGenxvOES(coord, pname, params);
}

// GL_OES_texture_cube_map_array

// GL_OES_texture_half_float

// GL_OES_texture_stencil8

// GL_OES_texture_storage_multisample_2d_array
void GL_APIENTRY glTexStorage3DMultisampleOES(GLenum target,
                                              GLsizei samples,
                                              GLenum internalformat,
                                              GLsizei width,
                                              GLsizei height,
                                              GLsizei depth,
                                              GLboolean fixedsamplelocations)
{
    return GL_TexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth,
                                         fixedsamplelocations);
}

// GL_OES_vertex_array_object
void GL_APIENTRY glBindVertexArrayOES(GLuint array)
{
    return GL_BindVertexArrayOES(array);
}

void GL_APIENTRY glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
{
    return GL_DeleteVertexArraysOES(n, arrays);
}

void GL_APIENTRY glGenVertexArraysOES(GLsizei n, GLuint *arrays)
{
    return GL_GenVertexArraysOES(n, arrays);
}

GLboolean GL_APIENTRY glIsVertexArrayOES(GLuint array)
{
    return GL_IsVertexArrayOES(array);
}

// GL_OVR_multiview
void GL_APIENTRY glFramebufferTextureMultiviewOVR(GLenum target,
                                                  GLenum attachment,
                                                  GLuint texture,
                                                  GLint level,
                                                  GLint baseViewIndex,
                                                  GLsizei numViews)
{
    return GL_FramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex,
                                             numViews);
}

// GL_OVR_multiview2

// EGL_ANGLE_explicit_context
void GL_APIENTRY glActiveShaderProgramContextANGLE(GLeglContext ctx,
                                                   GLuint pipeline,
                                                   GLuint program)
{
    return GL_ActiveShaderProgramContextANGLE(ctx, pipeline, program);
}

void GL_APIENTRY glActiveShaderProgramEXTContextANGLE(GLeglContext ctx,
                                                      GLuint pipeline,
                                                      GLuint program)
{
    return GL_ActiveShaderProgramEXTContextANGLE(ctx, pipeline, program);
}

void GL_APIENTRY glActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
{
    return GL_ActiveTextureContextANGLE(ctx, texture);
}

void GL_APIENTRY glAlphaFuncContextANGLE(GLeglContext ctx, GLenum func, GLfloat ref)
{
    return GL_AlphaFuncContextANGLE(ctx, func, ref);
}

void GL_APIENTRY glAlphaFuncxContextANGLE(GLeglContext ctx, GLenum func, GLfixed ref)
{
    return GL_AlphaFuncxContextANGLE(ctx, func, ref);
}

void GL_APIENTRY glAttachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
{
    return GL_AttachShaderContextANGLE(ctx, program, shader);
}

void GL_APIENTRY glBeginQueryContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
{
    return GL_BeginQueryContextANGLE(ctx, target, id);
}

void GL_APIENTRY glBeginQueryEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
{
    return GL_BeginQueryEXTContextANGLE(ctx, target, id);
}

void GL_APIENTRY glBeginTransformFeedbackContextANGLE(GLeglContext ctx, GLenum primitiveMode)
{
    return GL_BeginTransformFeedbackContextANGLE(ctx, primitiveMode);
}

void GL_APIENTRY glBindAttribLocationContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLuint index,
                                                  const GLchar *name)
{
    return GL_BindAttribLocationContextANGLE(ctx, program, index, name);
}

void GL_APIENTRY glBindBufferContextANGLE(GLeglContext ctx, GLenum target, GLuint buffer)
{
    return GL_BindBufferContextANGLE(ctx, target, buffer);
}

void GL_APIENTRY glBindBufferBaseContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLuint index,
                                              GLuint buffer)
{
    return GL_BindBufferBaseContextANGLE(ctx, target, index, buffer);
}

void GL_APIENTRY glBindBufferRangeContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLuint index,
                                               GLuint buffer,
                                               GLintptr offset,
                                               GLsizeiptr size)
{
    return GL_BindBufferRangeContextANGLE(ctx, target, index, buffer, offset, size);
}

void GL_APIENTRY glBindFragDataLocationEXTContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLuint color,
                                                       const GLchar *name)
{
    return GL_BindFragDataLocationEXTContextANGLE(ctx, program, color, name);
}

void GL_APIENTRY glBindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,
                                                              GLuint program,
                                                              GLuint colorNumber,
                                                              GLuint index,
                                                              const GLchar *name)
{
    return GL_BindFragDataLocationIndexedEXTContextANGLE(ctx, program, colorNumber, index, name);
}

void GL_APIENTRY glBindFramebufferContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
{
    return GL_BindFramebufferContextANGLE(ctx, target, framebuffer);
}

void GL_APIENTRY glBindFramebufferOESContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLuint framebuffer)
{
    return GL_BindFramebufferOESContextANGLE(ctx, target, framebuffer);
}

void GL_APIENTRY glBindImageTextureContextANGLE(GLeglContext ctx,
                                                GLuint unit,
                                                GLuint texture,
                                                GLint level,
                                                GLboolean layered,
                                                GLint layer,
                                                GLenum access,
                                                GLenum format)
{
    return GL_BindImageTextureContextANGLE(ctx, unit, texture, level, layered, layer, access,
                                           format);
}

void GL_APIENTRY glBindProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_BindProgramPipelineContextANGLE(ctx, pipeline);
}

void GL_APIENTRY glBindProgramPipelineEXTContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_BindProgramPipelineEXTContextANGLE(ctx, pipeline);
}

void GL_APIENTRY glBindRenderbufferContextANGLE(GLeglContext ctx,
                                                GLenum target,
                                                GLuint renderbuffer)
{
    return GL_BindRenderbufferContextANGLE(ctx, target, renderbuffer);
}

void GL_APIENTRY glBindRenderbufferOESContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLuint renderbuffer)
{
    return GL_BindRenderbufferOESContextANGLE(ctx, target, renderbuffer);
}

void GL_APIENTRY glBindSamplerContextANGLE(GLeglContext ctx, GLuint unit, GLuint sampler)
{
    return GL_BindSamplerContextANGLE(ctx, unit, sampler);
}

void GL_APIENTRY glBindTextureContextANGLE(GLeglContext ctx, GLenum target, GLuint texture)
{
    return GL_BindTextureContextANGLE(ctx, target, texture);
}

void GL_APIENTRY glBindTransformFeedbackContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
{
    return GL_BindTransformFeedbackContextANGLE(ctx, target, id);
}

void GL_APIENTRY glBindVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
{
    return GL_BindVertexArrayContextANGLE(ctx, array);
}

void GL_APIENTRY glBindVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
{
    return GL_BindVertexArrayOESContextANGLE(ctx, array);
}

void GL_APIENTRY glBindVertexBufferContextANGLE(GLeglContext ctx,
                                                GLuint bindingindex,
                                                GLuint buffer,
                                                GLintptr offset,
                                                GLsizei stride)
{
    return GL_BindVertexBufferContextANGLE(ctx, bindingindex, buffer, offset, stride);
}

void GL_APIENTRY glBlendBarrierContextANGLE(GLeglContext ctx)
{
    return GL_BlendBarrierContextANGLE(ctx);
}

void GL_APIENTRY glBlendBarrierKHRContextANGLE(GLeglContext ctx)
{
    return GL_BlendBarrierKHRContextANGLE(ctx);
}

void GL_APIENTRY
glBlendColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_BlendColorContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY glBlendEquationContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_BlendEquationContextANGLE(ctx, mode);
}

void GL_APIENTRY glBlendEquationSeparateContextANGLE(GLeglContext ctx,
                                                     GLenum modeRGB,
                                                     GLenum modeAlpha)
{
    return GL_BlendEquationSeparateContextANGLE(ctx, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationSeparateiContextANGLE(GLeglContext ctx,
                                                      GLuint buf,
                                                      GLenum modeRGB,
                                                      GLenum modeAlpha)
{
    return GL_BlendEquationSeparateiContextANGLE(ctx, buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationSeparateiEXTContextANGLE(GLeglContext ctx,
                                                         GLuint buf,
                                                         GLenum modeRGB,
                                                         GLenum modeAlpha)
{
    return GL_BlendEquationSeparateiEXTContextANGLE(ctx, buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationSeparateiOESContextANGLE(GLeglContext ctx,
                                                         GLuint buf,
                                                         GLenum modeRGB,
                                                         GLenum modeAlpha)
{
    return GL_BlendEquationSeparateiOESContextANGLE(ctx, buf, modeRGB, modeAlpha);
}

void GL_APIENTRY glBlendEquationiContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
{
    return GL_BlendEquationiContextANGLE(ctx, buf, mode);
}

void GL_APIENTRY glBlendEquationiEXTContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
{
    return GL_BlendEquationiEXTContextANGLE(ctx, buf, mode);
}

void GL_APIENTRY glBlendEquationiOESContextANGLE(GLeglContext ctx, GLuint buf, GLenum mode)
{
    return GL_BlendEquationiOESContextANGLE(ctx, buf, mode);
}

void GL_APIENTRY glBlendFuncContextANGLE(GLeglContext ctx, GLenum sfactor, GLenum dfactor)
{
    return GL_BlendFuncContextANGLE(ctx, sfactor, dfactor);
}

void GL_APIENTRY glBlendFuncSeparateContextANGLE(GLeglContext ctx,
                                                 GLenum sfactorRGB,
                                                 GLenum dfactorRGB,
                                                 GLenum sfactorAlpha,
                                                 GLenum dfactorAlpha)
{
    return GL_BlendFuncSeparateContextANGLE(ctx, sfactorRGB, dfactorRGB, sfactorAlpha,
                                            dfactorAlpha);
}

void GL_APIENTRY glBlendFuncSeparateiContextANGLE(GLeglContext ctx,
                                                  GLuint buf,
                                                  GLenum srcRGB,
                                                  GLenum dstRGB,
                                                  GLenum srcAlpha,
                                                  GLenum dstAlpha)
{
    return GL_BlendFuncSeparateiContextANGLE(ctx, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFuncSeparateiEXTContextANGLE(GLeglContext ctx,
                                                     GLuint buf,
                                                     GLenum srcRGB,
                                                     GLenum dstRGB,
                                                     GLenum srcAlpha,
                                                     GLenum dstAlpha)
{
    return GL_BlendFuncSeparateiEXTContextANGLE(ctx, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFuncSeparateiOESContextANGLE(GLeglContext ctx,
                                                     GLuint buf,
                                                     GLenum srcRGB,
                                                     GLenum dstRGB,
                                                     GLenum srcAlpha,
                                                     GLenum dstAlpha)
{
    return GL_BlendFuncSeparateiOESContextANGLE(ctx, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GL_APIENTRY glBlendFunciContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunciContextANGLE(ctx, buf, src, dst);
}

void GL_APIENTRY glBlendFunciEXTContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunciEXTContextANGLE(ctx, buf, src, dst);
}

void GL_APIENTRY glBlendFunciOESContextANGLE(GLeglContext ctx, GLuint buf, GLenum src, GLenum dst)
{
    return GL_BlendFunciOESContextANGLE(ctx, buf, src, dst);
}

void GL_APIENTRY glBlitFramebufferContextANGLE(GLeglContext ctx,
                                               GLint srcX0,
                                               GLint srcY0,
                                               GLint srcX1,
                                               GLint srcY1,
                                               GLint dstX0,
                                               GLint dstY0,
                                               GLint dstX1,
                                               GLint dstY1,
                                               GLbitfield mask,
                                               GLenum filter)
{
    return GL_BlitFramebufferContextANGLE(ctx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                                          dstY1, mask, filter);
}

void GL_APIENTRY glBlitFramebufferANGLEContextANGLE(GLeglContext ctx,
                                                    GLint srcX0,
                                                    GLint srcY0,
                                                    GLint srcX1,
                                                    GLint srcY1,
                                                    GLint dstX0,
                                                    GLint dstY0,
                                                    GLint dstX1,
                                                    GLint dstY1,
                                                    GLbitfield mask,
                                                    GLenum filter)
{
    return GL_BlitFramebufferANGLEContextANGLE(ctx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                                               dstY1, mask, filter);
}

void GL_APIENTRY glBlitFramebufferNVContextANGLE(GLeglContext ctx,
                                                 GLint srcX0,
                                                 GLint srcY0,
                                                 GLint srcX1,
                                                 GLint srcY1,
                                                 GLint dstX0,
                                                 GLint dstY0,
                                                 GLint dstX1,
                                                 GLint dstY1,
                                                 GLbitfield mask,
                                                 GLenum filter)
{
    return GL_BlitFramebufferNVContextANGLE(ctx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
                                            dstY1, mask, filter);
}

void GL_APIENTRY glBufferDataContextANGLE(GLeglContext ctx,
                                          GLenum target,
                                          GLsizeiptr size,
                                          const void *data,
                                          GLenum usage)
{
    return GL_BufferDataContextANGLE(ctx, target, size, data, usage);
}

void GL_APIENTRY glBufferStorageEXTContextANGLE(GLeglContext ctx,
                                                GLenum target,
                                                GLsizeiptr size,
                                                const void *data,
                                                GLbitfield flags)
{
    return GL_BufferStorageEXTContextANGLE(ctx, target, size, data, flags);
}

void GL_APIENTRY glBufferStorageExternalEXTContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLintptr offset,
                                                        GLsizeiptr size,
                                                        GLeglClientBufferEXT clientBuffer,
                                                        GLbitfield flags)
{
    return GL_BufferStorageExternalEXTContextANGLE(ctx, target, offset, size, clientBuffer, flags);
}

void GL_APIENTRY glBufferStorageMemEXTContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLsizeiptr size,
                                                   GLuint memory,
                                                   GLuint64 offset)
{
    return GL_BufferStorageMemEXTContextANGLE(ctx, target, size, memory, offset);
}

void GL_APIENTRY glBufferSubDataContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLintptr offset,
                                             GLsizeiptr size,
                                             const void *data)
{
    return GL_BufferSubDataContextANGLE(ctx, target, offset, size, data);
}

GLenum GL_APIENTRY glCheckFramebufferStatusContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_CheckFramebufferStatusContextANGLE(ctx, target);
}

GLenum GL_APIENTRY glCheckFramebufferStatusOESContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_CheckFramebufferStatusOESContextANGLE(ctx, target);
}

void GL_APIENTRY glClearContextANGLE(GLeglContext ctx, GLbitfield mask)
{
    return GL_ClearContextANGLE(ctx, mask);
}

void GL_APIENTRY glClearBufferfiContextANGLE(GLeglContext ctx,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             GLfloat depth,
                                             GLint stencil)
{
    return GL_ClearBufferfiContextANGLE(ctx, buffer, drawbuffer, depth, stencil);
}

void GL_APIENTRY glClearBufferfvContextANGLE(GLeglContext ctx,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             const GLfloat *value)
{
    return GL_ClearBufferfvContextANGLE(ctx, buffer, drawbuffer, value);
}

void GL_APIENTRY glClearBufferivContextANGLE(GLeglContext ctx,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             const GLint *value)
{
    return GL_ClearBufferivContextANGLE(ctx, buffer, drawbuffer, value);
}

void GL_APIENTRY glClearBufferuivContextANGLE(GLeglContext ctx,
                                              GLenum buffer,
                                              GLint drawbuffer,
                                              const GLuint *value)
{
    return GL_ClearBufferuivContextANGLE(ctx, buffer, drawbuffer, value);
}

void GL_APIENTRY
glClearColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_ClearColorContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY
glClearColorxContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
    return GL_ClearColorxContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY glClearDepthfContextANGLE(GLeglContext ctx, GLfloat d)
{
    return GL_ClearDepthfContextANGLE(ctx, d);
}

void GL_APIENTRY glClearDepthxContextANGLE(GLeglContext ctx, GLfixed depth)
{
    return GL_ClearDepthxContextANGLE(ctx, depth);
}

void GL_APIENTRY glClearStencilContextANGLE(GLeglContext ctx, GLint s)
{
    return GL_ClearStencilContextANGLE(ctx, s);
}

void GL_APIENTRY glClientActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
{
    return GL_ClientActiveTextureContextANGLE(ctx, texture);
}

GLenum GL_APIENTRY glClientWaitSyncContextANGLE(GLeglContext ctx,
                                                GLsync sync,
                                                GLbitfield flags,
                                                GLuint64 timeout)
{
    return GL_ClientWaitSyncContextANGLE(ctx, sync, flags, timeout);
}

void GL_APIENTRY glClipControlEXTContextANGLE(GLeglContext ctx, GLenum origin, GLenum depth)
{
    return GL_ClipControlEXTContextANGLE(ctx, origin, depth);
}

void GL_APIENTRY glClipPlanefContextANGLE(GLeglContext ctx, GLenum p, const GLfloat *eqn)
{
    return GL_ClipPlanefContextANGLE(ctx, p, eqn);
}

void GL_APIENTRY glClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, const GLfixed *equation)
{
    return GL_ClipPlanexContextANGLE(ctx, plane, equation);
}

void GL_APIENTRY
glColor4fContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return GL_Color4fContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY
glColor4ubContextANGLE(GLeglContext ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
    return GL_Color4ubContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY
glColor4xContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
    return GL_Color4xContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY glColorMaskContextANGLE(GLeglContext ctx,
                                         GLboolean red,
                                         GLboolean green,
                                         GLboolean blue,
                                         GLboolean alpha)
{
    return GL_ColorMaskContextANGLE(ctx, red, green, blue, alpha);
}

void GL_APIENTRY glColorMaskiContextANGLE(GLeglContext ctx,
                                          GLuint index,
                                          GLboolean r,
                                          GLboolean g,
                                          GLboolean b,
                                          GLboolean a)
{
    return GL_ColorMaskiContextANGLE(ctx, index, r, g, b, a);
}

void GL_APIENTRY glColorMaskiEXTContextANGLE(GLeglContext ctx,
                                             GLuint index,
                                             GLboolean r,
                                             GLboolean g,
                                             GLboolean b,
                                             GLboolean a)
{
    return GL_ColorMaskiEXTContextANGLE(ctx, index, r, g, b, a);
}

void GL_APIENTRY glColorMaskiOESContextANGLE(GLeglContext ctx,
                                             GLuint index,
                                             GLboolean r,
                                             GLboolean g,
                                             GLboolean b,
                                             GLboolean a)
{
    return GL_ColorMaskiOESContextANGLE(ctx, index, r, g, b, a);
}

void GL_APIENTRY glColorPointerContextANGLE(GLeglContext ctx,
                                            GLint size,
                                            GLenum type,
                                            GLsizei stride,
                                            const void *pointer)
{
    return GL_ColorPointerContextANGLE(ctx, size, type, stride, pointer);
}

void GL_APIENTRY glCompileShaderContextANGLE(GLeglContext ctx, GLuint shader)
{
    return GL_CompileShaderContextANGLE(ctx, shader);
}

void GL_APIENTRY glCompressedTexImage2DContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLint border,
                                                    GLsizei imageSize,
                                                    const void *data)
{
    return GL_CompressedTexImage2DContextANGLE(ctx, target, level, internalformat, width, height,
                                               border, imageSize, data);
}

void GL_APIENTRY glCompressedTexImage3DContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLsizei depth,
                                                    GLint border,
                                                    GLsizei imageSize,
                                                    const void *data)
{
    return GL_CompressedTexImage3DContextANGLE(ctx, target, level, internalformat, width, height,
                                               depth, border, imageSize, data);
}

void GL_APIENTRY glCompressedTexImage3DOESContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLint level,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLint border,
                                                       GLsizei imageSize,
                                                       const void *data)
{
    return GL_CompressedTexImage3DOESContextANGLE(ctx, target, level, internalformat, width, height,
                                                  depth, border, imageSize, data);
}

void GL_APIENTRY glCompressedTexSubImage2DContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLenum format,
                                                       GLsizei imageSize,
                                                       const void *data)
{
    return GL_CompressedTexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, width,
                                                  height, format, imageSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3DContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLint zoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLenum format,
                                                       GLsizei imageSize,
                                                       const void *data)
{
    return GL_CompressedTexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
                                                  width, height, depth, format, imageSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLint level,
                                                          GLint xoffset,
                                                          GLint yoffset,
                                                          GLint zoffset,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth,
                                                          GLenum format,
                                                          GLsizei imageSize,
                                                          const void *data)
{
    return GL_CompressedTexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
                                                     width, height, depth, format, imageSize, data);
}

void GL_APIENTRY glCopyBufferSubDataContextANGLE(GLeglContext ctx,
                                                 GLenum readTarget,
                                                 GLenum writeTarget,
                                                 GLintptr readOffset,
                                                 GLintptr writeOffset,
                                                 GLsizeiptr size)
{
    return GL_CopyBufferSubDataContextANGLE(ctx, readTarget, writeTarget, readOffset, writeOffset,
                                            size);
}

void GL_APIENTRY glCopyImageSubDataContextANGLE(GLeglContext ctx,
                                                GLuint srcName,
                                                GLenum srcTarget,
                                                GLint srcLevel,
                                                GLint srcX,
                                                GLint srcY,
                                                GLint srcZ,
                                                GLuint dstName,
                                                GLenum dstTarget,
                                                GLint dstLevel,
                                                GLint dstX,
                                                GLint dstY,
                                                GLint dstZ,
                                                GLsizei srcWidth,
                                                GLsizei srcHeight,
                                                GLsizei srcDepth)
{
    return GL_CopyImageSubDataContextANGLE(ctx, srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
                                           dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth,
                                           srcHeight, srcDepth);
}

void GL_APIENTRY glCopyImageSubDataEXTContextANGLE(GLeglContext ctx,
                                                   GLuint srcName,
                                                   GLenum srcTarget,
                                                   GLint srcLevel,
                                                   GLint srcX,
                                                   GLint srcY,
                                                   GLint srcZ,
                                                   GLuint dstName,
                                                   GLenum dstTarget,
                                                   GLint dstLevel,
                                                   GLint dstX,
                                                   GLint dstY,
                                                   GLint dstZ,
                                                   GLsizei srcWidth,
                                                   GLsizei srcHeight,
                                                   GLsizei srcDepth)
{
    return GL_CopyImageSubDataEXTContextANGLE(ctx, srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
                                              dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
                                              srcWidth, srcHeight, srcDepth);
}

void GL_APIENTRY glCopyImageSubDataOESContextANGLE(GLeglContext ctx,
                                                   GLuint srcName,
                                                   GLenum srcTarget,
                                                   GLint srcLevel,
                                                   GLint srcX,
                                                   GLint srcY,
                                                   GLint srcZ,
                                                   GLuint dstName,
                                                   GLenum dstTarget,
                                                   GLint dstLevel,
                                                   GLint dstX,
                                                   GLint dstY,
                                                   GLint dstZ,
                                                   GLsizei srcWidth,
                                                   GLsizei srcHeight,
                                                   GLsizei srcDepth)
{
    return GL_CopyImageSubDataOESContextANGLE(ctx, srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
                                              dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
                                              srcWidth, srcHeight, srcDepth);
}

void GL_APIENTRY glCopyTexImage2DContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLint level,
                                              GLenum internalformat,
                                              GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height,
                                              GLint border)
{
    return GL_CopyTexImage2DContextANGLE(ctx, target, level, internalformat, x, y, width, height,
                                         border);
}

void GL_APIENTRY glCopyTexSubImage2DContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height)
{
    return GL_CopyTexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, x, y, width,
                                            height);
}

void GL_APIENTRY glCopyTexSubImage3DContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLint yoffset,
                                                 GLint zoffset,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height)
{
    return GL_CopyTexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, x, y,
                                            width, height);
}

void GL_APIENTRY glCopyTexSubImage3DOESContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLint level,
                                                    GLint xoffset,
                                                    GLint yoffset,
                                                    GLint zoffset,
                                                    GLint x,
                                                    GLint y,
                                                    GLsizei width,
                                                    GLsizei height)
{
    return GL_CopyTexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, x, y,
                                               width, height);
}

void GL_APIENTRY glCreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,
                                                      GLsizei n,
                                                      GLuint *memoryObjects)
{
    return GL_CreateMemoryObjectsEXTContextANGLE(ctx, n, memoryObjects);
}

GLuint GL_APIENTRY glCreateProgramContextANGLE(GLeglContext ctx)
{
    return GL_CreateProgramContextANGLE(ctx);
}

GLuint GL_APIENTRY glCreateShaderContextANGLE(GLeglContext ctx, GLenum type)
{
    return GL_CreateShaderContextANGLE(ctx, type);
}

GLuint GL_APIENTRY glCreateShaderProgramvContextANGLE(GLeglContext ctx,
                                                      GLenum type,
                                                      GLsizei count,
                                                      const GLchar *const *strings)
{
    return GL_CreateShaderProgramvContextANGLE(ctx, type, count, strings);
}

GLuint GL_APIENTRY glCreateShaderProgramvEXTContextANGLE(GLeglContext ctx,
                                                         GLenum type,
                                                         GLsizei count,
                                                         const GLchar **strings)
{
    return GL_CreateShaderProgramvEXTContextANGLE(ctx, type, count, strings);
}

void GL_APIENTRY glCullFaceContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_CullFaceContextANGLE(ctx, mode);
}

void GL_APIENTRY glCurrentPaletteMatrixOESContextANGLE(GLeglContext ctx, GLuint matrixpaletteindex)
{
    return GL_CurrentPaletteMatrixOESContextANGLE(ctx, matrixpaletteindex);
}

void GL_APIENTRY glDebugMessageCallbackContextANGLE(GLeglContext ctx,
                                                    GLDEBUGPROC callback,
                                                    const void *userParam)
{
    return GL_DebugMessageCallbackContextANGLE(ctx, callback, userParam);
}

void GL_APIENTRY glDebugMessageCallbackKHRContextANGLE(GLeglContext ctx,
                                                       GLDEBUGPROCKHR callback,
                                                       const void *userParam)
{
    return GL_DebugMessageCallbackKHRContextANGLE(ctx, callback, userParam);
}

void GL_APIENTRY glDebugMessageControlContextANGLE(GLeglContext ctx,
                                                   GLenum source,
                                                   GLenum type,
                                                   GLenum severity,
                                                   GLsizei count,
                                                   const GLuint *ids,
                                                   GLboolean enabled)
{
    return GL_DebugMessageControlContextANGLE(ctx, source, type, severity, count, ids, enabled);
}

void GL_APIENTRY glDebugMessageControlKHRContextANGLE(GLeglContext ctx,
                                                      GLenum source,
                                                      GLenum type,
                                                      GLenum severity,
                                                      GLsizei count,
                                                      const GLuint *ids,
                                                      GLboolean enabled)
{
    return GL_DebugMessageControlKHRContextANGLE(ctx, source, type, severity, count, ids, enabled);
}

void GL_APIENTRY glDebugMessageInsertContextANGLE(GLeglContext ctx,
                                                  GLenum source,
                                                  GLenum type,
                                                  GLuint id,
                                                  GLenum severity,
                                                  GLsizei length,
                                                  const GLchar *buf)
{
    return GL_DebugMessageInsertContextANGLE(ctx, source, type, id, severity, length, buf);
}

void GL_APIENTRY glDebugMessageInsertKHRContextANGLE(GLeglContext ctx,
                                                     GLenum source,
                                                     GLenum type,
                                                     GLuint id,
                                                     GLenum severity,
                                                     GLsizei length,
                                                     const GLchar *buf)
{
    return GL_DebugMessageInsertKHRContextANGLE(ctx, source, type, id, severity, length, buf);
}

void GL_APIENTRY glDeleteBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *buffers)
{
    return GL_DeleteBuffersContextANGLE(ctx, n, buffers);
}

void GL_APIENTRY glDeleteFencesNVContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *fences)
{
    return GL_DeleteFencesNVContextANGLE(ctx, n, fences);
}

void GL_APIENTRY glDeleteFramebuffersContextANGLE(GLeglContext ctx,
                                                  GLsizei n,
                                                  const GLuint *framebuffers)
{
    return GL_DeleteFramebuffersContextANGLE(ctx, n, framebuffers);
}

void GL_APIENTRY glDeleteFramebuffersOESContextANGLE(GLeglContext ctx,
                                                     GLsizei n,
                                                     const GLuint *framebuffers)
{
    return GL_DeleteFramebuffersOESContextANGLE(ctx, n, framebuffers);
}

void GL_APIENTRY glDeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,
                                                      GLsizei n,
                                                      const GLuint *memoryObjects)
{
    return GL_DeleteMemoryObjectsEXTContextANGLE(ctx, n, memoryObjects);
}

void GL_APIENTRY glDeleteProgramContextANGLE(GLeglContext ctx, GLuint program)
{
    return GL_DeleteProgramContextANGLE(ctx, program);
}

void GL_APIENTRY glDeleteProgramPipelinesContextANGLE(GLeglContext ctx,
                                                      GLsizei n,
                                                      const GLuint *pipelines)
{
    return GL_DeleteProgramPipelinesContextANGLE(ctx, n, pipelines);
}

void GL_APIENTRY glDeleteProgramPipelinesEXTContextANGLE(GLeglContext ctx,
                                                         GLsizei n,
                                                         const GLuint *pipelines)
{
    return GL_DeleteProgramPipelinesEXTContextANGLE(ctx, n, pipelines);
}

void GL_APIENTRY glDeleteQueriesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
{
    return GL_DeleteQueriesContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glDeleteQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
{
    return GL_DeleteQueriesEXTContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glDeleteRenderbuffersContextANGLE(GLeglContext ctx,
                                                   GLsizei n,
                                                   const GLuint *renderbuffers)
{
    return GL_DeleteRenderbuffersContextANGLE(ctx, n, renderbuffers);
}

void GL_APIENTRY glDeleteRenderbuffersOESContextANGLE(GLeglContext ctx,
                                                      GLsizei n,
                                                      const GLuint *renderbuffers)
{
    return GL_DeleteRenderbuffersOESContextANGLE(ctx, n, renderbuffers);
}

void GL_APIENTRY glDeleteSamplersContextANGLE(GLeglContext ctx,
                                              GLsizei count,
                                              const GLuint *samplers)
{
    return GL_DeleteSamplersContextANGLE(ctx, count, samplers);
}

void GL_APIENTRY glDeleteSemaphoresEXTContextANGLE(GLeglContext ctx,
                                                   GLsizei n,
                                                   const GLuint *semaphores)
{
    return GL_DeleteSemaphoresEXTContextANGLE(ctx, n, semaphores);
}

void GL_APIENTRY glDeleteShaderContextANGLE(GLeglContext ctx, GLuint shader)
{
    return GL_DeleteShaderContextANGLE(ctx, shader);
}

void GL_APIENTRY glDeleteSyncContextANGLE(GLeglContext ctx, GLsync sync)
{
    return GL_DeleteSyncContextANGLE(ctx, sync);
}

void GL_APIENTRY glDeleteTexturesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *textures)
{
    return GL_DeleteTexturesContextANGLE(ctx, n, textures);
}

void GL_APIENTRY glDeleteTransformFeedbacksContextANGLE(GLeglContext ctx,
                                                        GLsizei n,
                                                        const GLuint *ids)
{
    return GL_DeleteTransformFeedbacksContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glDeleteVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *arrays)
{
    return GL_DeleteVertexArraysContextANGLE(ctx, n, arrays);
}

void GL_APIENTRY glDeleteVertexArraysOESContextANGLE(GLeglContext ctx,
                                                     GLsizei n,
                                                     const GLuint *arrays)
{
    return GL_DeleteVertexArraysOESContextANGLE(ctx, n, arrays);
}

void GL_APIENTRY glDepthFuncContextANGLE(GLeglContext ctx, GLenum func)
{
    return GL_DepthFuncContextANGLE(ctx, func);
}

void GL_APIENTRY glDepthMaskContextANGLE(GLeglContext ctx, GLboolean flag)
{
    return GL_DepthMaskContextANGLE(ctx, flag);
}

void GL_APIENTRY glDepthRangefContextANGLE(GLeglContext ctx, GLfloat n, GLfloat f)
{
    return GL_DepthRangefContextANGLE(ctx, n, f);
}

void GL_APIENTRY glDepthRangexContextANGLE(GLeglContext ctx, GLfixed n, GLfixed f)
{
    return GL_DepthRangexContextANGLE(ctx, n, f);
}

void GL_APIENTRY glDetachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
{
    return GL_DetachShaderContextANGLE(ctx, program, shader);
}

void GL_APIENTRY glDisableContextANGLE(GLeglContext ctx, GLenum cap)
{
    return GL_DisableContextANGLE(ctx, cap);
}

void GL_APIENTRY glDisableClientStateContextANGLE(GLeglContext ctx, GLenum array)
{
    return GL_DisableClientStateContextANGLE(ctx, array);
}

void GL_APIENTRY glDisableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
{
    return GL_DisableVertexAttribArrayContextANGLE(ctx, index);
}

void GL_APIENTRY glDisableiContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_DisableiContextANGLE(ctx, target, index);
}

void GL_APIENTRY glDisableiEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_DisableiEXTContextANGLE(ctx, target, index);
}

void GL_APIENTRY glDisableiOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_DisableiOESContextANGLE(ctx, target, index);
}

void GL_APIENTRY glDiscardFramebufferEXTContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLsizei numAttachments,
                                                     const GLenum *attachments)
{
    return GL_DiscardFramebufferEXTContextANGLE(ctx, target, numAttachments, attachments);
}

void GL_APIENTRY glDispatchComputeContextANGLE(GLeglContext ctx,
                                               GLuint num_groups_x,
                                               GLuint num_groups_y,
                                               GLuint num_groups_z)
{
    return GL_DispatchComputeContextANGLE(ctx, num_groups_x, num_groups_y, num_groups_z);
}

void GL_APIENTRY glDispatchComputeIndirectContextANGLE(GLeglContext ctx, GLintptr indirect)
{
    return GL_DispatchComputeIndirectContextANGLE(ctx, indirect);
}

void GL_APIENTRY glDrawArraysContextANGLE(GLeglContext ctx, GLenum mode, GLint first, GLsizei count)
{
    return GL_DrawArraysContextANGLE(ctx, mode, first, count);
}

void GL_APIENTRY glDrawArraysIndirectContextANGLE(GLeglContext ctx,
                                                  GLenum mode,
                                                  const void *indirect)
{
    return GL_DrawArraysIndirectContextANGLE(ctx, mode, indirect);
}

void GL_APIENTRY glDrawArraysInstancedContextANGLE(GLeglContext ctx,
                                                   GLenum mode,
                                                   GLint first,
                                                   GLsizei count,
                                                   GLsizei instancecount)
{
    return GL_DrawArraysInstancedContextANGLE(ctx, mode, first, count, instancecount);
}

void GL_APIENTRY glDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum mode,
                                                        GLint first,
                                                        GLsizei count,
                                                        GLsizei primcount)
{
    return GL_DrawArraysInstancedANGLEContextANGLE(ctx, mode, first, count, primcount);
}

void GL_APIENTRY glDrawArraysInstancedEXTContextANGLE(GLeglContext ctx,
                                                      GLenum mode,
                                                      GLint start,
                                                      GLsizei count,
                                                      GLsizei primcount)
{
    return GL_DrawArraysInstancedEXTContextANGLE(ctx, mode, start, count, primcount);
}

void GL_APIENTRY glDrawBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
{
    return GL_DrawBuffersContextANGLE(ctx, n, bufs);
}

void GL_APIENTRY glDrawBuffersEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
{
    return GL_DrawBuffersEXTContextANGLE(ctx, n, bufs);
}

void GL_APIENTRY glDrawElementsContextANGLE(GLeglContext ctx,
                                            GLenum mode,
                                            GLsizei count,
                                            GLenum type,
                                            const void *indices)
{
    return GL_DrawElementsContextANGLE(ctx, mode, count, type, indices);
}

void GL_APIENTRY glDrawElementsBaseVertexContextANGLE(GLeglContext ctx,
                                                      GLenum mode,
                                                      GLsizei count,
                                                      GLenum type,
                                                      const void *indices,
                                                      GLint basevertex)
{
    return GL_DrawElementsBaseVertexContextANGLE(ctx, mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
                                                         GLenum mode,
                                                         GLsizei count,
                                                         GLenum type,
                                                         const void *indices,
                                                         GLint basevertex)
{
    return GL_DrawElementsBaseVertexEXTContextANGLE(ctx, mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsBaseVertexOESContextANGLE(GLeglContext ctx,
                                                         GLenum mode,
                                                         GLsizei count,
                                                         GLenum type,
                                                         const void *indices,
                                                         GLint basevertex)
{
    return GL_DrawElementsBaseVertexOESContextANGLE(ctx, mode, count, type, indices, basevertex);
}

void GL_APIENTRY glDrawElementsIndirectContextANGLE(GLeglContext ctx,
                                                    GLenum mode,
                                                    GLenum type,
                                                    const void *indirect)
{
    return GL_DrawElementsIndirectContextANGLE(ctx, mode, type, indirect);
}

void GL_APIENTRY glDrawElementsInstancedContextANGLE(GLeglContext ctx,
                                                     GLenum mode,
                                                     GLsizei count,
                                                     GLenum type,
                                                     const void *indices,
                                                     GLsizei instancecount)
{
    return GL_DrawElementsInstancedContextANGLE(ctx, mode, count, type, indices, instancecount);
}

void GL_APIENTRY glDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
                                                          GLenum mode,
                                                          GLsizei count,
                                                          GLenum type,
                                                          const void *indices,
                                                          GLsizei primcount)
{
    return GL_DrawElementsInstancedANGLEContextANGLE(ctx, mode, count, type, indices, primcount);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexContextANGLE(GLeglContext ctx,
                                                               GLenum mode,
                                                               GLsizei count,
                                                               GLenum type,
                                                               const void *indices,
                                                               GLsizei instancecount,
                                                               GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertexContextANGLE(ctx, mode, count, type, indices,
                                                          instancecount, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexEXTContextANGLE(GLeglContext ctx,
                                                                  GLenum mode,
                                                                  GLsizei count,
                                                                  GLenum type,
                                                                  const void *indices,
                                                                  GLsizei instancecount,
                                                                  GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertexEXTContextANGLE(ctx, mode, count, type, indices,
                                                             instancecount, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexOESContextANGLE(GLeglContext ctx,
                                                                  GLenum mode,
                                                                  GLsizei count,
                                                                  GLenum type,
                                                                  const void *indices,
                                                                  GLsizei instancecount,
                                                                  GLint basevertex)
{
    return GL_DrawElementsInstancedBaseVertexOESContextANGLE(ctx, mode, count, type, indices,
                                                             instancecount, basevertex);
}

void GL_APIENTRY glDrawElementsInstancedEXTContextANGLE(GLeglContext ctx,
                                                        GLenum mode,
                                                        GLsizei count,
                                                        GLenum type,
                                                        const void *indices,
                                                        GLsizei primcount)
{
    return GL_DrawElementsInstancedEXTContextANGLE(ctx, mode, count, type, indices, primcount);
}

void GL_APIENTRY glDrawRangeElementsContextANGLE(GLeglContext ctx,
                                                 GLenum mode,
                                                 GLuint start,
                                                 GLuint end,
                                                 GLsizei count,
                                                 GLenum type,
                                                 const void *indices)
{
    return GL_DrawRangeElementsContextANGLE(ctx, mode, start, end, count, type, indices);
}

void GL_APIENTRY glDrawRangeElementsBaseVertexContextANGLE(GLeglContext ctx,
                                                           GLenum mode,
                                                           GLuint start,
                                                           GLuint end,
                                                           GLsizei count,
                                                           GLenum type,
                                                           const void *indices,
                                                           GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertexContextANGLE(ctx, mode, start, end, count, type, indices,
                                                      basevertex);
}

void GL_APIENTRY glDrawRangeElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
                                                              GLenum mode,
                                                              GLuint start,
                                                              GLuint end,
                                                              GLsizei count,
                                                              GLenum type,
                                                              const void *indices,
                                                              GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertexEXTContextANGLE(ctx, mode, start, end, count, type,
                                                         indices, basevertex);
}

void GL_APIENTRY glDrawRangeElementsBaseVertexOESContextANGLE(GLeglContext ctx,
                                                              GLenum mode,
                                                              GLuint start,
                                                              GLuint end,
                                                              GLsizei count,
                                                              GLenum type,
                                                              const void *indices,
                                                              GLint basevertex)
{
    return GL_DrawRangeElementsBaseVertexOESContextANGLE(ctx, mode, start, end, count, type,
                                                         indices, basevertex);
}

void GL_APIENTRY glDrawTexfOESContextANGLE(GLeglContext ctx,
                                           GLfloat x,
                                           GLfloat y,
                                           GLfloat z,
                                           GLfloat width,
                                           GLfloat height)
{
    return GL_DrawTexfOESContextANGLE(ctx, x, y, z, width, height);
}

void GL_APIENTRY glDrawTexfvOESContextANGLE(GLeglContext ctx, const GLfloat *coords)
{
    return GL_DrawTexfvOESContextANGLE(ctx, coords);
}

void GL_APIENTRY
glDrawTexiOESContextANGLE(GLeglContext ctx, GLint x, GLint y, GLint z, GLint width, GLint height)
{
    return GL_DrawTexiOESContextANGLE(ctx, x, y, z, width, height);
}

void GL_APIENTRY glDrawTexivOESContextANGLE(GLeglContext ctx, const GLint *coords)
{
    return GL_DrawTexivOESContextANGLE(ctx, coords);
}

void GL_APIENTRY glDrawTexsOESContextANGLE(GLeglContext ctx,
                                           GLshort x,
                                           GLshort y,
                                           GLshort z,
                                           GLshort width,
                                           GLshort height)
{
    return GL_DrawTexsOESContextANGLE(ctx, x, y, z, width, height);
}

void GL_APIENTRY glDrawTexsvOESContextANGLE(GLeglContext ctx, const GLshort *coords)
{
    return GL_DrawTexsvOESContextANGLE(ctx, coords);
}

void GL_APIENTRY glDrawTexxOESContextANGLE(GLeglContext ctx,
                                           GLfixed x,
                                           GLfixed y,
                                           GLfixed z,
                                           GLfixed width,
                                           GLfixed height)
{
    return GL_DrawTexxOESContextANGLE(ctx, x, y, z, width, height);
}

void GL_APIENTRY glDrawTexxvOESContextANGLE(GLeglContext ctx, const GLfixed *coords)
{
    return GL_DrawTexxvOESContextANGLE(ctx, coords);
}

void GL_APIENTRY glEGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,
                                                                    GLenum target,
                                                                    GLeglImageOES image)
{
    return GL_EGLImageTargetRenderbufferStorageOESContextANGLE(ctx, target, image);
}

void GL_APIENTRY glEGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLeglImageOES image)
{
    return GL_EGLImageTargetTexture2DOESContextANGLE(ctx, target, image);
}

void GL_APIENTRY glEnableContextANGLE(GLeglContext ctx, GLenum cap)
{
    return GL_EnableContextANGLE(ctx, cap);
}

void GL_APIENTRY glEnableClientStateContextANGLE(GLeglContext ctx, GLenum array)
{
    return GL_EnableClientStateContextANGLE(ctx, array);
}

void GL_APIENTRY glEnableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
{
    return GL_EnableVertexAttribArrayContextANGLE(ctx, index);
}

void GL_APIENTRY glEnableiContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_EnableiContextANGLE(ctx, target, index);
}

void GL_APIENTRY glEnableiEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_EnableiEXTContextANGLE(ctx, target, index);
}

void GL_APIENTRY glEnableiOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_EnableiOESContextANGLE(ctx, target, index);
}

void GL_APIENTRY glEndQueryContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_EndQueryContextANGLE(ctx, target);
}

void GL_APIENTRY glEndQueryEXTContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_EndQueryEXTContextANGLE(ctx, target);
}

void GL_APIENTRY glEndTransformFeedbackContextANGLE(GLeglContext ctx)
{
    return GL_EndTransformFeedbackContextANGLE(ctx);
}

GLsync GL_APIENTRY glFenceSyncContextANGLE(GLeglContext ctx, GLenum condition, GLbitfield flags)
{
    return GL_FenceSyncContextANGLE(ctx, condition, flags);
}

void GL_APIENTRY glFinishContextANGLE(GLeglContext ctx)
{
    return GL_FinishContextANGLE(ctx);
}

void GL_APIENTRY glFinishFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
{
    return GL_FinishFenceNVContextANGLE(ctx, fence);
}

void GL_APIENTRY glFlushContextANGLE(GLeglContext ctx)
{
    return GL_FlushContextANGLE(ctx);
}

void GL_APIENTRY glFlushMappedBufferRangeContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLintptr offset,
                                                      GLsizeiptr length)
{
    return GL_FlushMappedBufferRangeContextANGLE(ctx, target, offset, length);
}

void GL_APIENTRY glFlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLintptr offset,
                                                         GLsizeiptr length)
{
    return GL_FlushMappedBufferRangeEXTContextANGLE(ctx, target, offset, length);
}

void GL_APIENTRY glFogfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
{
    return GL_FogfContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glFogfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
{
    return GL_FogfvContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glFogxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
{
    return GL_FogxContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glFogxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
{
    return GL_FogxvContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glFramebufferFetchBarrierEXTContextANGLE(GLeglContext ctx)
{
    return GL_FramebufferFetchBarrierEXTContextANGLE(ctx);
}

void GL_APIENTRY glFramebufferParameteriContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLenum pname,
                                                     GLint param)
{
    return GL_FramebufferParameteriContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glFramebufferRenderbufferContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLenum attachment,
                                                       GLenum renderbuffertarget,
                                                       GLuint renderbuffer)
{
    return GL_FramebufferRenderbufferContextANGLE(ctx, target, attachment, renderbuffertarget,
                                                  renderbuffer);
}

void GL_APIENTRY glFramebufferRenderbufferOESContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLenum attachment,
                                                          GLenum renderbuffertarget,
                                                          GLuint renderbuffer)
{
    return GL_FramebufferRenderbufferOESContextANGLE(ctx, target, attachment, renderbuffertarget,
                                                     renderbuffer);
}

void GL_APIENTRY glFramebufferTextureContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLenum attachment,
                                                  GLuint texture,
                                                  GLint level)
{
    return GL_FramebufferTextureContextANGLE(ctx, target, attachment, texture, level);
}

void GL_APIENTRY glFramebufferTexture2DContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLenum attachment,
                                                    GLenum textarget,
                                                    GLuint texture,
                                                    GLint level)
{
    return GL_FramebufferTexture2DContextANGLE(ctx, target, attachment, textarget, texture, level);
}

void GL_APIENTRY glFramebufferTexture2DMultisampleEXTContextANGLE(GLeglContext ctx,
                                                                  GLenum target,
                                                                  GLenum attachment,
                                                                  GLenum textarget,
                                                                  GLuint texture,
                                                                  GLint level,
                                                                  GLsizei samples)
{
    return GL_FramebufferTexture2DMultisampleEXTContextANGLE(ctx, target, attachment, textarget,
                                                             texture, level, samples);
}

void GL_APIENTRY glFramebufferTexture2DOESContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLenum attachment,
                                                       GLenum textarget,
                                                       GLuint texture,
                                                       GLint level)
{
    return GL_FramebufferTexture2DOESContextANGLE(ctx, target, attachment, textarget, texture,
                                                  level);
}

void GL_APIENTRY glFramebufferTexture3DOESContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLenum attachment,
                                                       GLenum textarget,
                                                       GLuint texture,
                                                       GLint level,
                                                       GLint zoffset)
{
    return GL_FramebufferTexture3DOESContextANGLE(ctx, target, attachment, textarget, texture,
                                                  level, zoffset);
}

void GL_APIENTRY glFramebufferTextureEXTContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLenum attachment,
                                                     GLuint texture,
                                                     GLint level)
{
    return GL_FramebufferTextureEXTContextANGLE(ctx, target, attachment, texture, level);
}

void GL_APIENTRY glFramebufferTextureLayerContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLenum attachment,
                                                       GLuint texture,
                                                       GLint level,
                                                       GLint layer)
{
    return GL_FramebufferTextureLayerContextANGLE(ctx, target, attachment, texture, level, layer);
}

void GL_APIENTRY glFramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,
                                                              GLenum target,
                                                              GLenum attachment,
                                                              GLuint texture,
                                                              GLint level,
                                                              GLint baseViewIndex,
                                                              GLsizei numViews)
{
    return GL_FramebufferTextureMultiviewOVRContextANGLE(ctx, target, attachment, texture, level,
                                                         baseViewIndex, numViews);
}

void GL_APIENTRY glFrontFaceContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_FrontFaceContextANGLE(ctx, mode);
}

void GL_APIENTRY glFrustumfContextANGLE(GLeglContext ctx,
                                        GLfloat l,
                                        GLfloat r,
                                        GLfloat b,
                                        GLfloat t,
                                        GLfloat n,
                                        GLfloat f)
{
    return GL_FrustumfContextANGLE(ctx, l, r, b, t, n, f);
}

void GL_APIENTRY glFrustumxContextANGLE(GLeglContext ctx,
                                        GLfixed l,
                                        GLfixed r,
                                        GLfixed b,
                                        GLfixed t,
                                        GLfixed n,
                                        GLfixed f)
{
    return GL_FrustumxContextANGLE(ctx, l, r, b, t, n, f);
}

void GL_APIENTRY glGenBuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *buffers)
{
    return GL_GenBuffersContextANGLE(ctx, n, buffers);
}

void GL_APIENTRY glGenFencesNVContextANGLE(GLeglContext ctx, GLsizei n, GLuint *fences)
{
    return GL_GenFencesNVContextANGLE(ctx, n, fences);
}

void GL_APIENTRY glGenFramebuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
{
    return GL_GenFramebuffersContextANGLE(ctx, n, framebuffers);
}

void GL_APIENTRY glGenFramebuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
{
    return GL_GenFramebuffersOESContextANGLE(ctx, n, framebuffers);
}

void GL_APIENTRY glGenProgramPipelinesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *pipelines)
{
    return GL_GenProgramPipelinesContextANGLE(ctx, n, pipelines);
}

void GL_APIENTRY glGenProgramPipelinesEXTContextANGLE(GLeglContext ctx,
                                                      GLsizei n,
                                                      GLuint *pipelines)
{
    return GL_GenProgramPipelinesEXTContextANGLE(ctx, n, pipelines);
}

void GL_APIENTRY glGenQueriesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
{
    return GL_GenQueriesContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glGenQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
{
    return GL_GenQueriesEXTContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glGenRenderbuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
{
    return GL_GenRenderbuffersContextANGLE(ctx, n, renderbuffers);
}

void GL_APIENTRY glGenRenderbuffersOESContextANGLE(GLeglContext ctx,
                                                   GLsizei n,
                                                   GLuint *renderbuffers)
{
    return GL_GenRenderbuffersOESContextANGLE(ctx, n, renderbuffers);
}

void GL_APIENTRY glGenSamplersContextANGLE(GLeglContext ctx, GLsizei count, GLuint *samplers)
{
    return GL_GenSamplersContextANGLE(ctx, count, samplers);
}

void GL_APIENTRY glGenSemaphoresEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *semaphores)
{
    return GL_GenSemaphoresEXTContextANGLE(ctx, n, semaphores);
}

void GL_APIENTRY glGenTexturesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *textures)
{
    return GL_GenTexturesContextANGLE(ctx, n, textures);
}

void GL_APIENTRY glGenTransformFeedbacksContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
{
    return GL_GenTransformFeedbacksContextANGLE(ctx, n, ids);
}

void GL_APIENTRY glGenVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
{
    return GL_GenVertexArraysContextANGLE(ctx, n, arrays);
}

void GL_APIENTRY glGenVertexArraysOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
{
    return GL_GenVertexArraysOESContextANGLE(ctx, n, arrays);
}

void GL_APIENTRY glGenerateMipmapContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_GenerateMipmapContextANGLE(ctx, target);
}

void GL_APIENTRY glGenerateMipmapOESContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_GenerateMipmapOESContextANGLE(ctx, target);
}

void GL_APIENTRY glGetActiveAttribContextANGLE(GLeglContext ctx,
                                               GLuint program,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLint *size,
                                               GLenum *type,
                                               GLchar *name)
{
    return GL_GetActiveAttribContextANGLE(ctx, program, index, bufSize, length, size, type, name);
}

void GL_APIENTRY glGetActiveUniformContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLuint index,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLint *size,
                                                GLenum *type,
                                                GLchar *name)
{
    return GL_GetActiveUniformContextANGLE(ctx, program, index, bufSize, length, size, type, name);
}

void GL_APIENTRY glGetActiveUniformBlockNameContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLuint uniformBlockIndex,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLchar *uniformBlockName)
{
    return GL_GetActiveUniformBlockNameContextANGLE(ctx, program, uniformBlockIndex, bufSize,
                                                    length, uniformBlockName);
}

void GL_APIENTRY glGetActiveUniformBlockivContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLuint uniformBlockIndex,
                                                       GLenum pname,
                                                       GLint *params)
{
    return GL_GetActiveUniformBlockivContextANGLE(ctx, program, uniformBlockIndex, pname, params);
}

void GL_APIENTRY glGetActiveUniformsivContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLsizei uniformCount,
                                                   const GLuint *uniformIndices,
                                                   GLenum pname,
                                                   GLint *params)
{
    return GL_GetActiveUniformsivContextANGLE(ctx, program, uniformCount, uniformIndices, pname,
                                              params);
}

void GL_APIENTRY glGetAttachedShadersContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLsizei maxCount,
                                                  GLsizei *count,
                                                  GLuint *shaders)
{
    return GL_GetAttachedShadersContextANGLE(ctx, program, maxCount, count, shaders);
}

GLint GL_APIENTRY glGetAttribLocationContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  const GLchar *name)
{
    return GL_GetAttribLocationContextANGLE(ctx, program, name);
}

void GL_APIENTRY glGetBooleani_vContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLuint index,
                                             GLboolean *data)
{
    return GL_GetBooleani_vContextANGLE(ctx, target, index, data);
}

void GL_APIENTRY glGetBooleanvContextANGLE(GLeglContext ctx, GLenum pname, GLboolean *data)
{
    return GL_GetBooleanvContextANGLE(ctx, pname, data);
}

void GL_APIENTRY glGetBufferParameteri64vContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLenum pname,
                                                      GLint64 *params)
{
    return GL_GetBufferParameteri64vContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetBufferParameterivContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLenum pname,
                                                    GLint *params)
{
    return GL_GetBufferParameterivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetBufferPointervContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum pname,
                                                 void **params)
{
    return GL_GetBufferPointervContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetBufferPointervOESContextANGLE(GLeglContext ctx,
                                                    GLenum target,
                                                    GLenum pname,
                                                    void **params)
{
    return GL_GetBufferPointervOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetClipPlanefContextANGLE(GLeglContext ctx, GLenum plane, GLfloat *equation)
{
    return GL_GetClipPlanefContextANGLE(ctx, plane, equation);
}

void GL_APIENTRY glGetClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, GLfixed *equation)
{
    return GL_GetClipPlanexContextANGLE(ctx, plane, equation);
}

GLuint GL_APIENTRY glGetDebugMessageLogContextANGLE(GLeglContext ctx,
                                                    GLuint count,
                                                    GLsizei bufSize,
                                                    GLenum *sources,
                                                    GLenum *types,
                                                    GLuint *ids,
                                                    GLenum *severities,
                                                    GLsizei *lengths,
                                                    GLchar *messageLog)
{
    return GL_GetDebugMessageLogContextANGLE(ctx, count, bufSize, sources, types, ids, severities,
                                             lengths, messageLog);
}

GLuint GL_APIENTRY glGetDebugMessageLogKHRContextANGLE(GLeglContext ctx,
                                                       GLuint count,
                                                       GLsizei bufSize,
                                                       GLenum *sources,
                                                       GLenum *types,
                                                       GLuint *ids,
                                                       GLenum *severities,
                                                       GLsizei *lengths,
                                                       GLchar *messageLog)
{
    return GL_GetDebugMessageLogKHRContextANGLE(ctx, count, bufSize, sources, types, ids,
                                                severities, lengths, messageLog);
}

GLenum GL_APIENTRY glGetErrorContextANGLE(GLeglContext ctx)
{
    return GL_GetErrorContextANGLE(ctx);
}

void GL_APIENTRY glGetFenceivNVContextANGLE(GLeglContext ctx,
                                            GLuint fence,
                                            GLenum pname,
                                            GLint *params)
{
    return GL_GetFenceivNVContextANGLE(ctx, fence, pname, params);
}

void GL_APIENTRY glGetFixedvContextANGLE(GLeglContext ctx, GLenum pname, GLfixed *params)
{
    return GL_GetFixedvContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glGetFloatvContextANGLE(GLeglContext ctx, GLenum pname, GLfloat *data)
{
    return GL_GetFloatvContextANGLE(ctx, pname, data);
}

GLint GL_APIENTRY glGetFragDataIndexEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    const GLchar *name)
{
    return GL_GetFragDataIndexEXTContextANGLE(ctx, program, name);
}

GLint GL_APIENTRY glGetFragDataLocationContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    const GLchar *name)
{
    return GL_GetFragDataLocationContextANGLE(ctx, program, name);
}

void GL_APIENTRY glGetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,
                                                                   GLenum target,
                                                                   GLenum attachment,
                                                                   GLenum pname,
                                                                   GLint *params)
{
    return GL_GetFramebufferAttachmentParameterivContextANGLE(ctx, target, attachment, pname,
                                                              params);
}

void GL_APIENTRY glGetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,
                                                                      GLenum target,
                                                                      GLenum attachment,
                                                                      GLenum pname,
                                                                      GLint *params)
{
    return GL_GetFramebufferAttachmentParameterivOESContextANGLE(ctx, target, attachment, pname,
                                                                 params);
}

void GL_APIENTRY glGetFramebufferParameterivContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLint *params)
{
    return GL_GetFramebufferParameterivContextANGLE(ctx, target, pname, params);
}

GLenum GL_APIENTRY glGetGraphicsResetStatusContextANGLE(GLeglContext ctx)
{
    return GL_GetGraphicsResetStatusContextANGLE(ctx);
}

GLenum GL_APIENTRY glGetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx)
{
    return GL_GetGraphicsResetStatusEXTContextANGLE(ctx);
}

void GL_APIENTRY glGetInteger64i_vContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLuint index,
                                               GLint64 *data)
{
    return GL_GetInteger64i_vContextANGLE(ctx, target, index, data);
}

void GL_APIENTRY glGetInteger64vContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
{
    return GL_GetInteger64vContextANGLE(ctx, pname, data);
}

void GL_APIENTRY glGetInteger64vEXTContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
{
    return GL_GetInteger64vEXTContextANGLE(ctx, pname, data);
}

void GL_APIENTRY glGetIntegeri_vContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLuint index,
                                             GLint *data)
{
    return GL_GetIntegeri_vContextANGLE(ctx, target, index, data);
}

void GL_APIENTRY glGetIntegervContextANGLE(GLeglContext ctx, GLenum pname, GLint *data)
{
    return GL_GetIntegervContextANGLE(ctx, pname, data);
}

void GL_APIENTRY glGetInternalformativContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLenum internalformat,
                                                   GLenum pname,
                                                   GLsizei bufSize,
                                                   GLint *params)
{
    return GL_GetInternalformativContextANGLE(ctx, target, internalformat, pname, bufSize, params);
}

void GL_APIENTRY glGetLightfvContextANGLE(GLeglContext ctx,
                                          GLenum light,
                                          GLenum pname,
                                          GLfloat *params)
{
    return GL_GetLightfvContextANGLE(ctx, light, pname, params);
}

void GL_APIENTRY glGetLightxvContextANGLE(GLeglContext ctx,
                                          GLenum light,
                                          GLenum pname,
                                          GLfixed *params)
{
    return GL_GetLightxvContextANGLE(ctx, light, pname, params);
}

void GL_APIENTRY glGetMaterialfvContextANGLE(GLeglContext ctx,
                                             GLenum face,
                                             GLenum pname,
                                             GLfloat *params)
{
    return GL_GetMaterialfvContextANGLE(ctx, face, pname, params);
}

void GL_APIENTRY glGetMaterialxvContextANGLE(GLeglContext ctx,
                                             GLenum face,
                                             GLenum pname,
                                             GLfixed *params)
{
    return GL_GetMaterialxvContextANGLE(ctx, face, pname, params);
}

void GL_APIENTRY glGetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
                                                             GLuint memoryObject,
                                                             GLenum pname,
                                                             GLint *params)
{
    return GL_GetMemoryObjectParameterivEXTContextANGLE(ctx, memoryObject, pname, params);
}

void GL_APIENTRY glGetMultisamplefvContextANGLE(GLeglContext ctx,
                                                GLenum pname,
                                                GLuint index,
                                                GLfloat *val)
{
    return GL_GetMultisamplefvContextANGLE(ctx, pname, index, val);
}

void GL_APIENTRY glGetObjectLabelContextANGLE(GLeglContext ctx,
                                              GLenum identifier,
                                              GLuint name,
                                              GLsizei bufSize,
                                              GLsizei *length,
                                              GLchar *label)
{
    return GL_GetObjectLabelContextANGLE(ctx, identifier, name, bufSize, length, label);
}

void GL_APIENTRY glGetObjectLabelEXTContextANGLE(GLeglContext ctx,
                                                 GLenum type,
                                                 GLuint object,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *label)
{
    return GL_GetObjectLabelEXTContextANGLE(ctx, type, object, bufSize, length, label);
}

void GL_APIENTRY glGetObjectLabelKHRContextANGLE(GLeglContext ctx,
                                                 GLenum identifier,
                                                 GLuint name,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *label)
{
    return GL_GetObjectLabelKHRContextANGLE(ctx, identifier, name, bufSize, length, label);
}

void GL_APIENTRY glGetObjectPtrLabelContextANGLE(GLeglContext ctx,
                                                 const void *ptr,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *label)
{
    return GL_GetObjectPtrLabelContextANGLE(ctx, ptr, bufSize, length, label);
}

void GL_APIENTRY glGetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
                                                    const void *ptr,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLchar *label)
{
    return GL_GetObjectPtrLabelKHRContextANGLE(ctx, ptr, bufSize, length, label);
}

void GL_APIENTRY glGetPointervContextANGLE(GLeglContext ctx, GLenum pname, void **params)
{
    return GL_GetPointervContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glGetPointervKHRContextANGLE(GLeglContext ctx, GLenum pname, void **params)
{
    return GL_GetPointervKHRContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glGetProgramBinaryContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLenum *binaryFormat,
                                                void *binary)
{
    return GL_GetProgramBinaryContextANGLE(ctx, program, bufSize, length, binaryFormat, binary);
}

void GL_APIENTRY glGetProgramBinaryOESContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLsizei bufSize,
                                                   GLsizei *length,
                                                   GLenum *binaryFormat,
                                                   void *binary)
{
    return GL_GetProgramBinaryOESContextANGLE(ctx, program, bufSize, length, binaryFormat, binary);
}

void GL_APIENTRY glGetProgramInfoLogContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *infoLog)
{
    return GL_GetProgramInfoLogContextANGLE(ctx, program, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramInterfaceivContextANGLE(GLeglContext ctx,
                                                     GLuint program,
                                                     GLenum programInterface,
                                                     GLenum pname,
                                                     GLint *params)
{
    return GL_GetProgramInterfaceivContextANGLE(ctx, program, programInterface, pname, params);
}

void GL_APIENTRY glGetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,
                                                         GLuint pipeline,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLchar *infoLog)
{
    return GL_GetProgramPipelineInfoLogContextANGLE(ctx, pipeline, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramPipelineInfoLogEXTContextANGLE(GLeglContext ctx,
                                                            GLuint pipeline,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLchar *infoLog)
{
    return GL_GetProgramPipelineInfoLogEXTContextANGLE(ctx, pipeline, bufSize, length, infoLog);
}

void GL_APIENTRY glGetProgramPipelineivContextANGLE(GLeglContext ctx,
                                                    GLuint pipeline,
                                                    GLenum pname,
                                                    GLint *params)
{
    return GL_GetProgramPipelineivContextANGLE(ctx, pipeline, pname, params);
}

void GL_APIENTRY glGetProgramPipelineivEXTContextANGLE(GLeglContext ctx,
                                                       GLuint pipeline,
                                                       GLenum pname,
                                                       GLint *params)
{
    return GL_GetProgramPipelineivEXTContextANGLE(ctx, pipeline, pname, params);
}

GLuint GL_APIENTRY glGetProgramResourceIndexContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLenum programInterface,
                                                         const GLchar *name)
{
    return GL_GetProgramResourceIndexContextANGLE(ctx, program, programInterface, name);
}

GLint GL_APIENTRY glGetProgramResourceLocationContextANGLE(GLeglContext ctx,
                                                           GLuint program,
                                                           GLenum programInterface,
                                                           const GLchar *name)
{
    return GL_GetProgramResourceLocationContextANGLE(ctx, program, programInterface, name);
}

GLint GL_APIENTRY glGetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,
                                                                   GLuint program,
                                                                   GLenum programInterface,
                                                                   const GLchar *name)
{
    return GL_GetProgramResourceLocationIndexEXTContextANGLE(ctx, program, programInterface, name);
}

void GL_APIENTRY glGetProgramResourceNameContextANGLE(GLeglContext ctx,
                                                      GLuint program,
                                                      GLenum programInterface,
                                                      GLuint index,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLchar *name)
{
    return GL_GetProgramResourceNameContextANGLE(ctx, program, programInterface, index, bufSize,
                                                 length, name);
}

void GL_APIENTRY glGetProgramResourceivContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLenum programInterface,
                                                    GLuint index,
                                                    GLsizei propCount,
                                                    const GLenum *props,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params)
{
    return GL_GetProgramResourceivContextANGLE(ctx, program, programInterface, index, propCount,
                                               props, bufSize, length, params);
}

void GL_APIENTRY glGetProgramivContextANGLE(GLeglContext ctx,
                                            GLuint program,
                                            GLenum pname,
                                            GLint *params)
{
    return GL_GetProgramivContextANGLE(ctx, program, pname, params);
}

void GL_APIENTRY glGetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,
                                                     GLuint id,
                                                     GLenum pname,
                                                     GLint64 *params)
{
    return GL_GetQueryObjecti64vEXTContextANGLE(ctx, id, pname, params);
}

void GL_APIENTRY glGetQueryObjectivEXTContextANGLE(GLeglContext ctx,
                                                   GLuint id,
                                                   GLenum pname,
                                                   GLint *params)
{
    return GL_GetQueryObjectivEXTContextANGLE(ctx, id, pname, params);
}

void GL_APIENTRY glGetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,
                                                      GLuint id,
                                                      GLenum pname,
                                                      GLuint64 *params)
{
    return GL_GetQueryObjectui64vEXTContextANGLE(ctx, id, pname, params);
}

void GL_APIENTRY glGetQueryObjectuivContextANGLE(GLeglContext ctx,
                                                 GLuint id,
                                                 GLenum pname,
                                                 GLuint *params)
{
    return GL_GetQueryObjectuivContextANGLE(ctx, id, pname, params);
}

void GL_APIENTRY glGetQueryObjectuivEXTContextANGLE(GLeglContext ctx,
                                                    GLuint id,
                                                    GLenum pname,
                                                    GLuint *params)
{
    return GL_GetQueryObjectuivEXTContextANGLE(ctx, id, pname, params);
}

void GL_APIENTRY glGetQueryivContextANGLE(GLeglContext ctx,
                                          GLenum target,
                                          GLenum pname,
                                          GLint *params)
{
    return GL_GetQueryivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetQueryivEXTContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLenum pname,
                                             GLint *params)
{
    return GL_GetQueryivEXTContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetRenderbufferParameterivContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLenum pname,
                                                          GLint *params)
{
    return GL_GetRenderbufferParameterivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,
                                                             GLenum target,
                                                             GLenum pname,
                                                             GLint *params)
{
    return GL_GetRenderbufferParameterivOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIivContextANGLE(GLeglContext ctx,
                                                      GLuint sampler,
                                                      GLenum pname,
                                                      GLint *params)
{
    return GL_GetSamplerParameterIivContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIivEXTContextANGLE(GLeglContext ctx,
                                                         GLuint sampler,
                                                         GLenum pname,
                                                         GLint *params)
{
    return GL_GetSamplerParameterIivEXTContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIivOESContextANGLE(GLeglContext ctx,
                                                         GLuint sampler,
                                                         GLenum pname,
                                                         GLint *params)
{
    return GL_GetSamplerParameterIivOESContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuivContextANGLE(GLeglContext ctx,
                                                       GLuint sampler,
                                                       GLenum pname,
                                                       GLuint *params)
{
    return GL_GetSamplerParameterIuivContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuivEXTContextANGLE(GLeglContext ctx,
                                                          GLuint sampler,
                                                          GLenum pname,
                                                          GLuint *params)
{
    return GL_GetSamplerParameterIuivEXTContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
                                                          GLuint sampler,
                                                          GLenum pname,
                                                          GLuint *params)
{
    return GL_GetSamplerParameterIuivOESContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterfvContextANGLE(GLeglContext ctx,
                                                     GLuint sampler,
                                                     GLenum pname,
                                                     GLfloat *params)
{
    return GL_GetSamplerParameterfvContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSamplerParameterivContextANGLE(GLeglContext ctx,
                                                     GLuint sampler,
                                                     GLenum pname,
                                                     GLint *params)
{
    return GL_GetSamplerParameterivContextANGLE(ctx, sampler, pname, params);
}

void GL_APIENTRY glGetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
                                                             GLuint semaphore,
                                                             GLenum pname,
                                                             GLuint64 *params)
{
    return GL_GetSemaphoreParameterui64vEXTContextANGLE(ctx, semaphore, pname, params);
}

void GL_APIENTRY glGetShaderInfoLogContextANGLE(GLeglContext ctx,
                                                GLuint shader,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLchar *infoLog)
{
    return GL_GetShaderInfoLogContextANGLE(ctx, shader, bufSize, length, infoLog);
}

void GL_APIENTRY glGetShaderPrecisionFormatContextANGLE(GLeglContext ctx,
                                                        GLenum shadertype,
                                                        GLenum precisiontype,
                                                        GLint *range,
                                                        GLint *precision)
{
    return GL_GetShaderPrecisionFormatContextANGLE(ctx, shadertype, precisiontype, range,
                                                   precision);
}

void GL_APIENTRY glGetShaderSourceContextANGLE(GLeglContext ctx,
                                               GLuint shader,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLchar *source)
{
    return GL_GetShaderSourceContextANGLE(ctx, shader, bufSize, length, source);
}

void GL_APIENTRY glGetShaderivContextANGLE(GLeglContext ctx,
                                           GLuint shader,
                                           GLenum pname,
                                           GLint *params)
{
    return GL_GetShaderivContextANGLE(ctx, shader, pname, params);
}

const GLubyte *GL_APIENTRY glGetStringContextANGLE(GLeglContext ctx, GLenum name)
{
    return GL_GetStringContextANGLE(ctx, name);
}

const GLubyte *GL_APIENTRY glGetStringiContextANGLE(GLeglContext ctx, GLenum name, GLuint index)
{
    return GL_GetStringiContextANGLE(ctx, name, index);
}

void GL_APIENTRY glGetSyncivContextANGLE(GLeglContext ctx,
                                         GLsync sync,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLsizei *length,
                                         GLint *values)
{
    return GL_GetSyncivContextANGLE(ctx, sync, pname, bufSize, length, values);
}

void GL_APIENTRY glGetTexEnvfvContextANGLE(GLeglContext ctx,
                                           GLenum target,
                                           GLenum pname,
                                           GLfloat *params)
{
    return GL_GetTexEnvfvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexEnvivContextANGLE(GLeglContext ctx,
                                           GLenum target,
                                           GLenum pname,
                                           GLint *params)
{
    return GL_GetTexEnvivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexEnvxvContextANGLE(GLeglContext ctx,
                                           GLenum target,
                                           GLenum pname,
                                           GLfixed *params)
{
    return GL_GetTexEnvxvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexGenfvOESContextANGLE(GLeglContext ctx,
                                              GLenum coord,
                                              GLenum pname,
                                              GLfloat *params)
{
    return GL_GetTexGenfvOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glGetTexGenivOESContextANGLE(GLeglContext ctx,
                                              GLenum coord,
                                              GLenum pname,
                                              GLint *params)
{
    return GL_GetTexGenivOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glGetTexGenxvOESContextANGLE(GLeglContext ctx,
                                              GLenum coord,
                                              GLenum pname,
                                              GLfixed *params)
{
    return GL_GetTexGenxvOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glGetTexLevelParameterfvContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLint level,
                                                      GLenum pname,
                                                      GLfloat *params)
{
    return GL_GetTexLevelParameterfvContextANGLE(ctx, target, level, pname, params);
}

void GL_APIENTRY glGetTexLevelParameterivContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLint level,
                                                      GLenum pname,
                                                      GLint *params)
{
    return GL_GetTexLevelParameterivContextANGLE(ctx, target, level, pname, params);
}

void GL_APIENTRY glGetTexParameterIivContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLenum pname,
                                                  GLint *params)
{
    return GL_GetTexParameterIivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterIivEXTContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLenum pname,
                                                     GLint *params)
{
    return GL_GetTexParameterIivEXTContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterIivOESContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLenum pname,
                                                     GLint *params)
{
    return GL_GetTexParameterIivOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuivContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLenum pname,
                                                   GLuint *params)
{
    return GL_GetTexParameterIuivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuivEXTContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLenum pname,
                                                      GLuint *params)
{
    return GL_GetTexParameterIuivEXTContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterIuivOESContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLenum pname,
                                                      GLuint *params)
{
    return GL_GetTexParameterIuivOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterfvContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLfloat *params)
{
    return GL_GetTexParameterfvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterivContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLint *params)
{
    return GL_GetTexParameterivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTexParameterxvContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum pname,
                                                 GLfixed *params)
{
    return GL_GetTexParameterxvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glGetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,
                                                           GLuint program,
                                                           GLuint index,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLsizei *size,
                                                           GLenum *type,
                                                           GLchar *name)
{
    return GL_GetTransformFeedbackVaryingContextANGLE(ctx, program, index, bufSize, length, size,
                                                      type, name);
}

void GL_APIENTRY glGetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,
                                                              GLuint shader,
                                                              GLsizei bufsize,
                                                              GLsizei *length,
                                                              GLchar *source)
{
    return GL_GetTranslatedShaderSourceANGLEContextANGLE(ctx, shader, bufsize, length, source);
}

GLuint GL_APIENTRY glGetUniformBlockIndexContextANGLE(GLeglContext ctx,
                                                      GLuint program,
                                                      const GLchar *uniformBlockName)
{
    return GL_GetUniformBlockIndexContextANGLE(ctx, program, uniformBlockName);
}

void GL_APIENTRY glGetUniformIndicesContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLsizei uniformCount,
                                                 const GLchar *const *uniformNames,
                                                 GLuint *uniformIndices)
{
    return GL_GetUniformIndicesContextANGLE(ctx, program, uniformCount, uniformNames,
                                            uniformIndices);
}

GLint GL_APIENTRY glGetUniformLocationContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   const GLchar *name)
{
    return GL_GetUniformLocationContextANGLE(ctx, program, name);
}

void GL_APIENTRY glGetUniformfvContextANGLE(GLeglContext ctx,
                                            GLuint program,
                                            GLint location,
                                            GLfloat *params)
{
    return GL_GetUniformfvContextANGLE(ctx, program, location, params);
}

void GL_APIENTRY glGetUniformivContextANGLE(GLeglContext ctx,
                                            GLuint program,
                                            GLint location,
                                            GLint *params)
{
    return GL_GetUniformivContextANGLE(ctx, program, location, params);
}

void GL_APIENTRY glGetUniformuivContextANGLE(GLeglContext ctx,
                                             GLuint program,
                                             GLint location,
                                             GLuint *params)
{
    return GL_GetUniformuivContextANGLE(ctx, program, location, params);
}

void GL_APIENTRY glGetUnsignedBytevEXTContextANGLE(GLeglContext ctx, GLenum pname, GLubyte *data)
{
    return GL_GetUnsignedBytevEXTContextANGLE(ctx, pname, data);
}

void GL_APIENTRY glGetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLuint index,
                                                     GLubyte *data)
{
    return GL_GetUnsignedBytei_vEXTContextANGLE(ctx, target, index, data);
}

void GL_APIENTRY glGetVertexAttribIivContextANGLE(GLeglContext ctx,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLint *params)
{
    return GL_GetVertexAttribIivContextANGLE(ctx, index, pname, params);
}

void GL_APIENTRY glGetVertexAttribIuivContextANGLE(GLeglContext ctx,
                                                   GLuint index,
                                                   GLenum pname,
                                                   GLuint *params)
{
    return GL_GetVertexAttribIuivContextANGLE(ctx, index, pname, params);
}

void GL_APIENTRY glGetVertexAttribPointervContextANGLE(GLeglContext ctx,
                                                       GLuint index,
                                                       GLenum pname,
                                                       void **pointer)
{
    return GL_GetVertexAttribPointervContextANGLE(ctx, index, pname, pointer);
}

void GL_APIENTRY glGetVertexAttribfvContextANGLE(GLeglContext ctx,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLfloat *params)
{
    return GL_GetVertexAttribfvContextANGLE(ctx, index, pname, params);
}

void GL_APIENTRY glGetVertexAttribivContextANGLE(GLeglContext ctx,
                                                 GLuint index,
                                                 GLenum pname,
                                                 GLint *params)
{
    return GL_GetVertexAttribivContextANGLE(ctx, index, pname, params);
}

void GL_APIENTRY glGetnUniformfvContextANGLE(GLeglContext ctx,
                                             GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
                                             GLfloat *params)
{
    return GL_GetnUniformfvContextANGLE(ctx, program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformfvEXTContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
                                                GLfloat *params)
{
    return GL_GetnUniformfvEXTContextANGLE(ctx, program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformivContextANGLE(GLeglContext ctx,
                                             GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
                                             GLint *params)
{
    return GL_GetnUniformivContextANGLE(ctx, program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformivEXTContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
                                                GLint *params)
{
    return GL_GetnUniformivEXTContextANGLE(ctx, program, location, bufSize, params);
}

void GL_APIENTRY glGetnUniformuivContextANGLE(GLeglContext ctx,
                                              GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
                                              GLuint *params)
{
    return GL_GetnUniformuivContextANGLE(ctx, program, location, bufSize, params);
}

void GL_APIENTRY glHintContextANGLE(GLeglContext ctx, GLenum target, GLenum mode)
{
    return GL_HintContextANGLE(ctx, target, mode);
}

void GL_APIENTRY glImportMemoryFdEXTContextANGLE(GLeglContext ctx,
                                                 GLuint memory,
                                                 GLuint64 size,
                                                 GLenum handleType,
                                                 GLint fd)
{
    return GL_ImportMemoryFdEXTContextANGLE(ctx, memory, size, handleType, fd);
}

void GL_APIENTRY glImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,
                                                    GLuint semaphore,
                                                    GLenum handleType,
                                                    GLint fd)
{
    return GL_ImportSemaphoreFdEXTContextANGLE(ctx, semaphore, handleType, fd);
}

void GL_APIENTRY glInsertEventMarkerEXTContextANGLE(GLeglContext ctx,
                                                    GLsizei length,
                                                    const GLchar *marker)
{
    return GL_InsertEventMarkerEXTContextANGLE(ctx, length, marker);
}

void GL_APIENTRY glInvalidateFramebufferContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLsizei numAttachments,
                                                     const GLenum *attachments)
{
    return GL_InvalidateFramebufferContextANGLE(ctx, target, numAttachments, attachments);
}

void GL_APIENTRY glInvalidateSubFramebufferContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLsizei numAttachments,
                                                        const GLenum *attachments,
                                                        GLint x,
                                                        GLint y,
                                                        GLsizei width,
                                                        GLsizei height)
{
    return GL_InvalidateSubFramebufferContextANGLE(ctx, target, numAttachments, attachments, x, y,
                                                   width, height);
}

GLboolean GL_APIENTRY glIsBufferContextANGLE(GLeglContext ctx, GLuint buffer)
{
    return GL_IsBufferContextANGLE(ctx, buffer);
}

GLboolean GL_APIENTRY glIsEnabledContextANGLE(GLeglContext ctx, GLenum cap)
{
    return GL_IsEnabledContextANGLE(ctx, cap);
}

GLboolean GL_APIENTRY glIsEnablediContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_IsEnablediContextANGLE(ctx, target, index);
}

GLboolean GL_APIENTRY glIsEnablediEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_IsEnablediEXTContextANGLE(ctx, target, index);
}

GLboolean GL_APIENTRY glIsEnablediOESContextANGLE(GLeglContext ctx, GLenum target, GLuint index)
{
    return GL_IsEnablediOESContextANGLE(ctx, target, index);
}

GLboolean GL_APIENTRY glIsFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
{
    return GL_IsFenceNVContextANGLE(ctx, fence);
}

GLboolean GL_APIENTRY glIsFramebufferContextANGLE(GLeglContext ctx, GLuint framebuffer)
{
    return GL_IsFramebufferContextANGLE(ctx, framebuffer);
}

GLboolean GL_APIENTRY glIsFramebufferOESContextANGLE(GLeglContext ctx, GLuint framebuffer)
{
    return GL_IsFramebufferOESContextANGLE(ctx, framebuffer);
}

GLboolean GL_APIENTRY glIsMemoryObjectEXTContextANGLE(GLeglContext ctx, GLuint memoryObject)
{
    return GL_IsMemoryObjectEXTContextANGLE(ctx, memoryObject);
}

GLboolean GL_APIENTRY glIsProgramContextANGLE(GLeglContext ctx, GLuint program)
{
    return GL_IsProgramContextANGLE(ctx, program);
}

GLboolean GL_APIENTRY glIsProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_IsProgramPipelineContextANGLE(ctx, pipeline);
}

GLboolean GL_APIENTRY glIsProgramPipelineEXTContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_IsProgramPipelineEXTContextANGLE(ctx, pipeline);
}

GLboolean GL_APIENTRY glIsQueryContextANGLE(GLeglContext ctx, GLuint id)
{
    return GL_IsQueryContextANGLE(ctx, id);
}

GLboolean GL_APIENTRY glIsQueryEXTContextANGLE(GLeglContext ctx, GLuint id)
{
    return GL_IsQueryEXTContextANGLE(ctx, id);
}

GLboolean GL_APIENTRY glIsRenderbufferContextANGLE(GLeglContext ctx, GLuint renderbuffer)
{
    return GL_IsRenderbufferContextANGLE(ctx, renderbuffer);
}

GLboolean GL_APIENTRY glIsRenderbufferOESContextANGLE(GLeglContext ctx, GLuint renderbuffer)
{
    return GL_IsRenderbufferOESContextANGLE(ctx, renderbuffer);
}

GLboolean GL_APIENTRY glIsSemaphoreEXTContextANGLE(GLeglContext ctx, GLuint semaphore)
{
    return GL_IsSemaphoreEXTContextANGLE(ctx, semaphore);
}

GLboolean GL_APIENTRY glIsSamplerContextANGLE(GLeglContext ctx, GLuint sampler)
{
    return GL_IsSamplerContextANGLE(ctx, sampler);
}

GLboolean GL_APIENTRY glIsShaderContextANGLE(GLeglContext ctx, GLuint shader)
{
    return GL_IsShaderContextANGLE(ctx, shader);
}

GLboolean GL_APIENTRY glIsSyncContextANGLE(GLeglContext ctx, GLsync sync)
{
    return GL_IsSyncContextANGLE(ctx, sync);
}

GLboolean GL_APIENTRY glIsTextureContextANGLE(GLeglContext ctx, GLuint texture)
{
    return GL_IsTextureContextANGLE(ctx, texture);
}

GLboolean GL_APIENTRY glIsTransformFeedbackContextANGLE(GLeglContext ctx, GLuint id)
{
    return GL_IsTransformFeedbackContextANGLE(ctx, id);
}

GLboolean GL_APIENTRY glIsVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
{
    return GL_IsVertexArrayContextANGLE(ctx, array);
}

GLboolean GL_APIENTRY glIsVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
{
    return GL_IsVertexArrayOESContextANGLE(ctx, array);
}

void GL_APIENTRY glLabelObjectEXTContextANGLE(GLeglContext ctx,
                                              GLenum type,
                                              GLuint object,
                                              GLsizei length,
                                              const GLchar *label)
{
    return GL_LabelObjectEXTContextANGLE(ctx, type, object, length, label);
}

void GL_APIENTRY glLightModelfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
{
    return GL_LightModelfContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glLightModelfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
{
    return GL_LightModelfvContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glLightModelxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
{
    return GL_LightModelxContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glLightModelxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
{
    return GL_LightModelxvContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glLightfContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfloat param)
{
    return GL_LightfContextANGLE(ctx, light, pname, param);
}

void GL_APIENTRY glLightfvContextANGLE(GLeglContext ctx,
                                       GLenum light,
                                       GLenum pname,
                                       const GLfloat *params)
{
    return GL_LightfvContextANGLE(ctx, light, pname, params);
}

void GL_APIENTRY glLightxContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfixed param)
{
    return GL_LightxContextANGLE(ctx, light, pname, param);
}

void GL_APIENTRY glLightxvContextANGLE(GLeglContext ctx,
                                       GLenum light,
                                       GLenum pname,
                                       const GLfixed *params)
{
    return GL_LightxvContextANGLE(ctx, light, pname, params);
}

void GL_APIENTRY glLineWidthContextANGLE(GLeglContext ctx, GLfloat width)
{
    return GL_LineWidthContextANGLE(ctx, width);
}

void GL_APIENTRY glLineWidthxContextANGLE(GLeglContext ctx, GLfixed width)
{
    return GL_LineWidthxContextANGLE(ctx, width);
}

void GL_APIENTRY glLinkProgramContextANGLE(GLeglContext ctx, GLuint program)
{
    return GL_LinkProgramContextANGLE(ctx, program);
}

void GL_APIENTRY glLoadIdentityContextANGLE(GLeglContext ctx)
{
    return GL_LoadIdentityContextANGLE(ctx);
}

void GL_APIENTRY glLoadMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
{
    return GL_LoadMatrixfContextANGLE(ctx, m);
}

void GL_APIENTRY glLoadMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
{
    return GL_LoadMatrixxContextANGLE(ctx, m);
}

void GL_APIENTRY glLoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx)
{
    return GL_LoadPaletteFromModelViewMatrixOESContextANGLE(ctx);
}

void GL_APIENTRY glLogicOpContextANGLE(GLeglContext ctx, GLenum opcode)
{
    return GL_LogicOpContextANGLE(ctx, opcode);
}

void *GL_APIENTRY glMapBufferOESContextANGLE(GLeglContext ctx, GLenum target, GLenum access)
{
    return GL_MapBufferOESContextANGLE(ctx, target, access);
}

void *GL_APIENTRY glMapBufferRangeContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLintptr offset,
                                               GLsizeiptr length,
                                               GLbitfield access)
{
    return GL_MapBufferRangeContextANGLE(ctx, target, offset, length, access);
}

void *GL_APIENTRY glMapBufferRangeEXTContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLintptr offset,
                                                  GLsizeiptr length,
                                                  GLbitfield access)
{
    return GL_MapBufferRangeEXTContextANGLE(ctx, target, offset, length, access);
}

void GL_APIENTRY glMaterialfContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfloat param)
{
    return GL_MaterialfContextANGLE(ctx, face, pname, param);
}

void GL_APIENTRY glMaterialfvContextANGLE(GLeglContext ctx,
                                          GLenum face,
                                          GLenum pname,
                                          const GLfloat *params)
{
    return GL_MaterialfvContextANGLE(ctx, face, pname, params);
}

void GL_APIENTRY glMaterialxContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfixed param)
{
    return GL_MaterialxContextANGLE(ctx, face, pname, param);
}

void GL_APIENTRY glMaterialxvContextANGLE(GLeglContext ctx,
                                          GLenum face,
                                          GLenum pname,
                                          const GLfixed *param)
{
    return GL_MaterialxvContextANGLE(ctx, face, pname, param);
}

void GL_APIENTRY glMatrixIndexPointerOESContextANGLE(GLeglContext ctx,
                                                     GLint size,
                                                     GLenum type,
                                                     GLsizei stride,
                                                     const void *pointer)
{
    return GL_MatrixIndexPointerOESContextANGLE(ctx, size, type, stride, pointer);
}

void GL_APIENTRY glMatrixModeContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_MatrixModeContextANGLE(ctx, mode);
}

void GL_APIENTRY glMaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx, GLuint count)
{
    return GL_MaxShaderCompilerThreadsKHRContextANGLE(ctx, count);
}

void GL_APIENTRY glMemoryBarrierContextANGLE(GLeglContext ctx, GLbitfield barriers)
{
    return GL_MemoryBarrierContextANGLE(ctx, barriers);
}

void GL_APIENTRY glMemoryBarrierByRegionContextANGLE(GLeglContext ctx, GLbitfield barriers)
{
    return GL_MemoryBarrierByRegionContextANGLE(ctx, barriers);
}

void GL_APIENTRY glMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
                                                          GLuint memoryObject,
                                                          GLenum pname,
                                                          const GLint *params)
{
    return GL_MemoryObjectParameterivEXTContextANGLE(ctx, memoryObject, pname, params);
}

void GL_APIENTRY glMinSampleShadingContextANGLE(GLeglContext ctx, GLfloat value)
{
    return GL_MinSampleShadingContextANGLE(ctx, value);
}

void GL_APIENTRY glMinSampleShadingOESContextANGLE(GLeglContext ctx, GLfloat value)
{
    return GL_MinSampleShadingOESContextANGLE(ctx, value);
}

void GL_APIENTRY glMultMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
{
    return GL_MultMatrixfContextANGLE(ctx, m);
}

void GL_APIENTRY glMultMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
{
    return GL_MultMatrixxContextANGLE(ctx, m);
}

void GL_APIENTRY glMultiDrawElementsBaseVertexEXTContextANGLE(GLeglContext ctx,
                                                              GLenum mode,
                                                              const GLsizei *count,
                                                              GLenum type,
                                                              const void *const *indices,
                                                              GLsizei primcount,
                                                              const GLint *basevertex)
{
    return GL_MultiDrawElementsBaseVertexEXTContextANGLE(ctx, mode, count, type, indices, primcount,
                                                         basevertex);
}

void GL_APIENTRY glMultiTexCoord4fContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLfloat s,
                                               GLfloat t,
                                               GLfloat r,
                                               GLfloat q)
{
    return GL_MultiTexCoord4fContextANGLE(ctx, target, s, t, r, q);
}

void GL_APIENTRY glMultiTexCoord4xContextANGLE(GLeglContext ctx,
                                               GLenum texture,
                                               GLfixed s,
                                               GLfixed t,
                                               GLfixed r,
                                               GLfixed q)
{
    return GL_MultiTexCoord4xContextANGLE(ctx, texture, s, t, r, q);
}

void GL_APIENTRY glNamedBufferStorageExternalEXTContextANGLE(GLeglContext ctx,
                                                             GLuint buffer,
                                                             GLintptr offset,
                                                             GLsizeiptr size,
                                                             GLeglClientBufferEXT clientBuffer,
                                                             GLbitfield flags)
{
    return GL_NamedBufferStorageExternalEXTContextANGLE(ctx, buffer, offset, size, clientBuffer,
                                                        flags);
}

void GL_APIENTRY glNormal3fContextANGLE(GLeglContext ctx, GLfloat nx, GLfloat ny, GLfloat nz)
{
    return GL_Normal3fContextANGLE(ctx, nx, ny, nz);
}

void GL_APIENTRY glNormal3xContextANGLE(GLeglContext ctx, GLfixed nx, GLfixed ny, GLfixed nz)
{
    return GL_Normal3xContextANGLE(ctx, nx, ny, nz);
}

void GL_APIENTRY glNormalPointerContextANGLE(GLeglContext ctx,
                                             GLenum type,
                                             GLsizei stride,
                                             const void *pointer)
{
    return GL_NormalPointerContextANGLE(ctx, type, stride, pointer);
}

void GL_APIENTRY glObjectLabelContextANGLE(GLeglContext ctx,
                                           GLenum identifier,
                                           GLuint name,
                                           GLsizei length,
                                           const GLchar *label)
{
    return GL_ObjectLabelContextANGLE(ctx, identifier, name, length, label);
}

void GL_APIENTRY glObjectLabelKHRContextANGLE(GLeglContext ctx,
                                              GLenum identifier,
                                              GLuint name,
                                              GLsizei length,
                                              const GLchar *label)
{
    return GL_ObjectLabelKHRContextANGLE(ctx, identifier, name, length, label);
}

void GL_APIENTRY glObjectPtrLabelContextANGLE(GLeglContext ctx,
                                              const void *ptr,
                                              GLsizei length,
                                              const GLchar *label)
{
    return GL_ObjectPtrLabelContextANGLE(ctx, ptr, length, label);
}

void GL_APIENTRY glObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
                                                 const void *ptr,
                                                 GLsizei length,
                                                 const GLchar *label)
{
    return GL_ObjectPtrLabelKHRContextANGLE(ctx, ptr, length, label);
}

void GL_APIENTRY glOrthofContextANGLE(GLeglContext ctx,
                                      GLfloat l,
                                      GLfloat r,
                                      GLfloat b,
                                      GLfloat t,
                                      GLfloat n,
                                      GLfloat f)
{
    return GL_OrthofContextANGLE(ctx, l, r, b, t, n, f);
}

void GL_APIENTRY glOrthoxContextANGLE(GLeglContext ctx,
                                      GLfixed l,
                                      GLfixed r,
                                      GLfixed b,
                                      GLfixed t,
                                      GLfixed n,
                                      GLfixed f)
{
    return GL_OrthoxContextANGLE(ctx, l, r, b, t, n, f);
}

void GL_APIENTRY glPatchParameteriContextANGLE(GLeglContext ctx, GLenum pname, GLint value)
{
    return GL_PatchParameteriContextANGLE(ctx, pname, value);
}

void GL_APIENTRY glPatchParameteriEXTContextANGLE(GLeglContext ctx, GLenum pname, GLint value)
{
    return GL_PatchParameteriEXTContextANGLE(ctx, pname, value);
}

void GL_APIENTRY glPauseTransformFeedbackContextANGLE(GLeglContext ctx)
{
    return GL_PauseTransformFeedbackContextANGLE(ctx);
}

void GL_APIENTRY glPixelStoreiContextANGLE(GLeglContext ctx, GLenum pname, GLint param)
{
    return GL_PixelStoreiContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glPointParameterfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
{
    return GL_PointParameterfContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glPointParameterfvContextANGLE(GLeglContext ctx,
                                                GLenum pname,
                                                const GLfloat *params)
{
    return GL_PointParameterfvContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glPointParameterxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
{
    return GL_PointParameterxContextANGLE(ctx, pname, param);
}

void GL_APIENTRY glPointParameterxvContextANGLE(GLeglContext ctx,
                                                GLenum pname,
                                                const GLfixed *params)
{
    return GL_PointParameterxvContextANGLE(ctx, pname, params);
}

void GL_APIENTRY glPointSizeContextANGLE(GLeglContext ctx, GLfloat size)
{
    return GL_PointSizeContextANGLE(ctx, size);
}

void GL_APIENTRY glPointSizePointerOESContextANGLE(GLeglContext ctx,
                                                   GLenum type,
                                                   GLsizei stride,
                                                   const void *pointer)
{
    return GL_PointSizePointerOESContextANGLE(ctx, type, stride, pointer);
}

void GL_APIENTRY glPointSizexContextANGLE(GLeglContext ctx, GLfixed size)
{
    return GL_PointSizexContextANGLE(ctx, size);
}

void GL_APIENTRY glPolygonOffsetContextANGLE(GLeglContext ctx, GLfloat factor, GLfloat units)
{
    return GL_PolygonOffsetContextANGLE(ctx, factor, units);
}

void GL_APIENTRY glPolygonOffsetxContextANGLE(GLeglContext ctx, GLfixed factor, GLfixed units)
{
    return GL_PolygonOffsetxContextANGLE(ctx, factor, units);
}

void GL_APIENTRY glPopDebugGroupContextANGLE(GLeglContext ctx)
{
    return GL_PopDebugGroupContextANGLE(ctx);
}

void GL_APIENTRY glPopDebugGroupKHRContextANGLE(GLeglContext ctx)
{
    return GL_PopDebugGroupKHRContextANGLE(ctx);
}

void GL_APIENTRY glPopGroupMarkerEXTContextANGLE(GLeglContext ctx)
{
    return GL_PopGroupMarkerEXTContextANGLE(ctx);
}

void GL_APIENTRY glPopMatrixContextANGLE(GLeglContext ctx)
{
    return GL_PopMatrixContextANGLE(ctx);
}

void GL_APIENTRY glPrimitiveBoundingBoxContextANGLE(GLeglContext ctx,
                                                    GLfloat minX,
                                                    GLfloat minY,
                                                    GLfloat minZ,
                                                    GLfloat minW,
                                                    GLfloat maxX,
                                                    GLfloat maxY,
                                                    GLfloat maxZ,
                                                    GLfloat maxW)
{
    return GL_PrimitiveBoundingBoxContextANGLE(ctx, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}

void GL_APIENTRY glPrimitiveBoundingBoxEXTContextANGLE(GLeglContext ctx,
                                                       GLfloat minX,
                                                       GLfloat minY,
                                                       GLfloat minZ,
                                                       GLfloat minW,
                                                       GLfloat maxX,
                                                       GLfloat maxY,
                                                       GLfloat maxZ,
                                                       GLfloat maxW)
{
    return GL_PrimitiveBoundingBoxEXTContextANGLE(ctx, minX, minY, minZ, minW, maxX, maxY, maxZ,
                                                  maxW);
}

void GL_APIENTRY glProgramBinaryContextANGLE(GLeglContext ctx,
                                             GLuint program,
                                             GLenum binaryFormat,
                                             const void *binary,
                                             GLsizei length)
{
    return GL_ProgramBinaryContextANGLE(ctx, program, binaryFormat, binary, length);
}

void GL_APIENTRY glProgramBinaryOESContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLenum binaryFormat,
                                                const void *binary,
                                                GLint length)
{
    return GL_ProgramBinaryOESContextANGLE(ctx, program, binaryFormat, binary, length);
}

void GL_APIENTRY glProgramParameteriContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLenum pname,
                                                 GLint value)
{
    return GL_ProgramParameteriContextANGLE(ctx, program, pname, value);
}

void GL_APIENTRY glProgramParameteriEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLenum pname,
                                                    GLint value)
{
    return GL_ProgramParameteriEXTContextANGLE(ctx, program, pname, value);
}

void GL_APIENTRY glProgramUniform1fContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLfloat v0)
{
    return GL_ProgramUniform1fContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1fEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLfloat v0)
{
    return GL_ProgramUniform1fEXTContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1fvContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value)
{
    return GL_ProgramUniform1fvContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform1fvEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLfloat *value)
{
    return GL_ProgramUniform1fvEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform1iContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLint v0)
{
    return GL_ProgramUniform1iContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1iEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLint v0)
{
    return GL_ProgramUniform1iEXTContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1ivContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLint *value)
{
    return GL_ProgramUniform1ivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform1ivEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLint *value)
{
    return GL_ProgramUniform1ivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform1uiContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLuint v0)
{
    return GL_ProgramUniform1uiContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1uiEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLuint v0)
{
    return GL_ProgramUniform1uiEXTContextANGLE(ctx, program, location, v0);
}

void GL_APIENTRY glProgramUniform1uivContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  const GLuint *value)
{
    return GL_ProgramUniform1uivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform1uivEXTContextANGLE(GLeglContext ctx,
                                                     GLuint program,
                                                     GLint location,
                                                     GLsizei count,
                                                     const GLuint *value)
{
    return GL_ProgramUniform1uivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform2fContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLfloat v0,
                                                GLfloat v1)
{
    return GL_ProgramUniform2fContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2fEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLfloat v0,
                                                   GLfloat v1)
{
    return GL_ProgramUniform2fEXTContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2fvContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value)
{
    return GL_ProgramUniform2fvContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform2fvEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLfloat *value)
{
    return GL_ProgramUniform2fvEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY
glProgramUniform2iContextANGLE(GLeglContext ctx, GLuint program, GLint location, GLint v0, GLint v1)
{
    return GL_ProgramUniform2iContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2iEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLint v0,
                                                   GLint v1)
{
    return GL_ProgramUniform2iEXTContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2ivContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLint *value)
{
    return GL_ProgramUniform2ivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform2ivEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLint *value)
{
    return GL_ProgramUniform2ivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform2uiContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLuint v0,
                                                 GLuint v1)
{
    return GL_ProgramUniform2uiContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2uiEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLuint v0,
                                                    GLuint v1)
{
    return GL_ProgramUniform2uiEXTContextANGLE(ctx, program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2uivContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  const GLuint *value)
{
    return GL_ProgramUniform2uivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform2uivEXTContextANGLE(GLeglContext ctx,
                                                     GLuint program,
                                                     GLint location,
                                                     GLsizei count,
                                                     const GLuint *value)
{
    return GL_ProgramUniform2uivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3fContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLfloat v0,
                                                GLfloat v1,
                                                GLfloat v2)
{
    return GL_ProgramUniform3fContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3fEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLfloat v0,
                                                   GLfloat v1,
                                                   GLfloat v2)
{
    return GL_ProgramUniform3fEXTContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3fvContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value)
{
    return GL_ProgramUniform3fvContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3fvEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLfloat *value)
{
    return GL_ProgramUniform3fvEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3iContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLint v0,
                                                GLint v1,
                                                GLint v2)
{
    return GL_ProgramUniform3iContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3iEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLint v0,
                                                   GLint v1,
                                                   GLint v2)
{
    return GL_ProgramUniform3iEXTContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3ivContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLint *value)
{
    return GL_ProgramUniform3ivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3ivEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLint *value)
{
    return GL_ProgramUniform3ivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3uiContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLuint v0,
                                                 GLuint v1,
                                                 GLuint v2)
{
    return GL_ProgramUniform3uiContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3uiEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLuint v0,
                                                    GLuint v1,
                                                    GLuint v2)
{
    return GL_ProgramUniform3uiEXTContextANGLE(ctx, program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3uivContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  const GLuint *value)
{
    return GL_ProgramUniform3uivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform3uivEXTContextANGLE(GLeglContext ctx,
                                                     GLuint program,
                                                     GLint location,
                                                     GLsizei count,
                                                     const GLuint *value)
{
    return GL_ProgramUniform3uivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4fContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLfloat v0,
                                                GLfloat v1,
                                                GLfloat v2,
                                                GLfloat v3)
{
    return GL_ProgramUniform4fContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4fEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLfloat v0,
                                                   GLfloat v1,
                                                   GLfloat v2,
                                                   GLfloat v3)
{
    return GL_ProgramUniform4fEXTContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4fvContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value)
{
    return GL_ProgramUniform4fvContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4fvEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLfloat *value)
{
    return GL_ProgramUniform4fvEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4iContextANGLE(GLeglContext ctx,
                                                GLuint program,
                                                GLint location,
                                                GLint v0,
                                                GLint v1,
                                                GLint v2,
                                                GLint v3)
{
    return GL_ProgramUniform4iContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4iEXTContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLint location,
                                                   GLint v0,
                                                   GLint v1,
                                                   GLint v2,
                                                   GLint v3)
{
    return GL_ProgramUniform4iEXTContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4ivContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLint *value)
{
    return GL_ProgramUniform4ivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4ivEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLsizei count,
                                                    const GLint *value)
{
    return GL_ProgramUniform4ivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4uiContextANGLE(GLeglContext ctx,
                                                 GLuint program,
                                                 GLint location,
                                                 GLuint v0,
                                                 GLuint v1,
                                                 GLuint v2,
                                                 GLuint v3)
{
    return GL_ProgramUniform4uiContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4uiEXTContextANGLE(GLeglContext ctx,
                                                    GLuint program,
                                                    GLint location,
                                                    GLuint v0,
                                                    GLuint v1,
                                                    GLuint v2,
                                                    GLuint v3)
{
    return GL_ProgramUniform4uiEXTContextANGLE(ctx, program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4uivContextANGLE(GLeglContext ctx,
                                                  GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  const GLuint *value)
{
    return GL_ProgramUniform4uivContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniform4uivEXTContextANGLE(GLeglContext ctx,
                                                     GLuint program,
                                                     GLint location,
                                                     GLsizei count,
                                                     const GLuint *value)
{
    return GL_ProgramUniform4uivEXTContextANGLE(ctx, program, location, count, value);
}

void GL_APIENTRY glProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLint location,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value)
{
    return GL_ProgramUniformMatrix2fvContextANGLE(ctx, program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix2fvEXTContextANGLE(GLeglContext ctx,
                                                          GLuint program,
                                                          GLint location,
                                                          GLsizei count,
                                                          GLboolean transpose,
                                                          const GLfloat *value)
{
    return GL_ProgramUniformMatrix2fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                     value);
}

void GL_APIENTRY glProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x3fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix2x3fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x3fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x4fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix2x4fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix2x4fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLint location,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value)
{
    return GL_ProgramUniformMatrix3fvContextANGLE(ctx, program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix3fvEXTContextANGLE(GLeglContext ctx,
                                                          GLuint program,
                                                          GLint location,
                                                          GLsizei count,
                                                          GLboolean transpose,
                                                          const GLfloat *value)
{
    return GL_ProgramUniformMatrix3fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                     value);
}

void GL_APIENTRY glProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x2fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix3x2fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x2fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x4fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix3x4fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix3x4fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLint location,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value)
{
    return GL_ProgramUniformMatrix4fvContextANGLE(ctx, program, location, count, transpose, value);
}

void GL_APIENTRY glProgramUniformMatrix4fvEXTContextANGLE(GLeglContext ctx,
                                                          GLuint program,
                                                          GLint location,
                                                          GLsizei count,
                                                          GLboolean transpose,
                                                          const GLfloat *value)
{
    return GL_ProgramUniformMatrix4fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                     value);
}

void GL_APIENTRY glProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x2fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix4x2fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x2fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x3fvContextANGLE(ctx, program, location, count, transpose,
                                                    value);
}

void GL_APIENTRY glProgramUniformMatrix4x3fvEXTContextANGLE(GLeglContext ctx,
                                                            GLuint program,
                                                            GLint location,
                                                            GLsizei count,
                                                            GLboolean transpose,
                                                            const GLfloat *value)
{
    return GL_ProgramUniformMatrix4x3fvEXTContextANGLE(ctx, program, location, count, transpose,
                                                       value);
}

void GL_APIENTRY glPushDebugGroupContextANGLE(GLeglContext ctx,
                                              GLenum source,
                                              GLuint id,
                                              GLsizei length,
                                              const GLchar *message)
{
    return GL_PushDebugGroupContextANGLE(ctx, source, id, length, message);
}

void GL_APIENTRY glPushDebugGroupKHRContextANGLE(GLeglContext ctx,
                                                 GLenum source,
                                                 GLuint id,
                                                 GLsizei length,
                                                 const GLchar *message)
{
    return GL_PushDebugGroupKHRContextANGLE(ctx, source, id, length, message);
}

void GL_APIENTRY glPushGroupMarkerEXTContextANGLE(GLeglContext ctx,
                                                  GLsizei length,
                                                  const GLchar *marker)
{
    return GL_PushGroupMarkerEXTContextANGLE(ctx, length, marker);
}

void GL_APIENTRY glPushMatrixContextANGLE(GLeglContext ctx)
{
    return GL_PushMatrixContextANGLE(ctx);
}

void GL_APIENTRY glQueryCounterEXTContextANGLE(GLeglContext ctx, GLuint id, GLenum target)
{
    return GL_QueryCounterEXTContextANGLE(ctx, id, target);
}

GLbitfield GL_APIENTRY glQueryMatrixxOESContextANGLE(GLeglContext ctx,
                                                     GLfixed *mantissa,
                                                     GLint *exponent)
{
    return GL_QueryMatrixxOESContextANGLE(ctx, mantissa, exponent);
}

void GL_APIENTRY glReadBufferContextANGLE(GLeglContext ctx, GLenum src)
{
    return GL_ReadBufferContextANGLE(ctx, src);
}

void GL_APIENTRY glReadPixelsContextANGLE(GLeglContext ctx,
                                          GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height,
                                          GLenum format,
                                          GLenum type,
                                          void *pixels)
{
    return GL_ReadPixelsContextANGLE(ctx, x, y, width, height, format, type, pixels);
}

void GL_APIENTRY glReadnPixelsContextANGLE(GLeglContext ctx,
                                           GLint x,
                                           GLint y,
                                           GLsizei width,
                                           GLsizei height,
                                           GLenum format,
                                           GLenum type,
                                           GLsizei bufSize,
                                           void *data)
{
    return GL_ReadnPixelsContextANGLE(ctx, x, y, width, height, format, type, bufSize, data);
}

void GL_APIENTRY glReadnPixelsEXTContextANGLE(GLeglContext ctx,
                                              GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height,
                                              GLenum format,
                                              GLenum type,
                                              GLsizei bufSize,
                                              void *data)
{
    return GL_ReadnPixelsEXTContextANGLE(ctx, x, y, width, height, format, type, bufSize, data);
}

void GL_APIENTRY glReleaseShaderCompilerContextANGLE(GLeglContext ctx)
{
    return GL_ReleaseShaderCompilerContextANGLE(ctx);
}

void GL_APIENTRY glRenderbufferStorageContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLenum internalformat,
                                                   GLsizei width,
                                                   GLsizei height)
{
    return GL_RenderbufferStorageContextANGLE(ctx, target, internalformat, width, height);
}

void GL_APIENTRY glRenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,
                                                              GLenum target,
                                                              GLsizei samples,
                                                              GLenum internalformat,
                                                              GLsizei width,
                                                              GLsizei height)
{
    return GL_RenderbufferStorageMultisampleContextANGLE(ctx, target, samples, internalformat,
                                                         width, height);
}

void GL_APIENTRY glRenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,
                                                                   GLenum target,
                                                                   GLsizei samples,
                                                                   GLenum internalformat,
                                                                   GLsizei width,
                                                                   GLsizei height)
{
    return GL_RenderbufferStorageMultisampleANGLEContextANGLE(ctx, target, samples, internalformat,
                                                              width, height);
}

void GL_APIENTRY glRenderbufferStorageMultisampleEXTContextANGLE(GLeglContext ctx,
                                                                 GLenum target,
                                                                 GLsizei samples,
                                                                 GLenum internalformat,
                                                                 GLsizei width,
                                                                 GLsizei height)
{
    return GL_RenderbufferStorageMultisampleEXTContextANGLE(ctx, target, samples, internalformat,
                                                            width, height);
}

void GL_APIENTRY glRenderbufferStorageOESContextANGLE(GLeglContext ctx,
                                                      GLenum target,
                                                      GLenum internalformat,
                                                      GLsizei width,
                                                      GLsizei height)
{
    return GL_RenderbufferStorageOESContextANGLE(ctx, target, internalformat, width, height);
}

void GL_APIENTRY glResumeTransformFeedbackContextANGLE(GLeglContext ctx)
{
    return GL_ResumeTransformFeedbackContextANGLE(ctx);
}

void GL_APIENTRY
glRotatefContextANGLE(GLeglContext ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_RotatefContextANGLE(ctx, angle, x, y, z);
}

void GL_APIENTRY
glRotatexContextANGLE(GLeglContext ctx, GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
    return GL_RotatexContextANGLE(ctx, angle, x, y, z);
}

void GL_APIENTRY glSampleCoverageContextANGLE(GLeglContext ctx, GLfloat value, GLboolean invert)
{
    return GL_SampleCoverageContextANGLE(ctx, value, invert);
}

void GL_APIENTRY glSampleCoveragexContextANGLE(GLeglContext ctx, GLclampx value, GLboolean invert)
{
    return GL_SampleCoveragexContextANGLE(ctx, value, invert);
}

void GL_APIENTRY glSampleMaskiContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
{
    return GL_SampleMaskiContextANGLE(ctx, maskNumber, mask);
}

void GL_APIENTRY glSamplerParameterIivContextANGLE(GLeglContext ctx,
                                                   GLuint sampler,
                                                   GLenum pname,
                                                   const GLint *param)
{
    return GL_SamplerParameterIivContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIivEXTContextANGLE(GLeglContext ctx,
                                                      GLuint sampler,
                                                      GLenum pname,
                                                      const GLint *param)
{
    return GL_SamplerParameterIivEXTContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIivOESContextANGLE(GLeglContext ctx,
                                                      GLuint sampler,
                                                      GLenum pname,
                                                      const GLint *param)
{
    return GL_SamplerParameterIivOESContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuivContextANGLE(GLeglContext ctx,
                                                    GLuint sampler,
                                                    GLenum pname,
                                                    const GLuint *param)
{
    return GL_SamplerParameterIuivContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuivEXTContextANGLE(GLeglContext ctx,
                                                       GLuint sampler,
                                                       GLenum pname,
                                                       const GLuint *param)
{
    return GL_SamplerParameterIuivEXTContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
                                                       GLuint sampler,
                                                       GLenum pname,
                                                       const GLuint *param)
{
    return GL_SamplerParameterIuivOESContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterfContextANGLE(GLeglContext ctx,
                                                 GLuint sampler,
                                                 GLenum pname,
                                                 GLfloat param)
{
    return GL_SamplerParameterfContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterfvContextANGLE(GLeglContext ctx,
                                                  GLuint sampler,
                                                  GLenum pname,
                                                  const GLfloat *param)
{
    return GL_SamplerParameterfvContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameteriContextANGLE(GLeglContext ctx,
                                                 GLuint sampler,
                                                 GLenum pname,
                                                 GLint param)
{
    return GL_SamplerParameteriContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glSamplerParameterivContextANGLE(GLeglContext ctx,
                                                  GLuint sampler,
                                                  GLenum pname,
                                                  const GLint *param)
{
    return GL_SamplerParameterivContextANGLE(ctx, sampler, pname, param);
}

void GL_APIENTRY glScalefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_ScalefContextANGLE(ctx, x, y, z);
}

void GL_APIENTRY glScalexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
{
    return GL_ScalexContextANGLE(ctx, x, y, z);
}

void GL_APIENTRY
glScissorContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
{
    return GL_ScissorContextANGLE(ctx, x, y, width, height);
}

void GL_APIENTRY glSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
                                                          GLuint semaphore,
                                                          GLenum pname,
                                                          const GLuint64 *params)
{
    return GL_SemaphoreParameterui64vEXTContextANGLE(ctx, semaphore, pname, params);
}

void GL_APIENTRY glSetFenceNVContextANGLE(GLeglContext ctx, GLuint fence, GLenum condition)
{
    return GL_SetFenceNVContextANGLE(ctx, fence, condition);
}

void GL_APIENTRY glShadeModelContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_ShadeModelContextANGLE(ctx, mode);
}

void GL_APIENTRY glShaderBinaryContextANGLE(GLeglContext ctx,
                                            GLsizei count,
                                            const GLuint *shaders,
                                            GLenum binaryformat,
                                            const void *binary,
                                            GLsizei length)
{
    return GL_ShaderBinaryContextANGLE(ctx, count, shaders, binaryformat, binary, length);
}

void GL_APIENTRY glShaderSourceContextANGLE(GLeglContext ctx,
                                            GLuint shader,
                                            GLsizei count,
                                            const GLchar *const *string,
                                            const GLint *length)
{
    return GL_ShaderSourceContextANGLE(ctx, shader, count, string, length);
}

void GL_APIENTRY glSignalSemaphoreEXTContextANGLE(GLeglContext ctx,
                                                  GLuint semaphore,
                                                  GLuint numBufferBarriers,
                                                  const GLuint *buffers,
                                                  GLuint numTextureBarriers,
                                                  const GLuint *textures,
                                                  const GLenum *dstLayouts)
{
    return GL_SignalSemaphoreEXTContextANGLE(ctx, semaphore, numBufferBarriers, buffers,
                                             numTextureBarriers, textures, dstLayouts);
}

void GL_APIENTRY glStencilFuncContextANGLE(GLeglContext ctx, GLenum func, GLint ref, GLuint mask)
{
    return GL_StencilFuncContextANGLE(ctx, func, ref, mask);
}

void GL_APIENTRY glStencilFuncSeparateContextANGLE(GLeglContext ctx,
                                                   GLenum face,
                                                   GLenum func,
                                                   GLint ref,
                                                   GLuint mask)
{
    return GL_StencilFuncSeparateContextANGLE(ctx, face, func, ref, mask);
}

void GL_APIENTRY glStencilMaskContextANGLE(GLeglContext ctx, GLuint mask)
{
    return GL_StencilMaskContextANGLE(ctx, mask);
}

void GL_APIENTRY glStencilMaskSeparateContextANGLE(GLeglContext ctx, GLenum face, GLuint mask)
{
    return GL_StencilMaskSeparateContextANGLE(ctx, face, mask);
}

void GL_APIENTRY glStencilOpContextANGLE(GLeglContext ctx, GLenum fail, GLenum zfail, GLenum zpass)
{
    return GL_StencilOpContextANGLE(ctx, fail, zfail, zpass);
}

void GL_APIENTRY glStencilOpSeparateContextANGLE(GLeglContext ctx,
                                                 GLenum face,
                                                 GLenum sfail,
                                                 GLenum dpfail,
                                                 GLenum dppass)
{
    return GL_StencilOpSeparateContextANGLE(ctx, face, sfail, dpfail, dppass);
}

GLboolean GL_APIENTRY glTestFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
{
    return GL_TestFenceNVContextANGLE(ctx, fence);
}

void GL_APIENTRY glTexBufferContextANGLE(GLeglContext ctx,
                                         GLenum target,
                                         GLenum internalformat,
                                         GLuint buffer)
{
    return GL_TexBufferContextANGLE(ctx, target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferEXTContextANGLE(GLeglContext ctx,
                                            GLenum target,
                                            GLenum internalformat,
                                            GLuint buffer)
{
    return GL_TexBufferEXTContextANGLE(ctx, target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferOESContextANGLE(GLeglContext ctx,
                                            GLenum target,
                                            GLenum internalformat,
                                            GLuint buffer)
{
    return GL_TexBufferOESContextANGLE(ctx, target, internalformat, buffer);
}

void GL_APIENTRY glTexBufferRangeContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLenum internalformat,
                                              GLuint buffer,
                                              GLintptr offset,
                                              GLsizeiptr size)
{
    return GL_TexBufferRangeContextANGLE(ctx, target, internalformat, buffer, offset, size);
}

void GL_APIENTRY glTexBufferRangeEXTContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum internalformat,
                                                 GLuint buffer,
                                                 GLintptr offset,
                                                 GLsizeiptr size)
{
    return GL_TexBufferRangeEXTContextANGLE(ctx, target, internalformat, buffer, offset, size);
}

void GL_APIENTRY glTexBufferRangeOESContextANGLE(GLeglContext ctx,
                                                 GLenum target,
                                                 GLenum internalformat,
                                                 GLuint buffer,
                                                 GLintptr offset,
                                                 GLsizeiptr size)
{
    return GL_TexBufferRangeOESContextANGLE(ctx, target, internalformat, buffer, offset, size);
}

void GL_APIENTRY glTexCoordPointerContextANGLE(GLeglContext ctx,
                                               GLint size,
                                               GLenum type,
                                               GLsizei stride,
                                               const void *pointer)
{
    return GL_TexCoordPointerContextANGLE(ctx, size, type, stride, pointer);
}

void GL_APIENTRY glTexEnvfContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfloat param)
{
    return GL_TexEnvfContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexEnvfvContextANGLE(GLeglContext ctx,
                                        GLenum target,
                                        GLenum pname,
                                        const GLfloat *params)
{
    return GL_TexEnvfvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexEnviContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLint param)
{
    return GL_TexEnviContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexEnvivContextANGLE(GLeglContext ctx,
                                        GLenum target,
                                        GLenum pname,
                                        const GLint *params)
{
    return GL_TexEnvivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexEnvxContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfixed param)
{
    return GL_TexEnvxContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexEnvxvContextANGLE(GLeglContext ctx,
                                        GLenum target,
                                        GLenum pname,
                                        const GLfixed *params)
{
    return GL_TexEnvxvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexGenfOESContextANGLE(GLeglContext ctx,
                                          GLenum coord,
                                          GLenum pname,
                                          GLfloat param)
{
    return GL_TexGenfOESContextANGLE(ctx, coord, pname, param);
}

void GL_APIENTRY glTexGenfvOESContextANGLE(GLeglContext ctx,
                                           GLenum coord,
                                           GLenum pname,
                                           const GLfloat *params)
{
    return GL_TexGenfvOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glTexGeniOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLint param)
{
    return GL_TexGeniOESContextANGLE(ctx, coord, pname, param);
}

void GL_APIENTRY glTexGenivOESContextANGLE(GLeglContext ctx,
                                           GLenum coord,
                                           GLenum pname,
                                           const GLint *params)
{
    return GL_TexGenivOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glTexGenxOESContextANGLE(GLeglContext ctx,
                                          GLenum coord,
                                          GLenum pname,
                                          GLfixed param)
{
    return GL_TexGenxOESContextANGLE(ctx, coord, pname, param);
}

void GL_APIENTRY glTexGenxvOESContextANGLE(GLeglContext ctx,
                                           GLenum coord,
                                           GLenum pname,
                                           const GLfixed *params)
{
    return GL_TexGenxvOESContextANGLE(ctx, coord, pname, params);
}

void GL_APIENTRY glTexImage2DContextANGLE(GLeglContext ctx,
                                          GLenum target,
                                          GLint level,
                                          GLint internalformat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLint border,
                                          GLenum format,
                                          GLenum type,
                                          const void *pixels)
{
    return GL_TexImage2DContextANGLE(ctx, target, level, internalformat, width, height, border,
                                     format, type, pixels);
}

void GL_APIENTRY glTexImage3DContextANGLE(GLeglContext ctx,
                                          GLenum target,
                                          GLint level,
                                          GLint internalformat,
                                          GLsizei width,
                                          GLsizei height,
                                          GLsizei depth,
                                          GLint border,
                                          GLenum format,
                                          GLenum type,
                                          const void *pixels)
{
    return GL_TexImage3DContextANGLE(ctx, target, level, internalformat, width, height, depth,
                                     border, format, type, pixels);
}

void GL_APIENTRY glTexImage3DOESContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLint level,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLint border,
                                             GLenum format,
                                             GLenum type,
                                             const void *pixels)
{
    return GL_TexImage3DOESContextANGLE(ctx, target, level, internalformat, width, height, depth,
                                        border, format, type, pixels);
}

void GL_APIENTRY glTexParameterIivContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLenum pname,
                                               const GLint *params)
{
    return GL_TexParameterIivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterIivEXTContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLenum pname,
                                                  const GLint *params)
{
    return GL_TexParameterIivEXTContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterIivOESContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLenum pname,
                                                  const GLint *params)
{
    return GL_TexParameterIivOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterIuivContextANGLE(GLeglContext ctx,
                                                GLenum target,
                                                GLenum pname,
                                                const GLuint *params)
{
    return GL_TexParameterIuivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterIuivEXTContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLenum pname,
                                                   const GLuint *params)
{
    return GL_TexParameterIuivEXTContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterIuivOESContextANGLE(GLeglContext ctx,
                                                   GLenum target,
                                                   GLenum pname,
                                                   const GLuint *params)
{
    return GL_TexParameterIuivOESContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterfContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLenum pname,
                                             GLfloat param)
{
    return GL_TexParameterfContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexParameterfvContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLenum pname,
                                              const GLfloat *params)
{
    return GL_TexParameterfvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameteriContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLenum pname,
                                             GLint param)
{
    return GL_TexParameteriContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexParameterivContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLenum pname,
                                              const GLint *params)
{
    return GL_TexParameterivContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexParameterxContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLenum pname,
                                             GLfixed param)
{
    return GL_TexParameterxContextANGLE(ctx, target, pname, param);
}

void GL_APIENTRY glTexParameterxvContextANGLE(GLeglContext ctx,
                                              GLenum target,
                                              GLenum pname,
                                              const GLfixed *params)
{
    return GL_TexParameterxvContextANGLE(ctx, target, pname, params);
}

void GL_APIENTRY glTexStorage1DEXTContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLsizei levels,
                                               GLenum internalformat,
                                               GLsizei width)
{
    return GL_TexStorage1DEXTContextANGLE(ctx, target, levels, internalformat, width);
}

void GL_APIENTRY glTexStorage2DContextANGLE(GLeglContext ctx,
                                            GLenum target,
                                            GLsizei levels,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height)
{
    return GL_TexStorage2DContextANGLE(ctx, target, levels, internalformat, width, height);
}

void GL_APIENTRY glTexStorage2DEXTContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLsizei levels,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height)
{
    return GL_TexStorage2DEXTContextANGLE(ctx, target, levels, internalformat, width, height);
}

void GL_APIENTRY glTexStorage2DMultisampleContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLboolean fixedsamplelocations)
{
    return GL_TexStorage2DMultisampleContextANGLE(ctx, target, samples, internalformat, width,
                                                  height, fixedsamplelocations);
}

void GL_APIENTRY glTexStorage3DContextANGLE(GLeglContext ctx,
                                            GLenum target,
                                            GLsizei levels,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth)
{
    return GL_TexStorage3DContextANGLE(ctx, target, levels, internalformat, width, height, depth);
}

void GL_APIENTRY glTexStorage3DEXTContextANGLE(GLeglContext ctx,
                                               GLenum target,
                                               GLsizei levels,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth)
{
    return GL_TexStorage3DEXTContextANGLE(ctx, target, levels, internalformat, width, height,
                                          depth);
}

void GL_APIENTRY glTexStorage3DMultisampleContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLsizei depth,
                                                       GLboolean fixedsamplelocations)
{
    return GL_TexStorage3DMultisampleContextANGLE(ctx, target, samples, internalformat, width,
                                                  height, depth, fixedsamplelocations);
}

void GL_APIENTRY glTexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLsizei samples,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth,
                                                          GLboolean fixedsamplelocations)
{
    return GL_TexStorage3DMultisampleOESContextANGLE(ctx, target, samples, internalformat, width,
                                                     height, depth, fixedsamplelocations);
}

void GL_APIENTRY glTexStorageMem2DEXTContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLsizei levels,
                                                  GLenum internalFormat,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLuint memory,
                                                  GLuint64 offset)
{
    return GL_TexStorageMem2DEXTContextANGLE(ctx, target, levels, internalFormat, width, height,
                                             memory, offset);
}

void GL_APIENTRY glTexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,
                                                             GLenum target,
                                                             GLsizei samples,
                                                             GLenum internalFormat,
                                                             GLsizei width,
                                                             GLsizei height,
                                                             GLboolean fixedSampleLocations,
                                                             GLuint memory,
                                                             GLuint64 offset)
{
    return GL_TexStorageMem2DMultisampleEXTContextANGLE(
        ctx, target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
}

void GL_APIENTRY glTexStorageMem3DEXTContextANGLE(GLeglContext ctx,
                                                  GLenum target,
                                                  GLsizei levels,
                                                  GLenum internalFormat,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLsizei depth,
                                                  GLuint memory,
                                                  GLuint64 offset)
{
    return GL_TexStorageMem3DEXTContextANGLE(ctx, target, levels, internalFormat, width, height,
                                             depth, memory, offset);
}

void GL_APIENTRY glTexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,
                                                             GLenum target,
                                                             GLsizei samples,
                                                             GLenum internalFormat,
                                                             GLsizei width,
                                                             GLsizei height,
                                                             GLsizei depth,
                                                             GLboolean fixedSampleLocations,
                                                             GLuint memory,
                                                             GLuint64 offset)
{
    return GL_TexStorageMem3DMultisampleEXTContextANGLE(ctx, target, samples, internalFormat, width,
                                                        height, depth, fixedSampleLocations, memory,
                                                        offset);
}

void GL_APIENTRY glTexSubImage2DContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLenum type,
                                             const void *pixels)
{
    return GL_TexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, width, height, format,
                                        type, pixels);
}

void GL_APIENTRY glTexSubImage3DContextANGLE(GLeglContext ctx,
                                             GLenum target,
                                             GLint level,
                                             GLint xoffset,
                                             GLint yoffset,
                                             GLint zoffset,
                                             GLsizei width,
                                             GLsizei height,
                                             GLsizei depth,
                                             GLenum format,
                                             GLenum type,
                                             const void *pixels)
{
    return GL_TexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, width,
                                        height, depth, format, type, pixels);
}

void GL_APIENTRY glTexSubImage3DOESContextANGLE(GLeglContext ctx,
                                                GLenum target,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLenum format,
                                                GLenum type,
                                                const void *pixels)
{
    return GL_TexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, width,
                                           height, depth, format, type, pixels);
}

void GL_APIENTRY glTransformFeedbackVaryingsContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLsizei count,
                                                         const GLchar *const *varyings,
                                                         GLenum bufferMode)
{
    return GL_TransformFeedbackVaryingsContextANGLE(ctx, program, count, varyings, bufferMode);
}

void GL_APIENTRY glTranslatefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_TranslatefContextANGLE(ctx, x, y, z);
}

void GL_APIENTRY glTranslatexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
{
    return GL_TranslatexContextANGLE(ctx, x, y, z);
}

void GL_APIENTRY glUniform1fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0)
{
    return GL_Uniform1fContextANGLE(ctx, location, v0);
}

void GL_APIENTRY glUniform1fvContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat *value)
{
    return GL_Uniform1fvContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform1iContextANGLE(GLeglContext ctx, GLint location, GLint v0)
{
    return GL_Uniform1iContextANGLE(ctx, location, v0);
}

void GL_APIENTRY glUniform1ivContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLint *value)
{
    return GL_Uniform1ivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform1uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0)
{
    return GL_Uniform1uiContextANGLE(ctx, location, v0);
}

void GL_APIENTRY glUniform1uivContextANGLE(GLeglContext ctx,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint *value)
{
    return GL_Uniform1uivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform2fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1)
{
    return GL_Uniform2fContextANGLE(ctx, location, v0, v1);
}

void GL_APIENTRY glUniform2fvContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat *value)
{
    return GL_Uniform2fvContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform2iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1)
{
    return GL_Uniform2iContextANGLE(ctx, location, v0, v1);
}

void GL_APIENTRY glUniform2ivContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLint *value)
{
    return GL_Uniform2ivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform2uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1)
{
    return GL_Uniform2uiContextANGLE(ctx, location, v0, v1);
}

void GL_APIENTRY glUniform2uivContextANGLE(GLeglContext ctx,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint *value)
{
    return GL_Uniform2uivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY
glUniform3fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
    return GL_Uniform3fContextANGLE(ctx, location, v0, v1, v2);
}

void GL_APIENTRY glUniform3fvContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat *value)
{
    return GL_Uniform3fvContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY
glUniform3iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2)
{
    return GL_Uniform3iContextANGLE(ctx, location, v0, v1, v2);
}

void GL_APIENTRY glUniform3ivContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLint *value)
{
    return GL_Uniform3ivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY
glUniform3uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
    return GL_Uniform3uiContextANGLE(ctx, location, v0, v1, v2);
}

void GL_APIENTRY glUniform3uivContextANGLE(GLeglContext ctx,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint *value)
{
    return GL_Uniform3uivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform4fContextANGLE(GLeglContext ctx,
                                         GLint location,
                                         GLfloat v0,
                                         GLfloat v1,
                                         GLfloat v2,
                                         GLfloat v3)
{
    return GL_Uniform4fContextANGLE(ctx, location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4fvContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLfloat *value)
{
    return GL_Uniform4fvContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY
glUniform4iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
    return GL_Uniform4iContextANGLE(ctx, location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4ivContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLsizei count,
                                          const GLint *value)
{
    return GL_Uniform4ivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniform4uiContextANGLE(GLeglContext ctx,
                                          GLint location,
                                          GLuint v0,
                                          GLuint v1,
                                          GLuint v2,
                                          GLuint v3)
{
    return GL_Uniform4uiContextANGLE(ctx, location, v0, v1, v2, v3);
}

void GL_APIENTRY glUniform4uivContextANGLE(GLeglContext ctx,
                                           GLint location,
                                           GLsizei count,
                                           const GLuint *value)
{
    return GL_Uniform4uivContextANGLE(ctx, location, count, value);
}

void GL_APIENTRY glUniformBlockBindingContextANGLE(GLeglContext ctx,
                                                   GLuint program,
                                                   GLuint uniformBlockIndex,
                                                   GLuint uniformBlockBinding)
{
    return GL_UniformBlockBindingContextANGLE(ctx, program, uniformBlockIndex, uniformBlockBinding);
}

void GL_APIENTRY glUniformMatrix2fvContextANGLE(GLeglContext ctx,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_UniformMatrix2fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix2x3fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix2x4fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3fvContextANGLE(GLeglContext ctx,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_UniformMatrix3fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix3x2fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix3x4fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4fvContextANGLE(GLeglContext ctx,
                                                GLint location,
                                                GLsizei count,
                                                GLboolean transpose,
                                                const GLfloat *value)
{
    return GL_UniformMatrix4fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix4x2fvContextANGLE(ctx, location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
                                                  GLint location,
                                                  GLsizei count,
                                                  GLboolean transpose,
                                                  const GLfloat *value)
{
    return GL_UniformMatrix4x3fvContextANGLE(ctx, location, count, transpose, value);
}

GLboolean GL_APIENTRY glUnmapBufferContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_UnmapBufferContextANGLE(ctx, target);
}

GLboolean GL_APIENTRY glUnmapBufferOESContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_UnmapBufferOESContextANGLE(ctx, target);
}

void GL_APIENTRY glUseProgramContextANGLE(GLeglContext ctx, GLuint program)
{
    return GL_UseProgramContextANGLE(ctx, program);
}

void GL_APIENTRY glUseProgramStagesContextANGLE(GLeglContext ctx,
                                                GLuint pipeline,
                                                GLbitfield stages,
                                                GLuint program)
{
    return GL_UseProgramStagesContextANGLE(ctx, pipeline, stages, program);
}

void GL_APIENTRY glUseProgramStagesEXTContextANGLE(GLeglContext ctx,
                                                   GLuint pipeline,
                                                   GLbitfield stages,
                                                   GLuint program)
{
    return GL_UseProgramStagesEXTContextANGLE(ctx, pipeline, stages, program);
}

void GL_APIENTRY glValidateProgramContextANGLE(GLeglContext ctx, GLuint program)
{
    return GL_ValidateProgramContextANGLE(ctx, program);
}

void GL_APIENTRY glValidateProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_ValidateProgramPipelineContextANGLE(ctx, pipeline);
}

void GL_APIENTRY glValidateProgramPipelineEXTContextANGLE(GLeglContext ctx, GLuint pipeline)
{
    return GL_ValidateProgramPipelineEXTContextANGLE(ctx, pipeline);
}

void GL_APIENTRY glVertexAttrib1fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x)
{
    return GL_VertexAttrib1fContextANGLE(ctx, index, x);
}

void GL_APIENTRY glVertexAttrib1fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib1fvContextANGLE(ctx, index, v);
}

void GL_APIENTRY glVertexAttrib2fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y)
{
    return GL_VertexAttrib2fContextANGLE(ctx, index, x, y);
}

void GL_APIENTRY glVertexAttrib2fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib2fvContextANGLE(ctx, index, v);
}

void GL_APIENTRY
glVertexAttrib3fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
    return GL_VertexAttrib3fContextANGLE(ctx, index, x, y, z);
}

void GL_APIENTRY glVertexAttrib3fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib3fvContextANGLE(ctx, index, v);
}

void GL_APIENTRY glVertexAttrib4fContextANGLE(GLeglContext ctx,
                                              GLuint index,
                                              GLfloat x,
                                              GLfloat y,
                                              GLfloat z,
                                              GLfloat w)
{
    return GL_VertexAttrib4fContextANGLE(ctx, index, x, y, z, w);
}

void GL_APIENTRY glVertexAttrib4fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
{
    return GL_VertexAttrib4fvContextANGLE(ctx, index, v);
}

void GL_APIENTRY glVertexAttribBindingContextANGLE(GLeglContext ctx,
                                                   GLuint attribindex,
                                                   GLuint bindingindex)
{
    return GL_VertexAttribBindingContextANGLE(ctx, attribindex, bindingindex);
}

void GL_APIENTRY glVertexAttribDivisorContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
{
    return GL_VertexAttribDivisorContextANGLE(ctx, index, divisor);
}

void GL_APIENTRY glVertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,
                                                        GLuint index,
                                                        GLuint divisor)
{
    return GL_VertexAttribDivisorANGLEContextANGLE(ctx, index, divisor);
}

void GL_APIENTRY glVertexAttribDivisorEXTContextANGLE(GLeglContext ctx,
                                                      GLuint index,
                                                      GLuint divisor)
{
    return GL_VertexAttribDivisorEXTContextANGLE(ctx, index, divisor);
}

void GL_APIENTRY glVertexAttribFormatContextANGLE(GLeglContext ctx,
                                                  GLuint attribindex,
                                                  GLint size,
                                                  GLenum type,
                                                  GLboolean normalized,
                                                  GLuint relativeoffset)
{
    return GL_VertexAttribFormatContextANGLE(ctx, attribindex, size, type, normalized,
                                             relativeoffset);
}

void GL_APIENTRY
glVertexAttribI4iContextANGLE(GLeglContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
    return GL_VertexAttribI4iContextANGLE(ctx, index, x, y, z, w);
}

void GL_APIENTRY glVertexAttribI4ivContextANGLE(GLeglContext ctx, GLuint index, const GLint *v)
{
    return GL_VertexAttribI4ivContextANGLE(ctx, index, v);
}

void GL_APIENTRY glVertexAttribI4uiContextANGLE(GLeglContext ctx,
                                                GLuint index,
                                                GLuint x,
                                                GLuint y,
                                                GLuint z,
                                                GLuint w)
{
    return GL_VertexAttribI4uiContextANGLE(ctx, index, x, y, z, w);
}

void GL_APIENTRY glVertexAttribI4uivContextANGLE(GLeglContext ctx, GLuint index, const GLuint *v)
{
    return GL_VertexAttribI4uivContextANGLE(ctx, index, v);
}

void GL_APIENTRY glVertexAttribIFormatContextANGLE(GLeglContext ctx,
                                                   GLuint attribindex,
                                                   GLint size,
                                                   GLenum type,
                                                   GLuint relativeoffset)
{
    return GL_VertexAttribIFormatContextANGLE(ctx, attribindex, size, type, relativeoffset);
}

void GL_APIENTRY glVertexAttribIPointerContextANGLE(GLeglContext ctx,
                                                    GLuint index,
                                                    GLint size,
                                                    GLenum type,
                                                    GLsizei stride,
                                                    const void *pointer)
{
    return GL_VertexAttribIPointerContextANGLE(ctx, index, size, type, stride, pointer);
}

void GL_APIENTRY glVertexAttribPointerContextANGLE(GLeglContext ctx,
                                                   GLuint index,
                                                   GLint size,
                                                   GLenum type,
                                                   GLboolean normalized,
                                                   GLsizei stride,
                                                   const void *pointer)
{
    return GL_VertexAttribPointerContextANGLE(ctx, index, size, type, normalized, stride, pointer);
}

void GL_APIENTRY glVertexBindingDivisorContextANGLE(GLeglContext ctx,
                                                    GLuint bindingindex,
                                                    GLuint divisor)
{
    return GL_VertexBindingDivisorContextANGLE(ctx, bindingindex, divisor);
}

void GL_APIENTRY glVertexPointerContextANGLE(GLeglContext ctx,
                                             GLint size,
                                             GLenum type,
                                             GLsizei stride,
                                             const void *pointer)
{
    return GL_VertexPointerContextANGLE(ctx, size, type, stride, pointer);
}

void GL_APIENTRY
glViewportContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
{
    return GL_ViewportContextANGLE(ctx, x, y, width, height);
}

void GL_APIENTRY glWaitSemaphoreEXTContextANGLE(GLeglContext ctx,
                                                GLuint semaphore,
                                                GLuint numBufferBarriers,
                                                const GLuint *buffers,
                                                GLuint numTextureBarriers,
                                                const GLuint *textures,
                                                const GLenum *srcLayouts)
{
    return GL_WaitSemaphoreEXTContextANGLE(ctx, semaphore, numBufferBarriers, buffers,
                                           numTextureBarriers, textures, srcLayouts);
}

void GL_APIENTRY glWaitSyncContextANGLE(GLeglContext ctx,
                                        GLsync sync,
                                        GLbitfield flags,
                                        GLuint64 timeout)
{
    return GL_WaitSyncContextANGLE(ctx, sync, flags, timeout);
}

void GL_APIENTRY glWeightPointerOESContextANGLE(GLeglContext ctx,
                                                GLint size,
                                                GLenum type,
                                                GLsizei stride,
                                                const void *pointer)
{
    return GL_WeightPointerOESContextANGLE(ctx, size, type, stride, pointer);
}

void GL_APIENTRY glBindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,
                                                           GLuint program,
                                                           GLint location,
                                                           const GLchar *name)
{
    return GL_BindUniformLocationCHROMIUMContextANGLE(ctx, program, location, name);
}

void GL_APIENTRY glCoverageModulationCHROMIUMContextANGLE(GLeglContext ctx, GLenum components)
{
    return GL_CoverageModulationCHROMIUMContextANGLE(ctx, components);
}

void GL_APIENTRY glCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
                                                   GLuint sourceId,
                                                   GLint sourceLevel,
                                                   GLenum destTarget,
                                                   GLuint destId,
                                                   GLint destLevel,
                                                   GLint internalFormat,
                                                   GLenum destType,
                                                   GLboolean unpackFlipY,
                                                   GLboolean unpackPremultiplyAlpha,
                                                   GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopyTextureCHROMIUMContextANGLE(ctx, sourceId, sourceLevel, destTarget, destId,
                                              destLevel, internalFormat, destType, unpackFlipY,
                                              unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

void GL_APIENTRY glCopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,
                                                      GLuint sourceId,
                                                      GLint sourceLevel,
                                                      GLenum destTarget,
                                                      GLuint destId,
                                                      GLint destLevel,
                                                      GLint xoffset,
                                                      GLint yoffset,
                                                      GLint x,
                                                      GLint y,
                                                      GLint width,
                                                      GLint height,
                                                      GLboolean unpackFlipY,
                                                      GLboolean unpackPremultiplyAlpha,
                                                      GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopySubTextureCHROMIUMContextANGLE(
        ctx, sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, y, width,
        height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

void GL_APIENTRY glCompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
                                                             GLuint sourceId,
                                                             GLuint destId)
{
    return GL_CompressedCopyTextureCHROMIUMContextANGLE(ctx, sourceId, destId);
}

void GL_APIENTRY glRequestExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
{
    return GL_RequestExtensionANGLEContextANGLE(ctx, name);
}

void GL_APIENTRY glDisableExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
{
    return GL_DisableExtensionANGLEContextANGLE(ctx, name);
}

void GL_APIENTRY glGetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLboolean *params)
{
    return GL_GetBooleanvRobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
}

void GL_APIENTRY glGetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                               GLenum target,
                                                               GLenum pname,
                                                               GLsizei bufSize,
                                                               GLsizei *length,
                                                               GLint *params)
{
    return GL_GetBufferParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                          params);
}

void GL_APIENTRY glGetFloatvRobustANGLEContextANGLE(GLeglContext ctx,
                                                    GLenum pname,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLfloat *params)
{
    return GL_GetFloatvRobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
}

void GL_APIENTRY glGetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                              GLenum target,
                                                                              GLenum attachment,
                                                                              GLenum pname,
                                                                              GLsizei bufSize,
                                                                              GLsizei *length,
                                                                              GLint *params)
{
    return GL_GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(
        ctx, target, attachment, pname, bufSize, length, params);
}

void GL_APIENTRY glGetIntegervRobustANGLEContextANGLE(GLeglContext ctx,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *data)
{
    return GL_GetIntegervRobustANGLEContextANGLE(ctx, pname, bufSize, length, data);
}

void GL_APIENTRY glGetProgramivRobustANGLEContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLint *params)
{
    return GL_GetProgramivRobustANGLEContextANGLE(ctx, program, pname, bufSize, length, params);
}

void GL_APIENTRY glGetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                     GLenum target,
                                                                     GLenum pname,
                                                                     GLsizei bufSize,
                                                                     GLsizei *length,
                                                                     GLint *params)
{
    return GL_GetRenderbufferParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                                params);
}

void GL_APIENTRY glGetShaderivRobustANGLEContextANGLE(GLeglContext ctx,
                                                      GLuint shader,
                                                      GLenum pname,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLint *params)
{
    return GL_GetShaderivRobustANGLEContextANGLE(ctx, shader, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLenum target,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLfloat *params)
{
    return GL_GetTexParameterfvRobustANGLEContextANGLE(ctx, target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLenum target,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLint *params)
{
    return GL_GetTexParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLint location,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLfloat *params)
{
    return GL_GetUniformfvRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
}

void GL_APIENTRY glGetUniformivRobustANGLEContextANGLE(GLeglContext ctx,
                                                       GLuint program,
                                                       GLint location,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLint *params)
{
    return GL_GetUniformivRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLuint index,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLfloat *params)
{
    return GL_GetVertexAttribfvRobustANGLEContextANGLE(ctx, index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLuint index,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLint *params)
{
    return GL_GetVertexAttribivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,
                                                                  GLuint index,
                                                                  GLenum pname,
                                                                  GLsizei bufSize,
                                                                  GLsizei *length,
                                                                  void **pointer)
{
    return GL_GetVertexAttribPointervRobustANGLEContextANGLE(ctx, index, pname, bufSize, length,
                                                             pointer);
}

void GL_APIENTRY glReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,
                                                     GLint x,
                                                     GLint y,
                                                     GLsizei width,
                                                     GLsizei height,
                                                     GLenum format,
                                                     GLenum type,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLsizei *columns,
                                                     GLsizei *rows,
                                                     void *pixels)
{
    return GL_ReadPixelsRobustANGLEContextANGLE(ctx, x, y, width, height, format, type, bufSize,
                                                length, columns, rows, pixels);
}

void GL_APIENTRY glTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLint level,
                                                     GLint internalformat,
                                                     GLsizei width,
                                                     GLsizei height,
                                                     GLint border,
                                                     GLenum format,
                                                     GLenum type,
                                                     GLsizei bufSize,
                                                     const void *pixels)
{
    return GL_TexImage2DRobustANGLEContextANGLE(ctx, target, level, internalformat, width, height,
                                                border, format, type, bufSize, pixels);
}

void GL_APIENTRY glTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         const GLfloat *params)
{
    return GL_TexParameterfvRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
}

void GL_APIENTRY glTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         const GLint *params)
{
    return GL_TexParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
}

void GL_APIENTRY glTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLint level,
                                                        GLint xoffset,
                                                        GLint yoffset,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLenum format,
                                                        GLenum type,
                                                        GLsizei bufSize,
                                                        const void *pixels)
{
    return GL_TexSubImage2DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset, width,
                                                   height, format, type, bufSize, pixels);
}

void GL_APIENTRY glTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLint level,
                                                     GLint internalformat,
                                                     GLsizei width,
                                                     GLsizei height,
                                                     GLsizei depth,
                                                     GLint border,
                                                     GLenum format,
                                                     GLenum type,
                                                     GLsizei bufSize,
                                                     const void *pixels)
{
    return GL_TexImage3DRobustANGLEContextANGLE(ctx, target, level, internalformat, width, height,
                                                depth, border, format, type, bufSize, pixels);
}

void GL_APIENTRY glTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLint level,
                                                        GLint xoffset,
                                                        GLint yoffset,
                                                        GLint zoffset,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLsizei depth,
                                                        GLenum format,
                                                        GLenum type,
                                                        GLsizei bufSize,
                                                        const void *pixels)
{
    return GL_TexSubImage3DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
                                                   width, height, depth, format, type, bufSize,
                                                   pixels);
}

void GL_APIENTRY glCompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
                                                               GLenum target,
                                                               GLint level,
                                                               GLenum internalformat,
                                                               GLsizei width,
                                                               GLsizei height,
                                                               GLint border,
                                                               GLsizei imageSize,
                                                               GLsizei dataSize,
                                                               const GLvoid *data)
{
    return GL_CompressedTexImage2DRobustANGLEContextANGLE(
        ctx, target, level, internalformat, width, height, border, imageSize, dataSize, data);
}

void GL_APIENTRY glCompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
                                                                  GLenum target,
                                                                  GLint level,
                                                                  GLsizei xoffset,
                                                                  GLsizei yoffset,
                                                                  GLsizei width,
                                                                  GLsizei height,
                                                                  GLenum format,
                                                                  GLsizei imageSize,
                                                                  GLsizei dataSize,
                                                                  const GLvoid *data)
{
    return GL_CompressedTexSubImage2DRobustANGLEContextANGLE(
        ctx, target, level, xoffset, yoffset, width, height, format, imageSize, dataSize, data);
}

void GL_APIENTRY glCompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
                                                               GLenum target,
                                                               GLint level,
                                                               GLenum internalformat,
                                                               GLsizei width,
                                                               GLsizei height,
                                                               GLsizei depth,
                                                               GLint border,
                                                               GLsizei imageSize,
                                                               GLsizei dataSize,
                                                               const GLvoid *data)
{
    return GL_CompressedTexImage3DRobustANGLEContextANGLE(ctx, target, level, internalformat, width,
                                                          height, depth, border, imageSize,
                                                          dataSize, data);
}

void GL_APIENTRY glCompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
                                                                  GLenum target,
                                                                  GLint level,
                                                                  GLint xoffset,
                                                                  GLint yoffset,
                                                                  GLint zoffset,
                                                                  GLsizei width,
                                                                  GLsizei height,
                                                                  GLsizei depth,
                                                                  GLenum format,
                                                                  GLsizei imageSize,
                                                                  GLsizei dataSize,
                                                                  const GLvoid *data)
{
    return GL_CompressedTexSubImage3DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset,
                                                             zoffset, width, height, depth, format,
                                                             imageSize, dataSize, data);
}

void GL_APIENTRY glGetQueryivRobustANGLEContextANGLE(GLeglContext ctx,
                                                     GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
                                                     GLsizei *length,
                                                     GLint *params)
{
    return GL_GetQueryivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLuint id,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            GLuint *params)
{
    return GL_GetQueryObjectuivRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,
                                                            GLenum target,
                                                            GLenum pname,
                                                            GLsizei bufSize,
                                                            GLsizei *length,
                                                            void **params)
{
    return GL_GetBufferPointervRobustANGLEContextANGLE(ctx, target, pname, bufSize, length, params);
}

void GL_APIENTRY glGetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLuint index,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *data)
{
    return GL_GetIntegeri_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
}

void GL_APIENTRY glGetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,
                                                              GLenum target,
                                                              GLenum internalformat,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              GLsizei *length,
                                                              GLint *params)
{
    return GL_GetInternalformativRobustANGLEContextANGLE(ctx, target, internalformat, pname,
                                                         bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,
                                                             GLuint index,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             GLint *params)
{
    return GL_GetVertexAttribIivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length, params);
}

void GL_APIENTRY glGetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                              GLuint index,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              GLsizei *length,
                                                              GLuint *params)
{
    return GL_GetVertexAttribIuivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length,
                                                         params);
}

void GL_APIENTRY glGetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLuint program,
                                                        GLint location,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLuint *params)
{
    return GL_GetUniformuivRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
}

void GL_APIENTRY glGetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                  GLuint program,
                                                                  GLuint uniformBlockIndex,
                                                                  GLenum pname,
                                                                  GLsizei bufSize,
                                                                  GLsizei *length,
                                                                  GLint *params)
{
    return GL_GetActiveUniformBlockivRobustANGLEContextANGLE(ctx, program, uniformBlockIndex, pname,
                                                             bufSize, length, params);
}

void GL_APIENTRY glGetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint64 *data)
{
    return GL_GetInteger64vRobustANGLEContextANGLE(ctx, pname, bufSize, length, data);
}

void GL_APIENTRY glGetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLuint index,
                                                          GLsizei bufSize,
                                                          GLsizei *length,
                                                          GLint64 *data)
{
    return GL_GetInteger64i_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
}

void GL_APIENTRY glGetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,
                                                                 GLenum target,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLint64 *params)
{
    return GL_GetBufferParameteri64vRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                            params);
}

void GL_APIENTRY glSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                             GLuint sampler,
                                                             GLuint pname,
                                                             GLsizei bufSize,
                                                             const GLint *param)
{
    return GL_SamplerParameterivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
}

void GL_APIENTRY glSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                             GLuint sampler,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             const GLfloat *param)
{
    return GL_SamplerParameterfvRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
}

void GL_APIENTRY glGetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                GLuint sampler,
                                                                GLenum pname,
                                                                GLsizei bufSize,
                                                                GLsizei *length,
                                                                GLint *params)
{
    return GL_GetSamplerParameterivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
                                                           params);
}

void GL_APIENTRY glGetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                                GLuint sampler,
                                                                GLenum pname,
                                                                GLsizei bufSize,
                                                                GLsizei *length,
                                                                GLfloat *params)
{
    return GL_GetSamplerParameterfvRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
                                                           params);
}

void GL_APIENTRY glGetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                    GLenum target,
                                                                    GLenum pname,
                                                                    GLsizei bufSize,
                                                                    GLsizei *length,
                                                                    GLint *params)
{
    return GL_GetFramebufferParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                               params);
}

void GL_APIENTRY glGetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                GLuint program,
                                                                GLenum programInterface,
                                                                GLenum pname,
                                                                GLsizei bufSize,
                                                                GLsizei *length,
                                                                GLint *params)
{
    return GL_GetProgramInterfaceivRobustANGLEContextANGLE(ctx, program, programInterface, pname,
                                                           bufSize, length, params);
}

void GL_APIENTRY glGetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum target,
                                                        GLuint index,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLboolean *data)
{
    return GL_GetBooleani_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
}

void GL_APIENTRY glGetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,
                                                           GLenum pname,
                                                           GLuint index,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLfloat *val)
{
    return GL_GetMultisamplefvRobustANGLEContextANGLE(ctx, pname, index, bufSize, length, val);
}

void GL_APIENTRY glGetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                 GLenum target,
                                                                 GLint level,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLint *params)
{
    return GL_GetTexLevelParameterivRobustANGLEContextANGLE(ctx, target, level, pname, bufSize,
                                                            length, params);
}

void GL_APIENTRY glGetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                                 GLenum target,
                                                                 GLint level,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLfloat *params)
{
    return GL_GetTexLevelParameterfvRobustANGLEContextANGLE(ctx, target, level, pname, bufSize,
                                                            length, params);
}

void GL_APIENTRY glGetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 void **params)
{
    return GL_GetPointervRobustANGLERobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
}

void GL_APIENTRY glReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,
                                                      GLint x,
                                                      GLint y,
                                                      GLsizei width,
                                                      GLsizei height,
                                                      GLenum format,
                                                      GLenum type,
                                                      GLsizei bufSize,
                                                      GLsizei *length,
                                                      GLsizei *columns,
                                                      GLsizei *rows,
                                                      void *data)
{
    return GL_ReadnPixelsRobustANGLEContextANGLE(ctx, x, y, width, height, format, type, bufSize,
                                                 length, columns, rows, data);
}

void GL_APIENTRY glGetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLuint program,
                                                        GLint location,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLfloat *params)
{
    return GL_GetnUniformfvRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
}

void GL_APIENTRY glGetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,
                                                        GLuint program,
                                                        GLint location,
                                                        GLsizei bufSize,
                                                        GLsizei *length,
                                                        GLint *params)
{
    return GL_GetnUniformivRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
}

void GL_APIENTRY glGetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                         GLuint program,
                                                         GLint location,
                                                         GLsizei bufSize,
                                                         GLsizei *length,
                                                         GLuint *params)
{
    return GL_GetnUniformuivRobustANGLEContextANGLE(ctx, program, location, bufSize, length,
                                                    params);
}

void GL_APIENTRY glTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
                                                          GLenum target,
                                                          GLenum pname,
                                                          GLsizei bufSize,
                                                          const GLint *params)
{
    return GL_TexParameterIivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
}

void GL_APIENTRY glTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                           GLenum target,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           const GLuint *params)
{
    return GL_TexParameterIuivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
}

void GL_APIENTRY glGetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
                                                             GLenum target,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             GLint *params)
{
    return GL_GetTexParameterIivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                        params);
}

void GL_APIENTRY glGetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                              GLenum target,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              GLsizei *length,
                                                              GLuint *params)
{
    return GL_GetTexParameterIuivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
                                                         params);
}

void GL_APIENTRY glSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
                                                              GLuint sampler,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              const GLint *param)
{
    return GL_SamplerParameterIivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
}

void GL_APIENTRY glSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                               GLuint sampler,
                                                               GLenum pname,
                                                               GLsizei bufSize,
                                                               const GLuint *param)
{
    return GL_SamplerParameterIuivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
}

void GL_APIENTRY glGetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                 GLuint sampler,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLint *params)
{
    return GL_GetSamplerParameterIivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
                                                            params);
}

void GL_APIENTRY glGetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
                                                                  GLuint sampler,
                                                                  GLenum pname,
                                                                  GLsizei bufSize,
                                                                  GLsizei *length,
                                                                  GLuint *params)
{
    return GL_GetSamplerParameterIuivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
                                                             params);
}

void GL_APIENTRY glGetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,
                                                           GLuint id,
                                                           GLenum pname,
                                                           GLsizei bufSize,
                                                           GLsizei *length,
                                                           GLint *params)
{
    return GL_GetQueryObjectivRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,
                                                             GLuint id,
                                                             GLenum pname,
                                                             GLsizei bufSize,
                                                             GLsizei *length,
                                                             GLint64 *params)
{
    return GL_GetQueryObjecti64vRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
}

void GL_APIENTRY glGetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,
                                                              GLuint id,
                                                              GLenum pname,
                                                              GLsizei bufSize,
                                                              GLsizei *length,
                                                              GLuint64 *params)
{
    return GL_GetQueryObjectui64vRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
}

void GL_APIENTRY glCopyTexture3DANGLEContextANGLE(GLeglContext ctx,
                                                  GLuint sourceId,
                                                  GLint sourceLevel,
                                                  GLenum destTarget,
                                                  GLuint destId,
                                                  GLint destLevel,
                                                  GLint internalFormat,
                                                  GLenum destType,
                                                  GLboolean unpackFlipY,
                                                  GLboolean unpackPremultiplyAlpha,
                                                  GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopyTexture3DANGLEContextANGLE(ctx, sourceId, sourceLevel, destTarget, destId,
                                             destLevel, internalFormat, destType, unpackFlipY,
                                             unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

void GL_APIENTRY glCopySubTexture3DANGLEContextANGLE(GLeglContext ctx,
                                                     GLuint sourceId,
                                                     GLint sourceLevel,
                                                     GLenum destTarget,
                                                     GLuint destId,
                                                     GLint destLevel,
                                                     GLint xoffset,
                                                     GLint yoffset,
                                                     GLint zoffset,
                                                     GLint x,
                                                     GLint y,
                                                     GLint z,
                                                     GLint width,
                                                     GLint height,
                                                     GLint depth,
                                                     GLboolean unpackFlipY,
                                                     GLboolean unpackPremultiplyAlpha,
                                                     GLboolean unpackUnmultiplyAlpha)
{
    return GL_CopySubTexture3DANGLEContextANGLE(
        ctx, sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, zoffset, x, y,
        z, width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
}

void GL_APIENTRY glTexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,
                                                            GLenum target,
                                                            GLsizei samples,
                                                            GLenum internalformat,
                                                            GLsizei width,
                                                            GLsizei height,
                                                            GLboolean fixedsamplelocations)
{
    return GL_TexStorage2DMultisampleANGLEContextANGLE(ctx, target, samples, internalformat, width,
                                                       height, fixedsamplelocations);
}

void GL_APIENTRY glGetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,
                                                           GLenum target,
                                                           GLint level,
                                                           GLenum pname,
                                                           GLint *params)
{
    return GL_GetTexLevelParameterivANGLEContextANGLE(ctx, target, level, pname, params);
}

void GL_APIENTRY glGetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,
                                                           GLenum target,
                                                           GLint level,
                                                           GLenum pname,
                                                           GLfloat *params)
{
    return GL_GetTexLevelParameterfvANGLEContextANGLE(ctx, target, level, pname, params);
}

void GL_APIENTRY glMultiDrawArraysANGLEContextANGLE(GLeglContext ctx,
                                                    GLenum mode,
                                                    const GLint *firsts,
                                                    const GLsizei *counts,
                                                    GLsizei drawcount)
{
    return GL_MultiDrawArraysANGLEContextANGLE(ctx, mode, firsts, counts, drawcount);
}

void GL_APIENTRY glMultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
                                                             GLenum mode,
                                                             const GLint *firsts,
                                                             const GLsizei *counts,
                                                             const GLsizei *instanceCounts,
                                                             GLsizei drawcount)
{
    return GL_MultiDrawArraysInstancedANGLEContextANGLE(ctx, mode, firsts, counts, instanceCounts,
                                                        drawcount);
}

void GL_APIENTRY glMultiDrawElementsANGLEContextANGLE(GLeglContext ctx,
                                                      GLenum mode,
                                                      const GLsizei *counts,
                                                      GLenum type,
                                                      const GLvoid *const *indices,
                                                      GLsizei drawcount)
{
    return GL_MultiDrawElementsANGLEContextANGLE(ctx, mode, counts, type, indices, drawcount);
}

void GL_APIENTRY glMultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
                                                               GLenum mode,
                                                               const GLsizei *counts,
                                                               GLenum type,
                                                               const GLvoid *const *indices,
                                                               const GLsizei *instanceCounts,
                                                               GLsizei drawcount)
{
    return GL_MultiDrawElementsInstancedANGLEContextANGLE(ctx, mode, counts, type, indices,
                                                          instanceCounts, drawcount);
}

void GL_APIENTRY glDrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,
                                                                    GLenum mode,
                                                                    GLint first,
                                                                    GLsizei count,
                                                                    GLsizei instanceCount,
                                                                    GLuint baseInstance)
{
    return GL_DrawArraysInstancedBaseInstanceANGLEContextANGLE(ctx, mode, first, count,
                                                               instanceCount, baseInstance);
}

void GL_APIENTRY
glDrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,
                                                               GLenum mode,
                                                               GLsizei count,
                                                               GLenum type,
                                                               const GLvoid *indices,
                                                               GLsizei instanceCounts,
                                                               GLint baseVertex,
                                                               GLuint baseInstance)
{
    return GL_DrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(
        ctx, mode, count, type, indices, instanceCounts, baseVertex, baseInstance);
}

void GL_APIENTRY
glMultiDrawArraysInstancedBaseInstanceANGLEContextANGLE(GLeglContext ctx,
                                                        GLenum mode,
                                                        const GLint *firsts,
                                                        const GLsizei *counts,
                                                        const GLsizei *instanceCounts,
                                                        const GLuint *baseInstances,
                                                        GLsizei drawcount)
{
    return GL_MultiDrawArraysInstancedBaseInstanceANGLEContextANGLE(
        ctx, mode, firsts, counts, instanceCounts, baseInstances, drawcount);
}

void GL_APIENTRY
glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(GLeglContext ctx,
                                                                    GLenum mode,
                                                                    const GLsizei *counts,
                                                                    GLenum type,
                                                                    const GLvoid *const *indices,
                                                                    const GLsizei *instanceCounts,
                                                                    const GLint *baseVertices,
                                                                    const GLuint *baseInstances,
                                                                    GLsizei drawcount)
{
    return GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLEContextANGLE(
        ctx, mode, counts, type, indices, instanceCounts, baseVertices, baseInstances, drawcount);
}

void GL_APIENTRY glGetMultisamplefvANGLEContextANGLE(GLeglContext ctx,
                                                     GLenum pname,
                                                     GLuint index,
                                                     GLfloat *val)
{
    return GL_GetMultisamplefvANGLEContextANGLE(ctx, pname, index, val);
}

void GL_APIENTRY glSampleMaskiANGLEContextANGLE(GLeglContext ctx,
                                                GLuint maskNumber,
                                                GLbitfield mask)
{
    return GL_SampleMaskiANGLEContextANGLE(ctx, maskNumber, mask);
}

void GL_APIENTRY glProvokingVertexANGLEContextANGLE(GLeglContext ctx, GLenum mode)
{
    return GL_ProvokingVertexANGLEContextANGLE(ctx, mode);
}

void GL_APIENTRY glLoseContextCHROMIUMContextANGLE(GLeglContext ctx, GLenum current, GLenum other)
{
    return GL_LoseContextCHROMIUMContextANGLE(ctx, current, other);
}

void GL_APIENTRY glTexImage2DExternalANGLEContextANGLE(GLeglContext ctx,
                                                       GLenum target,
                                                       GLint level,
                                                       GLint internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLint border,
                                                       GLenum format,
                                                       GLenum type)
{
    return GL_TexImage2DExternalANGLEContextANGLE(ctx, target, level, internalformat, width, height,
                                                  border, format, type);
}

void GL_APIENTRY glInvalidateTextureANGLEContextANGLE(GLeglContext ctx, GLenum target)
{
    return GL_InvalidateTextureANGLEContextANGLE(ctx, target);
}

void GL_APIENTRY glGetTexImageANGLEContextANGLE(GLeglContext ctx,
                                                GLenum target,
                                                GLint level,
                                                GLenum format,
                                                GLenum type,
                                                void *pixels)
{
    return GL_GetTexImageANGLEContextANGLE(ctx, target, level, format, type, pixels);
}

void GL_APIENTRY glGetRenderbufferImageANGLEContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLenum format,
                                                         GLenum type,
                                                         void *pixels)
{
    return GL_GetRenderbufferImageANGLEContextANGLE(ctx, target, format, type, pixels);
}

void GL_APIENTRY glTexStorageMemFlags2DANGLEContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLsizei levels,
                                                         GLenum internalFormat,
                                                         GLsizei width,
                                                         GLsizei height,
                                                         GLuint memory,
                                                         GLuint64 offset,
                                                         GLbitfield createFlags,
                                                         GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags2DANGLEContextANGLE(ctx, target, levels, internalFormat, width,
                                                    height, memory, offset, createFlags,
                                                    usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags2DMultisampleANGLEContextANGLE(GLeglContext ctx,
                                                                    GLenum target,
                                                                    GLsizei samples,
                                                                    GLenum internalFormat,
                                                                    GLsizei width,
                                                                    GLsizei height,
                                                                    GLboolean fixedSampleLocations,
                                                                    GLuint memory,
                                                                    GLuint64 offset,
                                                                    GLbitfield createFlags,
                                                                    GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags2DMultisampleANGLEContextANGLE(
        ctx, target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset,
        createFlags, usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags3DANGLEContextANGLE(GLeglContext ctx,
                                                         GLenum target,
                                                         GLsizei levels,
                                                         GLenum internalFormat,
                                                         GLsizei width,
                                                         GLsizei height,
                                                         GLsizei depth,
                                                         GLuint memory,
                                                         GLuint64 offset,
                                                         GLbitfield createFlags,
                                                         GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags3DANGLEContextANGLE(ctx, target, levels, internalFormat, width,
                                                    height, depth, memory, offset, createFlags,
                                                    usageFlags);
}

void GL_APIENTRY glTexStorageMemFlags3DMultisampleANGLEContextANGLE(GLeglContext ctx,
                                                                    GLenum target,
                                                                    GLsizei samples,
                                                                    GLenum internalFormat,
                                                                    GLsizei width,
                                                                    GLsizei height,
                                                                    GLsizei depth,
                                                                    GLboolean fixedSampleLocations,
                                                                    GLuint memory,
                                                                    GLuint64 offset,
                                                                    GLbitfield createFlags,
                                                                    GLbitfield usageFlags)
{
    return GL_TexStorageMemFlags3DMultisampleANGLEContextANGLE(
        ctx, target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory,
        offset, createFlags, usageFlags);
}

void GL_APIENTRY glImportMemoryZirconHandleANGLEContextANGLE(GLeglContext ctx,
                                                             GLuint memory,
                                                             GLuint64 size,
                                                             GLenum handleType,
                                                             GLuint handle)
{
    return GL_ImportMemoryZirconHandleANGLEContextANGLE(ctx, memory, size, handleType, handle);
}

void GL_APIENTRY glImportSemaphoreZirconHandleANGLEContextANGLE(GLeglContext ctx,
                                                                GLuint semaphore,
                                                                GLenum handleType,
                                                                GLuint handle)
{
    return GL_ImportSemaphoreZirconHandleANGLEContextANGLE(ctx, semaphore, handleType, handle);
}

}  // extern "C"