Source/ThirdParty/ANGLE/src/libGL/libGL_autogen.cpp

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and wgl.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.
//
// libGL.cpp: Implements the exported Windows GL functions.

#include "angle_gl.h"

#include "libGL/entry_points_gl_1_0_autogen.h"
#include "libGL/entry_points_gl_1_1_autogen.h"
#include "libGL/entry_points_gl_1_2_autogen.h"
#include "libGL/entry_points_gl_1_3_autogen.h"
#include "libGL/entry_points_gl_1_4_autogen.h"
#include "libGL/entry_points_gl_1_5_autogen.h"
#include "libGL/entry_points_gl_2_0_autogen.h"
#include "libGL/entry_points_gl_2_1_autogen.h"
#include "libGL/entry_points_gl_3_0_autogen.h"
#include "libGL/entry_points_gl_3_1_autogen.h"
#include "libGL/entry_points_gl_3_2_autogen.h"
#include "libGL/entry_points_gl_3_3_autogen.h"
#include "libGL/entry_points_gl_4_0_autogen.h"
#include "libGL/entry_points_gl_4_1_autogen.h"
#include "libGL/entry_points_gl_4_2_autogen.h"
#include "libGL/entry_points_gl_4_3_autogen.h"
#include "libGL/entry_points_gl_4_4_autogen.h"
#include "libGL/entry_points_gl_4_5_autogen.h"
#include "libGL/entry_points_gl_4_6_autogen.h"

#include "common/event_tracer.h"

extern "C" {

// GL 1.0
void GL_APIENTRY glAccum(GLenum op, GLfloat value)
{
    return gl::Accum(op, value);
}

void GL_APIENTRY glAlphaFunc(GLenum func, GLfloat ref)
{
    return gl::AlphaFunc(func, ref);
}

void GL_APIENTRY glBegin(GLenum mode)
{
    return gl::Begin(mode);
}

void GL_APIENTRY glBitmap(GLsizei width,
                          GLsizei height,
                          GLfloat xorig,
                          GLfloat yorig,
                          GLfloat xmove,
                          GLfloat ymove,
                          const GLubyte *bitmap)
{
    return gl::Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
}

void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
{
    return gl::BlendFunc(sfactor, dfactor);
}

void GL_APIENTRY glCallList(GLuint list)
{
    return gl::CallList(list);
}

void GL_APIENTRY glCallLists(GLsizei n, GLenum type, const void *lists)
{
    return gl::CallLists(n, type, lists);
}

void GL_APIENTRY glClear(GLbitfield mask)
{
    return gl::Clear(mask);
}

void GL_APIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return gl::ClearAccum(red, green, blue, alpha);
}

void GL_APIENTRY glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return gl::ClearColor(red, green, blue, alpha);
}

void GL_APIENTRY glClearDepth(GLdouble depth)
{
    return gl::ClearDepth(depth);
}

void GL_APIENTRY glClearIndex(GLfloat c)
{
    return gl::ClearIndex(c);
}

void GL_APIENTRY glClearStencil(GLint s)
{
    return gl::ClearStencil(s);
}

void GL_APIENTRY glClipPlane(GLenum plane, const GLdouble *equation)
{
    return gl::ClipPlane(plane, equation);
}

void GL_APIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
    return gl::Color3b(red, green, blue);
}

void GL_APIENTRY glColor3bv(const GLbyte *v)
{
    return gl::Color3bv(v);
}

void GL_APIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
    return gl::Color3d(red, green, blue);
}

void GL_APIENTRY glColor3dv(const GLdouble *v)
{
    return gl::Color3dv(v);
}

void GL_APIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
    return gl::Color3f(red, green, blue);
}

void GL_APIENTRY glColor3fv(const GLfloat *v)
{
    return gl::Color3fv(v);
}

void GL_APIENTRY glColor3i(GLint red, GLint green, GLint blue)
{
    return gl::Color3i(red, green, blue);
}

void GL_APIENTRY glColor3iv(const GLint *v)
{
    return gl::Color3iv(v);
}

void GL_APIENTRY glColor3s(GLshort red, GLshort green, GLshort blue)
{
    return gl::Color3s(red, green, blue);
}

void GL_APIENTRY glColor3sv(const GLshort *v)
{
    return gl::Color3sv(v);
}

void GL_APIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
    return gl::Color3ub(red, green, blue);
}

void GL_APIENTRY glColor3ubv(const GLubyte *v)
{
    return gl::Color3ubv(v);
}

void GL_APIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue)
{
    return gl::Color3ui(red, green, blue);
}

void GL_APIENTRY glColor3uiv(const GLuint *v)
{
    return gl::Color3uiv(v);
}

void GL_APIENTRY glColor3us(GLushort red, GLushort green, GLushort blue)
{
    return gl::Color3us(red, green, blue);
}

void GL_APIENTRY glColor3usv(const GLushort *v)
{
    return gl::Color3usv(v);
}

void GL_APIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
    return gl::Color4b(red, green, blue, alpha);
}

void GL_APIENTRY glColor4bv(const GLbyte *v)
{
    return gl::Color4bv(v);
}

void GL_APIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
    return gl::Color4d(red, green, blue, alpha);
}

void GL_APIENTRY glColor4dv(const GLdouble *v)
{
    return gl::Color4dv(v);
}

void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    return gl::Color4f(red, green, blue, alpha);
}

void GL_APIENTRY glColor4fv(const GLfloat *v)
{
    return gl::Color4fv(v);
}

void GL_APIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
    return gl::Color4i(red, green, blue, alpha);
}

void GL_APIENTRY glColor4iv(const GLint *v)
{
    return gl::Color4iv(v);
}

void GL_APIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
    return gl::Color4s(red, green, blue, alpha);
}

void GL_APIENTRY glColor4sv(const GLshort *v)
{
    return gl::Color4sv(v);
}

void GL_APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
    return gl::Color4ub(red, green, blue, alpha);
}

void GL_APIENTRY glColor4ubv(const GLubyte *v)
{
    return gl::Color4ubv(v);
}

void GL_APIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
    return gl::Color4ui(red, green, blue, alpha);
}

void GL_APIENTRY glColor4uiv(const GLuint *v)
{
    return gl::Color4uiv(v);
}

void GL_APIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
    return gl::Color4us(red, green, blue, alpha);
}

void GL_APIENTRY glColor4usv(const GLushort *v)
{
    return gl::Color4usv(v);
}

void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
    return gl::ColorMask(red, green, blue, alpha);
}

void GL_APIENTRY glColorMaterial(GLenum face, GLenum mode)
{
    return gl::ColorMaterial(face, mode);
}

void GL_APIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
    return gl::CopyPixels(x, y, width, height, type);
}

void GL_APIENTRY glCullFace(GLenum mode)
{
    return gl::CullFace(mode);
}

void GL_APIENTRY glDeleteLists(GLuint list, GLsizei range)
{
    return gl::DeleteLists(list, range);
}

void GL_APIENTRY glDepthFunc(GLenum func)
{
    return gl::DepthFunc(func);
}

void GL_APIENTRY glDepthMask(GLboolean flag)
{
    return gl::DepthMask(flag);
}

void GL_APIENTRY glDepthRange(GLdouble n, GLdouble f)
{
    return gl::DepthRange(n, f);
}

void GL_APIENTRY glDisable(GLenum cap)
{
    return gl::Disable(cap);
}

void GL_APIENTRY glDrawBuffer(GLenum buf)
{
    return gl::DrawBuffer(buf);
}

void GL_APIENTRY
glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
    return gl::DrawPixels(width, height, format, type, pixels);
}

void GL_APIENTRY glEdgeFlag(GLboolean flag)
{
    return gl::EdgeFlag(flag);
}

void GL_APIENTRY glEdgeFlagv(const GLboolean *flag)
{
    return gl::EdgeFlagv(flag);
}

void GL_APIENTRY glEnable(GLenum cap)
{
    return gl::Enable(cap);
}

void GL_APIENTRY glEnd()
{
    return gl::End();
}

void GL_APIENTRY glEndList()
{
    return gl::EndList();
}

void GL_APIENTRY glEvalCoord1d(GLdouble u)
{
    return gl::EvalCoord1d(u);
}

void GL_APIENTRY glEvalCoord1dv(const GLdouble *u)
{
    return gl::EvalCoord1dv(u);
}

void GL_APIENTRY glEvalCoord1f(GLfloat u)
{
    return gl::EvalCoord1f(u);
}

void GL_APIENTRY glEvalCoord1fv(const GLfloat *u)
{
    return gl::EvalCoord1fv(u);
}

void GL_APIENTRY glEvalCoord2d(GLdouble u, GLdouble v)
{
    return gl::EvalCoord2d(u, v);
}

void GL_APIENTRY glEvalCoord2dv(const GLdouble *u)
{
    return gl::EvalCoord2dv(u);
}

void GL_APIENTRY glEvalCoord2f(GLfloat u, GLfloat v)
{
    return gl::EvalCoord2f(u, v);
}

void GL_APIENTRY glEvalCoord2fv(const GLfloat *u)
{
    return gl::EvalCoord2fv(u);
}

void GL_APIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
    return gl::EvalMesh1(mode, i1, i2);
}

void GL_APIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
    return gl::EvalMesh2(mode, i1, i2, j1, j2);
}

void GL_APIENTRY glEvalPoint1(GLint i)
{
    return gl::EvalPoint1(i);
}

void GL_APIENTRY glEvalPoint2(GLint i, GLint j)
{
    return gl::EvalPoint2(i, j);
}

void GL_APIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
    return gl::FeedbackBuffer(size, type, buffer);
}

void GL_APIENTRY glFinish()
{
    return gl::Finish();
}

void GL_APIENTRY glFlush()
{
    return gl::Flush();
}

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 glFogi(GLenum pname, GLint param)
{
    return gl::Fogi(pname, param);
}

void GL_APIENTRY glFogiv(GLenum pname, const GLint *params)
{
    return gl::Fogiv(pname, params);
}

void GL_APIENTRY glFrontFace(GLenum mode)
{
    return gl::FrontFace(mode);
}

void GL_APIENTRY glFrustum(GLdouble left,
                           GLdouble right,
                           GLdouble bottom,
                           GLdouble top,
                           GLdouble zNear,
                           GLdouble zFar)
{
    return gl::Frustum(left, right, bottom, top, zNear, zFar);
}

GLuint GL_APIENTRY glGenLists(GLsizei range)
{
    return gl::GenLists(range);
}

void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean *data)
{
    return gl::GetBooleanv(pname, data);
}

void GL_APIENTRY glGetClipPlane(GLenum plane, GLdouble *equation)
{
    return gl::GetClipPlane(plane, equation);
}

void GL_APIENTRY glGetDoublev(GLenum pname, GLdouble *data)
{
    return gl::GetDoublev(pname, data);
}

GLenum GL_APIENTRY glGetError()
{
    return gl::GetError();
}

void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat *data)
{
    return gl::GetFloatv(pname, data);
}

void GL_APIENTRY glGetIntegerv(GLenum pname, GLint *data)
{
    return gl::GetIntegerv(pname, data);
}

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

void GL_APIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params)
{
    return gl::GetLightiv(light, pname, params);
}

void GL_APIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v)
{
    return gl::GetMapdv(target, query, v);
}

void GL_APIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v)
{
    return gl::GetMapfv(target, query, v);
}

void GL_APIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v)
{
    return gl::GetMapiv(target, query, v);
}

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

void GL_APIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
    return gl::GetMaterialiv(face, pname, params);
}

void GL_APIENTRY glGetPixelMapfv(GLenum map, GLfloat *values)
{
    return gl::GetPixelMapfv(map, values);
}

void GL_APIENTRY glGetPixelMapuiv(GLenum map, GLuint *values)
{
    return gl::GetPixelMapuiv(map, values);
}

void GL_APIENTRY glGetPixelMapusv(GLenum map, GLushort *values)
{
    return gl::GetPixelMapusv(map, values);
}

void GL_APIENTRY glGetPolygonStipple(GLubyte *mask)
{
    return gl::GetPolygonStipple(mask);
}

const GLubyte *GL_APIENTRY glGetString(GLenum name)
{
    return gl::GetString(name);
}

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 glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
    return gl::GetTexGendv(coord, pname, params);
}

void GL_APIENTRY glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
    return gl::GetTexGenfv(coord, pname, params);
}

void GL_APIENTRY glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
    return gl::GetTexGeniv(coord, pname, params);
}

void GL_APIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
    return gl::GetTexImage(target, level, format, type, pixels);
}

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);
}

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);
}

void GL_APIENTRY glHint(GLenum target, GLenum mode)
{
    return gl::Hint(target, mode);
}

void GL_APIENTRY glIndexMask(GLuint mask)
{
    return gl::IndexMask(mask);
}

void GL_APIENTRY glIndexd(GLdouble c)
{
    return gl::Indexd(c);
}

void GL_APIENTRY glIndexdv(const GLdouble *c)
{
    return gl::Indexdv(c);
}

void GL_APIENTRY glIndexf(GLfloat c)
{
    return gl::Indexf(c);
}

void GL_APIENTRY glIndexfv(const GLfloat *c)
{
    return gl::Indexfv(c);
}

void GL_APIENTRY glIndexi(GLint c)
{
    return gl::Indexi(c);
}

void GL_APIENTRY glIndexiv(const GLint *c)
{
    return gl::Indexiv(c);
}

void GL_APIENTRY glIndexs(GLshort c)
{
    return gl::Indexs(c);
}

void GL_APIENTRY glIndexsv(const GLshort *c)
{
    return gl::Indexsv(c);
}

void GL_APIENTRY glInitNames()
{
    return gl::InitNames();
}

GLboolean GL_APIENTRY glIsEnabled(GLenum cap)
{
    return gl::IsEnabled(cap);
}

GLboolean GL_APIENTRY glIsList(GLuint list)
{
    return gl::IsList(list);
}

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 glLightModeli(GLenum pname, GLint param)
{
    return gl::LightModeli(pname, param);
}

void GL_APIENTRY glLightModeliv(GLenum pname, const GLint *params)
{
    return gl::LightModeliv(pname, params);
}

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 glLighti(GLenum light, GLenum pname, GLint param)
{
    return gl::Lighti(light, pname, param);
}

void GL_APIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params)
{
    return gl::Lightiv(light, pname, params);
}

void GL_APIENTRY glLineStipple(GLint factor, GLushort pattern)
{
    return gl::LineStipple(factor, pattern);
}

void GL_APIENTRY glLineWidth(GLfloat width)
{
    return gl::LineWidth(width);
}

void GL_APIENTRY glListBase(GLuint base)
{
    return gl::ListBase(base);
}

void GL_APIENTRY glLoadIdentity()
{
    return gl::LoadIdentity();
}

void GL_APIENTRY glLoadMatrixd(const GLdouble *m)
{
    return gl::LoadMatrixd(m);
}

void GL_APIENTRY glLoadMatrixf(const GLfloat *m)
{
    return gl::LoadMatrixf(m);
}

void GL_APIENTRY glLoadName(GLuint name)
{
    return gl::LoadName(name);
}

void GL_APIENTRY glLogicOp(GLenum opcode)
{
    return gl::LogicOp(opcode);
}

void GL_APIENTRY
glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
    return gl::Map1d(target, u1, u2, stride, order, points);
}

void GL_APIENTRY
glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
    return gl::Map1f(target, u1, u2, stride, order, points);
}

void GL_APIENTRY glMap2d(GLenum target,
                         GLdouble u1,
                         GLdouble u2,
                         GLint ustride,
                         GLint uorder,
                         GLdouble v1,
                         GLdouble v2,
                         GLint vstride,
                         GLint vorder,
                         const GLdouble *points)
{
    return gl::Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

void GL_APIENTRY glMap2f(GLenum target,
                         GLfloat u1,
                         GLfloat u2,
                         GLint ustride,
                         GLint uorder,
                         GLfloat v1,
                         GLfloat v2,
                         GLint vstride,
                         GLint vorder,
                         const GLfloat *points)
{
    return gl::Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

void GL_APIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
    return gl::MapGrid1d(un, u1, u2);
}

void GL_APIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
    return gl::MapGrid1f(un, u1, u2);
}

void GL_APIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
    return gl::MapGrid2d(un, u1, u2, vn, v1, v2);
}

void GL_APIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
    return gl::MapGrid2f(un, u1, u2, vn, v1, v2);
}

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 glMateriali(GLenum face, GLenum pname, GLint param)
{
    return gl::Materiali(face, pname, param);
}

void GL_APIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params)
{
    return gl::Materialiv(face, pname, params);
}

void GL_APIENTRY glMatrixMode(GLenum mode)
{
    return gl::MatrixMode(mode);
}

void GL_APIENTRY glMultMatrixd(const GLdouble *m)
{
    return gl::MultMatrixd(m);
}

void GL_APIENTRY glMultMatrixf(const GLfloat *m)
{
    return gl::MultMatrixf(m);
}

void GL_APIENTRY glNewList(GLuint list, GLenum mode)
{
    return gl::NewList(list, mode);
}

void GL_APIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
    return gl::Normal3b(nx, ny, nz);
}

void GL_APIENTRY glNormal3bv(const GLbyte *v)
{
    return gl::Normal3bv(v);
}

void GL_APIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
    return gl::Normal3d(nx, ny, nz);
}

void GL_APIENTRY glNormal3dv(const GLdouble *v)
{
    return gl::Normal3dv(v);
}

void GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
    return gl::Normal3f(nx, ny, nz);
}

void GL_APIENTRY glNormal3fv(const GLfloat *v)
{
    return gl::Normal3fv(v);
}

void GL_APIENTRY glNormal3i(GLint nx, GLint ny, GLint nz)
{
    return gl::Normal3i(nx, ny, nz);
}

void GL_APIENTRY glNormal3iv(const GLint *v)
{
    return gl::Normal3iv(v);
}

void GL_APIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
    return gl::Normal3s(nx, ny, nz);
}

void GL_APIENTRY glNormal3sv(const GLshort *v)
{
    return gl::Normal3sv(v);
}

void GL_APIENTRY
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
    return gl::Ortho(left, right, bottom, top, zNear, zFar);
}

void GL_APIENTRY glPassThrough(GLfloat token)
{
    return gl::PassThrough(token);
}

void GL_APIENTRY glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
    return gl::PixelMapfv(map, mapsize, values);
}

void GL_APIENTRY glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
    return gl::PixelMapuiv(map, mapsize, values);
}

void GL_APIENTRY glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
    return gl::PixelMapusv(map, mapsize, values);
}

void GL_APIENTRY glPixelStoref(GLenum pname, GLfloat param)
{
    return gl::PixelStoref(pname, param);
}

void GL_APIENTRY glPixelStorei(GLenum pname, GLint param)
{
    return gl::PixelStorei(pname, param);
}

void GL_APIENTRY glPixelTransferf(GLenum pname, GLfloat param)
{
    return gl::PixelTransferf(pname, param);
}

void GL_APIENTRY glPixelTransferi(GLenum pname, GLint param)
{
    return gl::PixelTransferi(pname, param);
}

void GL_APIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
    return gl::PixelZoom(xfactor, yfactor);
}

void GL_APIENTRY glPointSize(GLfloat size)
{
    return gl::PointSize(size);
}

void GL_APIENTRY glPolygonMode(GLenum face, GLenum mode)
{
    return gl::PolygonMode(face, mode);
}

void GL_APIENTRY glPolygonStipple(const GLubyte *mask)
{
    return gl::PolygonStipple(mask);
}

void GL_APIENTRY glPopAttrib()
{
    return gl::PopAttrib();
}

void GL_APIENTRY glPopMatrix()
{
    return gl::PopMatrix();
}

void GL_APIENTRY glPopName()
{
    return gl::PopName();
}

void GL_APIENTRY glPushAttrib(GLbitfield mask)
{
    return gl::PushAttrib(mask);
}

void GL_APIENTRY glPushMatrix()
{
    return gl::PushMatrix();
}

void GL_APIENTRY glPushName(GLuint name)
{
    return gl::PushName(name);
}

void GL_APIENTRY glRasterPos2d(GLdouble x, GLdouble y)
{
    return gl::RasterPos2d(x, y);
}

void GL_APIENTRY glRasterPos2dv(const GLdouble *v)
{
    return gl::RasterPos2dv(v);
}

void GL_APIENTRY glRasterPos2f(GLfloat x, GLfloat y)
{
    return gl::RasterPos2f(x, y);
}

void GL_APIENTRY glRasterPos2fv(const GLfloat *v)
{
    return gl::RasterPos2fv(v);
}

void GL_APIENTRY glRasterPos2i(GLint x, GLint y)
{
    return gl::RasterPos2i(x, y);
}

void GL_APIENTRY glRasterPos2iv(const GLint *v)
{
    return gl::RasterPos2iv(v);
}

void GL_APIENTRY glRasterPos2s(GLshort x, GLshort y)
{
    return gl::RasterPos2s(x, y);
}

void GL_APIENTRY glRasterPos2sv(const GLshort *v)
{
    return gl::RasterPos2sv(v);
}

void GL_APIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    return gl::RasterPos3d(x, y, z);
}

void GL_APIENTRY glRasterPos3dv(const GLdouble *v)
{
    return gl::RasterPos3dv(v);
}

void GL_APIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    return gl::RasterPos3f(x, y, z);
}

void GL_APIENTRY glRasterPos3fv(const GLfloat *v)
{
    return gl::RasterPos3fv(v);
}

void GL_APIENTRY glRasterPos3i(GLint x, GLint y, GLint z)
{
    return gl::RasterPos3i(x, y, z);
}

void GL_APIENTRY glRasterPos3iv(const GLint *v)
{
    return gl::RasterPos3iv(v);
}

void GL_APIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z)
{
    return gl::RasterPos3s(x, y, z);
}

void GL_APIENTRY glRasterPos3sv(const GLshort *v)
{
    return gl::RasterPos3sv(v);
}

void GL_APIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    return gl::RasterPos4d(x, y, z, w);
}

void GL_APIENTRY glRasterPos4dv(const GLdouble *v)
{
    return gl::RasterPos4dv(v);
}

void GL_APIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    return gl::RasterPos4f(x, y, z, w);
}

void GL_APIENTRY glRasterPos4fv(const GLfloat *v)
{
    return gl::RasterPos4fv(v);
}

void GL_APIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
    return gl::RasterPos4i(x, y, z, w);
}

void GL_APIENTRY glRasterPos4iv(const GLint *v)
{
    return gl::RasterPos4iv(v);
}

void GL_APIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    return gl::RasterPos4s(x, y, z, w);
}

void GL_APIENTRY glRasterPos4sv(const GLshort *v)
{
    return gl::RasterPos4sv(v);
}

void GL_APIENTRY glReadBuffer(GLenum src)
{
    return gl::ReadBuffer(src);
}

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 glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
    return gl::Rectd(x1, y1, x2, y2);
}

void GL_APIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2)
{
    return gl::Rectdv(v1, v2);
}

void GL_APIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
    return gl::Rectf(x1, y1, x2, y2);
}

void GL_APIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2)
{
    return gl::Rectfv(v1, v2);
}

void GL_APIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
    return gl::Recti(x1, y1, x2, y2);
}

void GL_APIENTRY glRectiv(const GLint *v1, const GLint *v2)
{
    return gl::Rectiv(v1, v2);
}

void GL_APIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
    return gl::Rects(x1, y1, x2, y2);
}

void GL_APIENTRY glRectsv(const GLshort *v1, const GLshort *v2)
{
    return gl::Rectsv(v1, v2);
}

GLint GL_APIENTRY glRenderMode(GLenum mode)
{
    return gl::RenderMode(mode);
}

void GL_APIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
    return gl::Rotated(angle, x, y, z);
}

void GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
    return gl::Rotatef(angle, x, y, z);
}

void GL_APIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z)
{
    return gl::Scaled(x, y, z);
}

void GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
{
    return gl::Scalef(x, y, z);
}

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

void GL_APIENTRY glSelectBuffer(GLsizei size, GLuint *buffer)
{
    return gl::SelectBuffer(size, buffer);
}

void GL_APIENTRY glShadeModel(GLenum mode)
{
    return gl::ShadeModel(mode);
}

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

void GL_APIENTRY glStencilMask(GLuint mask)
{
    return gl::StencilMask(mask);
}

void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
    return gl::StencilOp(fail, zfail, zpass);
}

void GL_APIENTRY glTexCoord1d(GLdouble s)
{
    return gl::TexCoord1d(s);
}

void GL_APIENTRY glTexCoord1dv(const GLdouble *v)
{
    return gl::TexCoord1dv(v);
}

void GL_APIENTRY glTexCoord1f(GLfloat s)
{
    return gl::TexCoord1f(s);
}

void GL_APIENTRY glTexCoord1fv(const GLfloat *v)
{
    return gl::TexCoord1fv(v);
}

void GL_APIENTRY glTexCoord1i(GLint s)
{
    return gl::TexCoord1i(s);
}

void GL_APIENTRY glTexCoord1iv(const GLint *v)
{
    return gl::TexCoord1iv(v);
}

void GL_APIENTRY glTexCoord1s(GLshort s)
{
    return gl::TexCoord1s(s);
}

void GL_APIENTRY glTexCoord1sv(const GLshort *v)
{
    return gl::TexCoord1sv(v);
}

void GL_APIENTRY glTexCoord2d(GLdouble s, GLdouble t)
{
    return gl::TexCoord2d(s, t);
}

void GL_APIENTRY glTexCoord2dv(const GLdouble *v)
{
    return gl::TexCoord2dv(v);
}

void GL_APIENTRY glTexCoord2f(GLfloat s, GLfloat t)
{
    return gl::TexCoord2f(s, t);
}

void GL_APIENTRY glTexCoord2fv(const GLfloat *v)
{
    return gl::TexCoord2fv(v);
}

void GL_APIENTRY glTexCoord2i(GLint s, GLint t)
{
    return gl::TexCoord2i(s, t);
}

void GL_APIENTRY glTexCoord2iv(const GLint *v)
{
    return gl::TexCoord2iv(v);
}

void GL_APIENTRY glTexCoord2s(GLshort s, GLshort t)
{
    return gl::TexCoord2s(s, t);
}

void GL_APIENTRY glTexCoord2sv(const GLshort *v)
{
    return gl::TexCoord2sv(v);
}

void GL_APIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
    return gl::TexCoord3d(s, t, r);
}

void GL_APIENTRY glTexCoord3dv(const GLdouble *v)
{
    return gl::TexCoord3dv(v);
}

void GL_APIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
    return gl::TexCoord3f(s, t, r);
}

void GL_APIENTRY glTexCoord3fv(const GLfloat *v)
{
    return gl::TexCoord3fv(v);
}

void GL_APIENTRY glTexCoord3i(GLint s, GLint t, GLint r)
{
    return gl::TexCoord3i(s, t, r);
}

void GL_APIENTRY glTexCoord3iv(const GLint *v)
{
    return gl::TexCoord3iv(v);
}

void GL_APIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r)
{
    return gl::TexCoord3s(s, t, r);
}

void GL_APIENTRY glTexCoord3sv(const GLshort *v)
{
    return gl::TexCoord3sv(v);
}

void GL_APIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    return gl::TexCoord4d(s, t, r, q);
}

void GL_APIENTRY glTexCoord4dv(const GLdouble *v)
{
    return gl::TexCoord4dv(v);
}

void GL_APIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
    return gl::TexCoord4f(s, t, r, q);
}

void GL_APIENTRY glTexCoord4fv(const GLfloat *v)
{
    return gl::TexCoord4fv(v);
}

void GL_APIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
    return gl::TexCoord4i(s, t, r, q);
}

void GL_APIENTRY glTexCoord4iv(const GLint *v)
{
    return gl::TexCoord4iv(v);
}

void GL_APIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
    return gl::TexCoord4s(s, t, r, q);
}

void GL_APIENTRY glTexCoord4sv(const GLshort *v)
{
    return gl::TexCoord4sv(v);
}

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 glTexGend(GLenum coord, GLenum pname, GLdouble param)
{
    return gl::TexGend(coord, pname, param);
}

void GL_APIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
{
    return gl::TexGendv(coord, pname, params);
}

void GL_APIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
    return gl::TexGenf(coord, pname, param);
}

void GL_APIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
{
    return gl::TexGenfv(coord, pname, params);
}

void GL_APIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param)
{
    return gl::TexGeni(coord, pname, param);
}

void GL_APIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
{
    return gl::TexGeniv(coord, pname, params);
}

void GL_APIENTRY glTexImage1D(GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
{
    return gl::TexImage1D(target, level, internalformat, width, border, format, type, pixels);
}

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 glTranslated(GLdouble x, GLdouble y, GLdouble z)
{
    return gl::Translated(x, y, z);
}

void GL_APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
    return gl::Translatef(x, y, z);
}

void GL_APIENTRY glVertex2d(GLdouble x, GLdouble y)
{
    return gl::Vertex2d(x, y);
}

void GL_APIENTRY glVertex2dv(const GLdouble *v)
{
    return gl::Vertex2dv(v);
}

void GL_APIENTRY glVertex2f(GLfloat x, GLfloat y)
{
    return gl::Vertex2f(x, y);
}

void GL_APIENTRY glVertex2fv(const GLfloat *v)
{
    return gl::Vertex2fv(v);
}

void GL_APIENTRY glVertex2i(GLint x, GLint y)
{
    return gl::Vertex2i(x, y);
}

void GL_APIENTRY glVertex2iv(const GLint *v)
{
    return gl::Vertex2iv(v);
}

void GL_APIENTRY glVertex2s(GLshort x, GLshort y)
{
    return gl::Vertex2s(x, y);
}

void GL_APIENTRY glVertex2sv(const GLshort *v)
{
    return gl::Vertex2sv(v);
}

void GL_APIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
    return gl::Vertex3d(x, y, z);
}

void GL_APIENTRY glVertex3dv(const GLdouble *v)
{
    return gl::Vertex3dv(v);
}

void GL_APIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
    return gl::Vertex3f(x, y, z);
}

void GL_APIENTRY glVertex3fv(const GLfloat *v)
{
    return gl::Vertex3fv(v);
}

void GL_APIENTRY glVertex3i(GLint x, GLint y, GLint z)
{
    return gl::Vertex3i(x, y, z);
}

void GL_APIENTRY glVertex3iv(const GLint *v)
{
    return gl::Vertex3iv(v);
}

void GL_APIENTRY glVertex3s(GLshort x, GLshort y, GLshort z)
{
    return gl::Vertex3s(x, y, z);
}

void GL_APIENTRY glVertex3sv(const GLshort *v)
{
    return gl::Vertex3sv(v);
}

void GL_APIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    return gl::Vertex4d(x, y, z, w);
}

void GL_APIENTRY glVertex4dv(const GLdouble *v)
{
    return gl::Vertex4dv(v);
}

void GL_APIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    return gl::Vertex4f(x, y, z, w);
}

void GL_APIENTRY glVertex4fv(const GLfloat *v)
{
    return gl::Vertex4fv(v);
}

void GL_APIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w)
{
    return gl::Vertex4i(x, y, z, w);
}

void GL_APIENTRY glVertex4iv(const GLint *v)
{
    return gl::Vertex4iv(v);
}

void GL_APIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    return gl::Vertex4s(x, y, z, w);
}

void GL_APIENTRY glVertex4sv(const GLshort *v)
{
    return gl::Vertex4sv(v);
}

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

// GL 1.1
GLboolean GL_APIENTRY glAreTexturesResident(GLsizei n,
                                            const GLuint *textures,
                                            GLboolean *residences)
{
    return gl::AreTexturesResident(n, textures, residences);
}

void GL_APIENTRY glArrayElement(GLint i)
{
    return gl::ArrayElement(i);
}

void GL_APIENTRY glBindTexture(GLenum target, GLuint texture)
{
    return gl::BindTexture(target, texture);
}

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

void GL_APIENTRY glCopyTexImage1D(GLenum target,
                                  GLint level,
                                  GLenum internalformat,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLint border)
{
    return gl::CopyTexImage1D(target, level, internalformat, x, y, width, border);
}

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
glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
    return gl::CopyTexSubImage1D(target, level, xoffset, x, y, width);
}

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);
}

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

void GL_APIENTRY glDisableClientState(GLenum array)
{
    return gl::DisableClientState(array);
}

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 glEdgeFlagPointer(GLsizei stride, const void *pointer)
{
    return gl::EdgeFlagPointer(stride, pointer);
}

void GL_APIENTRY glEnableClientState(GLenum array)
{
    return gl::EnableClientState(array);
}

void GL_APIENTRY glGenTextures(GLsizei n, GLuint *textures)
{
    return gl::GenTextures(n, textures);
}

void GL_APIENTRY glGetPointerv(GLenum pname, void **params)
{
    return gl::GetPointerv(pname, params);
}

void GL_APIENTRY glIndexPointer(GLenum type, GLsizei stride, const void *pointer)
{
    return gl::IndexPointer(type, stride, pointer);
}

void GL_APIENTRY glIndexub(GLubyte c)
{
    return gl::Indexub(c);
}

void GL_APIENTRY glIndexubv(const GLubyte *c)
{
    return gl::Indexubv(c);
}

void GL_APIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
{
    return gl::InterleavedArrays(format, stride, pointer);
}

GLboolean GL_APIENTRY glIsTexture(GLuint texture)
{
    return gl::IsTexture(texture);
}

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

void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
{
    return gl::PolygonOffset(factor, units);
}

void GL_APIENTRY glPopClientAttrib()
{
    return gl::PopClientAttrib();
}

void GL_APIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
{
    return gl::PrioritizeTextures(n, textures, priorities);
}

void GL_APIENTRY glPushClientAttrib(GLbitfield mask)
{
    return gl::PushClientAttrib(mask);
}

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

void GL_APIENTRY glTexSubImage1D(GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLsizei width,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
{
    return gl::TexSubImage1D(target, level, xoffset, width, format, type, pixels);
}

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 glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return gl::VertexPointer(size, type, stride, pointer);
}

// GL 1.2
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 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 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 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);
}

// GL 1.3
void GL_APIENTRY glActiveTexture(GLenum texture)
{
    return gl::ActiveTexture(texture);
}

void GL_APIENTRY glClientActiveTexture(GLenum texture)
{
    return gl::ClientActiveTexture(texture);
}

void GL_APIENTRY glCompressedTexImage1D(GLenum target,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLint border,
                                        GLsizei imageSize,
                                        const void *data)
{
    return gl::CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}

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 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 glCompressedTexSubImage1D(GLenum target,
                                           GLint level,
                                           GLint xoffset,
                                           GLsizei width,
                                           GLenum format,
                                           GLsizei imageSize,
                                           const void *data)
{
    return gl::CompressedTexSubImage1D(target, level, xoffset, width, format, 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 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 glGetCompressedTexImage(GLenum target, GLint level, void *img)
{
    return gl::GetCompressedTexImage(target, level, img);
}

void GL_APIENTRY glLoadTransposeMatrixd(const GLdouble *m)
{
    return gl::LoadTransposeMatrixd(m);
}

void GL_APIENTRY glLoadTransposeMatrixf(const GLfloat *m)
{
    return gl::LoadTransposeMatrixf(m);
}

void GL_APIENTRY glMultTransposeMatrixd(const GLdouble *m)
{
    return gl::MultTransposeMatrixd(m);
}

void GL_APIENTRY glMultTransposeMatrixf(const GLfloat *m)
{
    return gl::MultTransposeMatrixf(m);
}

void GL_APIENTRY glMultiTexCoord1d(GLenum target, GLdouble s)
{
    return gl::MultiTexCoord1d(target, s);
}

void GL_APIENTRY glMultiTexCoord1dv(GLenum target, const GLdouble *v)
{
    return gl::MultiTexCoord1dv(target, v);
}

void GL_APIENTRY glMultiTexCoord1f(GLenum target, GLfloat s)
{
    return gl::MultiTexCoord1f(target, s);
}

void GL_APIENTRY glMultiTexCoord1fv(GLenum target, const GLfloat *v)
{
    return gl::MultiTexCoord1fv(target, v);
}

void GL_APIENTRY glMultiTexCoord1i(GLenum target, GLint s)
{
    return gl::MultiTexCoord1i(target, s);
}

void GL_APIENTRY glMultiTexCoord1iv(GLenum target, const GLint *v)
{
    return gl::MultiTexCoord1iv(target, v);
}

void GL_APIENTRY glMultiTexCoord1s(GLenum target, GLshort s)
{
    return gl::MultiTexCoord1s(target, s);
}

void GL_APIENTRY glMultiTexCoord1sv(GLenum target, const GLshort *v)
{
    return gl::MultiTexCoord1sv(target, v);
}

void GL_APIENTRY glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
{
    return gl::MultiTexCoord2d(target, s, t);
}

void GL_APIENTRY glMultiTexCoord2dv(GLenum target, const GLdouble *v)
{
    return gl::MultiTexCoord2dv(target, v);
}

void GL_APIENTRY glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
{
    return gl::MultiTexCoord2f(target, s, t);
}

void GL_APIENTRY glMultiTexCoord2fv(GLenum target, const GLfloat *v)
{
    return gl::MultiTexCoord2fv(target, v);
}

void GL_APIENTRY glMultiTexCoord2i(GLenum target, GLint s, GLint t)
{
    return gl::MultiTexCoord2i(target, s, t);
}

void GL_APIENTRY glMultiTexCoord2iv(GLenum target, const GLint *v)
{
    return gl::MultiTexCoord2iv(target, v);
}

void GL_APIENTRY glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
{
    return gl::MultiTexCoord2s(target, s, t);
}

void GL_APIENTRY glMultiTexCoord2sv(GLenum target, const GLshort *v)
{
    return gl::MultiTexCoord2sv(target, v);
}

void GL_APIENTRY glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
    return gl::MultiTexCoord3d(target, s, t, r);
}

void GL_APIENTRY glMultiTexCoord3dv(GLenum target, const GLdouble *v)
{
    return gl::MultiTexCoord3dv(target, v);
}

void GL_APIENTRY glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
    return gl::MultiTexCoord3f(target, s, t, r);
}

void GL_APIENTRY glMultiTexCoord3fv(GLenum target, const GLfloat *v)
{
    return gl::MultiTexCoord3fv(target, v);
}

void GL_APIENTRY glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
    return gl::MultiTexCoord3i(target, s, t, r);
}

void GL_APIENTRY glMultiTexCoord3iv(GLenum target, const GLint *v)
{
    return gl::MultiTexCoord3iv(target, v);
}

void GL_APIENTRY glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
{
    return gl::MultiTexCoord3s(target, s, t, r);
}

void GL_APIENTRY glMultiTexCoord3sv(GLenum target, const GLshort *v)
{
    return gl::MultiTexCoord3sv(target, v);
}

void GL_APIENTRY glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    return gl::MultiTexCoord4d(target, s, t, r, q);
}

void GL_APIENTRY glMultiTexCoord4dv(GLenum target, const GLdouble *v)
{
    return gl::MultiTexCoord4dv(target, v);
}

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 glMultiTexCoord4fv(GLenum target, const GLfloat *v)
{
    return gl::MultiTexCoord4fv(target, v);
}

void GL_APIENTRY glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
    return gl::MultiTexCoord4i(target, s, t, r, q);
}

void GL_APIENTRY glMultiTexCoord4iv(GLenum target, const GLint *v)
{
    return gl::MultiTexCoord4iv(target, v);
}

void GL_APIENTRY glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
    return gl::MultiTexCoord4s(target, s, t, r, q);
}

void GL_APIENTRY glMultiTexCoord4sv(GLenum target, const GLshort *v)
{
    return gl::MultiTexCoord4sv(target, v);
}

void GL_APIENTRY glSampleCoverage(GLfloat value, GLboolean invert)
{
    return gl::SampleCoverage(value, invert);
}

// GL 1.4
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 glBlendFuncSeparate(GLenum sfactorRGB,
                                     GLenum dfactorRGB,
                                     GLenum sfactorAlpha,
                                     GLenum dfactorAlpha)
{
    return gl::BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void GL_APIENTRY glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
{
    return gl::FogCoordPointer(type, stride, pointer);
}

void GL_APIENTRY glFogCoordd(GLdouble coord)
{
    return gl::FogCoordd(coord);
}

void GL_APIENTRY glFogCoorddv(const GLdouble *coord)
{
    return gl::FogCoorddv(coord);
}

void GL_APIENTRY glFogCoordf(GLfloat coord)
{
    return gl::FogCoordf(coord);
}

void GL_APIENTRY glFogCoordfv(const GLfloat *coord)
{
    return gl::FogCoordfv(coord);
}

void GL_APIENTRY glMultiDrawArrays(GLenum mode,
                                   const GLint *first,
                                   const GLsizei *count,
                                   GLsizei drawcount)
{
    return gl::MultiDrawArrays(mode, first, count, drawcount);
}

void GL_APIENTRY glMultiDrawElements(GLenum mode,
                                     const GLsizei *count,
                                     GLenum type,
                                     const void *const *indices,
                                     GLsizei drawcount)
{
    return gl::MultiDrawElements(mode, count, type, indices, drawcount);
}

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 glPointParameteri(GLenum pname, GLint param)
{
    return gl::PointParameteri(pname, param);
}

void GL_APIENTRY glPointParameteriv(GLenum pname, const GLint *params)
{
    return gl::PointParameteriv(pname, params);
}

void GL_APIENTRY glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
    return gl::SecondaryColor3b(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3bv(const GLbyte *v)
{
    return gl::SecondaryColor3bv(v);
}

void GL_APIENTRY glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
    return gl::SecondaryColor3d(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3dv(const GLdouble *v)
{
    return gl::SecondaryColor3dv(v);
}

void GL_APIENTRY glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
    return gl::SecondaryColor3f(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3fv(const GLfloat *v)
{
    return gl::SecondaryColor3fv(v);
}

void GL_APIENTRY glSecondaryColor3i(GLint red, GLint green, GLint blue)
{
    return gl::SecondaryColor3i(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3iv(const GLint *v)
{
    return gl::SecondaryColor3iv(v);
}

void GL_APIENTRY glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
{
    return gl::SecondaryColor3s(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3sv(const GLshort *v)
{
    return gl::SecondaryColor3sv(v);
}

void GL_APIENTRY glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
    return gl::SecondaryColor3ub(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3ubv(const GLubyte *v)
{
    return gl::SecondaryColor3ubv(v);
}

void GL_APIENTRY glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
{
    return gl::SecondaryColor3ui(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3uiv(const GLuint *v)
{
    return gl::SecondaryColor3uiv(v);
}

void GL_APIENTRY glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
{
    return gl::SecondaryColor3us(red, green, blue);
}

void GL_APIENTRY glSecondaryColor3usv(const GLushort *v)
{
    return gl::SecondaryColor3usv(v);
}

void GL_APIENTRY glSecondaryColorPointer(GLint size,
                                         GLenum type,
                                         GLsizei stride,
                                         const void *pointer)
{
    return gl::SecondaryColorPointer(size, type, stride, pointer);
}

void GL_APIENTRY glWindowPos2d(GLdouble x, GLdouble y)
{
    return gl::WindowPos2d(x, y);
}

void GL_APIENTRY glWindowPos2dv(const GLdouble *v)
{
    return gl::WindowPos2dv(v);
}

void GL_APIENTRY glWindowPos2f(GLfloat x, GLfloat y)
{
    return gl::WindowPos2f(x, y);
}

void GL_APIENTRY glWindowPos2fv(const GLfloat *v)
{
    return gl::WindowPos2fv(v);
}

void GL_APIENTRY glWindowPos2i(GLint x, GLint y)
{
    return gl::WindowPos2i(x, y);
}

void GL_APIENTRY glWindowPos2iv(const GLint *v)
{
    return gl::WindowPos2iv(v);
}

void GL_APIENTRY glWindowPos2s(GLshort x, GLshort y)
{
    return gl::WindowPos2s(x, y);
}

void GL_APIENTRY glWindowPos2sv(const GLshort *v)
{
    return gl::WindowPos2sv(v);
}

void GL_APIENTRY glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    return gl::WindowPos3d(x, y, z);
}

void GL_APIENTRY glWindowPos3dv(const GLdouble *v)
{
    return gl::WindowPos3dv(v);
}

void GL_APIENTRY glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    return gl::WindowPos3f(x, y, z);
}

void GL_APIENTRY glWindowPos3fv(const GLfloat *v)
{
    return gl::WindowPos3fv(v);
}

void GL_APIENTRY glWindowPos3i(GLint x, GLint y, GLint z)
{
    return gl::WindowPos3i(x, y, z);
}

void GL_APIENTRY glWindowPos3iv(const GLint *v)
{
    return gl::WindowPos3iv(v);
}

void GL_APIENTRY glWindowPos3s(GLshort x, GLshort y, GLshort z)
{
    return gl::WindowPos3s(x, y, z);
}

void GL_APIENTRY glWindowPos3sv(const GLshort *v)
{
    return gl::WindowPos3sv(v);
}

// GL 1.5
void GL_APIENTRY glBeginQuery(GLenum target, GLuint id)
{
    return gl::BeginQuery(target, id);
}

void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer)
{
    return gl::BindBuffer(target, buffer);
}

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);
}

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

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

void GL_APIENTRY glEndQuery(GLenum target)
{
    return gl::EndQuery(target);
}

void GL_APIENTRY glGenBuffers(GLsizei n, GLuint *buffers)
{
    return gl::GenBuffers(n, buffers);
}

void GL_APIENTRY glGenQueries(GLsizei n, GLuint *ids)
{
    return gl::GenQueries(n, ids);
}

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

void GL_APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params)
{
    return gl::GetBufferPointerv(target, pname, params);
}

void GL_APIENTRY glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
{
    return gl::GetBufferSubData(target, offset, size, data);
}

void GL_APIENTRY glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
{
    return gl::GetQueryObjectiv(id, pname, params);
}

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);
}

GLboolean GL_APIENTRY glIsBuffer(GLuint buffer)
{
    return gl::IsBuffer(buffer);
}

GLboolean GL_APIENTRY glIsQuery(GLuint id)
{
    return gl::IsQuery(id);
}

void *GL_APIENTRY glMapBuffer(GLenum target, GLenum access)
{
    return gl::MapBuffer(target, access);
}

GLboolean GL_APIENTRY glUnmapBuffer(GLenum target)
{
    return gl::UnmapBuffer(target);
}

// GL 2.0
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 glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
    return gl::BlendEquationSeparate(modeRGB, modeAlpha);
}

void GL_APIENTRY glCompileShader(GLuint shader)
{
    return gl::CompileShader(shader);
}

GLuint GL_APIENTRY glCreateProgram()
{
    return gl::CreateProgram();
}

GLuint GL_APIENTRY glCreateShader(GLenum type)
{
    return gl::CreateShader(type);
}

void GL_APIENTRY glDeleteProgram(GLuint program)
{
    return gl::DeleteProgram(program);
}

void GL_APIENTRY glDeleteShader(GLuint shader)
{
    return gl::DeleteShader(shader);
}

void GL_APIENTRY glDetachShader(GLuint program, GLuint shader)
{
    return gl::DetachShader(program, shader);
}

void GL_APIENTRY glDisableVertexAttribArray(GLuint index)
{
    return gl::DisableVertexAttribArray(index);
}

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

void GL_APIENTRY glEnableVertexAttribArray(GLuint index)
{
    return gl::EnableVertexAttribArray(index);
}

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 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 glGetShaderInfoLog(GLuint shader,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLchar *infoLog)
{
    return gl::GetShaderInfoLog(shader, bufSize, length, infoLog);
}

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);
}

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 glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
{
    return gl::GetVertexAttribdv(index, pname, params);
}

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);
}

GLboolean GL_APIENTRY glIsProgram(GLuint program)
{
    return gl::IsProgram(program);
}

GLboolean GL_APIENTRY glIsShader(GLuint shader)
{
    return gl::IsShader(shader);
}

void GL_APIENTRY glLinkProgram(GLuint program)
{
    return gl::LinkProgram(program);
}

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 glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
    return gl::StencilFuncSeparate(face, func, ref, mask);
}

void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)
{
    return gl::StencilMaskSeparate(face, mask);
}

void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
    return gl::StencilOpSeparate(face, sfail, dpfail, dppass);
}

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 glVertexAttrib1d(GLuint index, GLdouble x)
{
    return gl::VertexAttrib1d(index, x);
}

void GL_APIENTRY glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttrib1dv(index, v);
}

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 glVertexAttrib1s(GLuint index, GLshort x)
{
    return gl::VertexAttrib1s(index, x);
}

void GL_APIENTRY glVertexAttrib1sv(GLuint index, const GLshort *v)
{
    return gl::VertexAttrib1sv(index, v);
}

void GL_APIENTRY glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
    return gl::VertexAttrib2d(index, x, y);
}

void GL_APIENTRY glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttrib2dv(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 glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
    return gl::VertexAttrib2s(index, x, y);
}

void GL_APIENTRY glVertexAttrib2sv(GLuint index, const GLshort *v)
{
    return gl::VertexAttrib2sv(index, v);
}

void GL_APIENTRY glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
    return gl::VertexAttrib3d(index, x, y, z);
}

void GL_APIENTRY glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttrib3dv(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 glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
    return gl::VertexAttrib3s(index, x, y, z);
}

void GL_APIENTRY glVertexAttrib3sv(GLuint index, const GLshort *v)
{
    return gl::VertexAttrib3sv(index, v);
}

void GL_APIENTRY glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
    return gl::VertexAttrib4Nbv(index, v);
}

void GL_APIENTRY glVertexAttrib4Niv(GLuint index, const GLint *v)
{
    return gl::VertexAttrib4Niv(index, v);
}

void GL_APIENTRY glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
    return gl::VertexAttrib4Nsv(index, v);
}

void GL_APIENTRY glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
    return gl::VertexAttrib4Nub(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
    return gl::VertexAttrib4Nubv(index, v);
}

void GL_APIENTRY glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
    return gl::VertexAttrib4Nuiv(index, v);
}

void GL_APIENTRY glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
    return gl::VertexAttrib4Nusv(index, v);
}

void GL_APIENTRY glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
    return gl::VertexAttrib4bv(index, v);
}

void GL_APIENTRY glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    return gl::VertexAttrib4d(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttrib4dv(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 glVertexAttrib4iv(GLuint index, const GLint *v)
{
    return gl::VertexAttrib4iv(index, v);
}

void GL_APIENTRY glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
    return gl::VertexAttrib4s(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttrib4sv(GLuint index, const GLshort *v)
{
    return gl::VertexAttrib4sv(index, v);
}

void GL_APIENTRY glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
    return gl::VertexAttrib4ubv(index, v);
}

void GL_APIENTRY glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
    return gl::VertexAttrib4uiv(index, v);
}

void GL_APIENTRY glVertexAttrib4usv(GLuint index, const GLushort *v)
{
    return gl::VertexAttrib4usv(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);
}

// GL 2.1
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);
}

// GL 3.0
void GL_APIENTRY glBeginConditionalRender(GLuint id, GLenum mode)
{
    return gl::BeginConditionalRender(id, mode);
}

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 glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
{
    return gl::BindFragDataLocation(program, color, name);
}

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 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);
}

GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target)
{
    return gl::CheckFramebufferStatus(target);
}

void GL_APIENTRY glClampColor(GLenum target, GLenum clamp)
{
    return gl::ClampColor(target, clamp);
}

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);
}

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 glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
{
    return gl::DeleteFramebuffers(n, framebuffers);
}

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

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

void GL_APIENTRY glDisablei(GLenum target, GLuint index)
{
    return gl::Disablei(target, index);
}

void GL_APIENTRY glEnablei(GLenum target, GLuint index)
{
    return gl::Enablei(target, index);
}

void GL_APIENTRY glEndConditionalRender()
{
    return gl::EndConditionalRender();
}

void GL_APIENTRY glEndTransformFeedback()
{
    return gl::EndTransformFeedback();
}

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

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

void GL_APIENTRY glFramebufferTexture1D(GLenum target,
                                        GLenum attachment,
                                        GLenum textarget,
                                        GLuint texture,
                                        GLint level)
{
    return gl::FramebufferTexture1D(target, attachment, textarget, texture, level);
}

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 glFramebufferTexture3D(GLenum target,
                                        GLenum attachment,
                                        GLenum textarget,
                                        GLuint texture,
                                        GLint level,
                                        GLint zoffset)
{
    return gl::FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}

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 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 glGenVertexArrays(GLsizei n, GLuint *arrays)
{
    return gl::GenVertexArrays(n, arrays);
}

void GL_APIENTRY glGenerateMipmap(GLenum target)
{
    return gl::GenerateMipmap(target);
}

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

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

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

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

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

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

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 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);
}

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);
}

GLboolean GL_APIENTRY glIsEnabledi(GLenum target, GLuint index)
{
    return gl::IsEnabledi(target, index);
}

GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer)
{
    return gl::IsFramebuffer(framebuffer);
}

GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer)
{
    return gl::IsRenderbuffer(renderbuffer);
}

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 glRenderbufferStorage(GLenum target,
                                       GLenum internalformat,
                                       GLsizei width,
                                       GLsizei height)
{
    return gl::RenderbufferStorage(target, internalformat, width, height);
}

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 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 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 glVertexAttribI1i(GLuint index, GLint x)
{
    return gl::VertexAttribI1i(index, x);
}

void GL_APIENTRY glVertexAttribI1iv(GLuint index, const GLint *v)
{
    return gl::VertexAttribI1iv(index, v);
}

void GL_APIENTRY glVertexAttribI1ui(GLuint index, GLuint x)
{
    return gl::VertexAttribI1ui(index, x);
}

void GL_APIENTRY glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
    return gl::VertexAttribI1uiv(index, v);
}

void GL_APIENTRY glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
    return gl::VertexAttribI2i(index, x, y);
}

void GL_APIENTRY glVertexAttribI2iv(GLuint index, const GLint *v)
{
    return gl::VertexAttribI2iv(index, v);
}

void GL_APIENTRY glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
    return gl::VertexAttribI2ui(index, x, y);
}

void GL_APIENTRY glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
    return gl::VertexAttribI2uiv(index, v);
}

void GL_APIENTRY glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
    return gl::VertexAttribI3i(index, x, y, z);
}

void GL_APIENTRY glVertexAttribI3iv(GLuint index, const GLint *v)
{
    return gl::VertexAttribI3iv(index, v);
}

void GL_APIENTRY glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
    return gl::VertexAttribI3ui(index, x, y, z);
}

void GL_APIENTRY glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
    return gl::VertexAttribI3uiv(index, v);
}

void GL_APIENTRY glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
    return gl::VertexAttribI4bv(index, v);
}

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 glVertexAttribI4sv(GLuint index, const GLshort *v)
{
    return gl::VertexAttribI4sv(index, v);
}

void GL_APIENTRY glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
    return gl::VertexAttribI4ubv(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 glVertexAttribI4usv(GLuint index, const GLushort *v)
{
    return gl::VertexAttribI4usv(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);
}

// GL 3.1
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 glDrawArraysInstanced(GLenum mode,
                                       GLint first,
                                       GLsizei count,
                                       GLsizei instancecount)
{
    return gl::DrawArraysInstanced(mode, first, count, instancecount);
}

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 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 glGetActiveUniformName(GLuint program,
                                        GLuint uniformIndex,
                                        GLsizei bufSize,
                                        GLsizei *length,
                                        GLchar *uniformName)
{
    return gl::GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}

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

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 glPrimitiveRestartIndex(GLuint index)
{
    return gl::PrimitiveRestartIndex(index);
}

void GL_APIENTRY glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
    return gl::TexBuffer(target, internalformat, buffer);
}

void GL_APIENTRY glUniformBlockBinding(GLuint program,
                                       GLuint uniformBlockIndex,
                                       GLuint uniformBlockBinding)
{
    return gl::UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}

// GL 3.2
GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
    return gl::ClientWaitSync(sync, flags, timeout);
}

void GL_APIENTRY glDeleteSync(GLsync sync)
{
    return gl::DeleteSync(sync);
}

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);
}

GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)
{
    return gl::FenceSync(condition, flags);
}

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

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

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 glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
{
    return gl::GetMultisamplefv(pname, index, val);
}

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

GLboolean GL_APIENTRY glIsSync(GLsync sync)
{
    return gl::IsSync(sync);
}

void GL_APIENTRY glMultiDrawElementsBaseVertex(GLenum mode,
                                               const GLsizei *count,
                                               GLenum type,
                                               const void *const *indices,
                                               GLsizei drawcount,
                                               const GLint *basevertex)
{
    return gl::MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}

void GL_APIENTRY glProvokingVertex(GLenum mode)
{
    return gl::ProvokingVertex(mode);
}

void GL_APIENTRY glSampleMaski(GLuint maskNumber, GLbitfield mask)
{
    return gl::SampleMaski(maskNumber, mask);
}

void GL_APIENTRY glTexImage2DMultisample(GLenum target,
                                         GLsizei samples,
                                         GLenum internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLboolean fixedsamplelocations)
{
    return gl::TexImage2DMultisample(target, samples, internalformat, width, height,
                                     fixedsamplelocations);
}

void GL_APIENTRY glTexImage3DMultisample(GLenum target,
                                         GLsizei samples,
                                         GLenum internalformat,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLboolean fixedsamplelocations)
{
    return gl::TexImage3DMultisample(target, samples, internalformat, width, height, depth,
                                     fixedsamplelocations);
}

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

// GL 3.3
void GL_APIENTRY glBindFragDataLocationIndexed(GLuint program,
                                               GLuint colorNumber,
                                               GLuint index,
                                               const GLchar *name)
{
    return gl::BindFragDataLocationIndexed(program, colorNumber, index, name);
}

void GL_APIENTRY glBindSampler(GLuint unit, GLuint sampler)
{
    return gl::BindSampler(unit, sampler);
}

void GL_APIENTRY glColorP3ui(GLenum type, GLuint color)
{
    return gl::ColorP3ui(type, color);
}

void GL_APIENTRY glColorP3uiv(GLenum type, const GLuint *color)
{
    return gl::ColorP3uiv(type, color);
}

void GL_APIENTRY glColorP4ui(GLenum type, GLuint color)
{
    return gl::ColorP4ui(type, color);
}

void GL_APIENTRY glColorP4uiv(GLenum type, const GLuint *color)
{
    return gl::ColorP4uiv(type, color);
}

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

void GL_APIENTRY glGenSamplers(GLsizei count, GLuint *samplers)
{
    return gl::GenSamplers(count, samplers);
}

GLint GL_APIENTRY glGetFragDataIndex(GLuint program, const GLchar *name)
{
    return gl::GetFragDataIndex(program, name);
}

void GL_APIENTRY glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
{
    return gl::GetQueryObjecti64v(id, pname, params);
}

void GL_APIENTRY glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
{
    return gl::GetQueryObjectui64v(id, 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 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);
}

GLboolean GL_APIENTRY glIsSampler(GLuint sampler)
{
    return gl::IsSampler(sampler);
}

void GL_APIENTRY glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
    return gl::MultiTexCoordP1ui(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    return gl::MultiTexCoordP1uiv(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
    return gl::MultiTexCoordP2ui(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    return gl::MultiTexCoordP2uiv(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
    return gl::MultiTexCoordP3ui(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    return gl::MultiTexCoordP3uiv(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
    return gl::MultiTexCoordP4ui(texture, type, coords);
}

void GL_APIENTRY glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
    return gl::MultiTexCoordP4uiv(texture, type, coords);
}

void GL_APIENTRY glNormalP3ui(GLenum type, GLuint coords)
{
    return gl::NormalP3ui(type, coords);
}

void GL_APIENTRY glNormalP3uiv(GLenum type, const GLuint *coords)
{
    return gl::NormalP3uiv(type, coords);
}

void GL_APIENTRY glQueryCounter(GLuint id, GLenum target)
{
    return gl::QueryCounter(id, target);
}

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 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 glSecondaryColorP3ui(GLenum type, GLuint color)
{
    return gl::SecondaryColorP3ui(type, color);
}

void GL_APIENTRY glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
    return gl::SecondaryColorP3uiv(type, color);
}

void GL_APIENTRY glTexCoordP1ui(GLenum type, GLuint coords)
{
    return gl::TexCoordP1ui(type, coords);
}

void GL_APIENTRY glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
    return gl::TexCoordP1uiv(type, coords);
}

void GL_APIENTRY glTexCoordP2ui(GLenum type, GLuint coords)
{
    return gl::TexCoordP2ui(type, coords);
}

void GL_APIENTRY glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
    return gl::TexCoordP2uiv(type, coords);
}

void GL_APIENTRY glTexCoordP3ui(GLenum type, GLuint coords)
{
    return gl::TexCoordP3ui(type, coords);
}

void GL_APIENTRY glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
    return gl::TexCoordP3uiv(type, coords);
}

void GL_APIENTRY glTexCoordP4ui(GLenum type, GLuint coords)
{
    return gl::TexCoordP4ui(type, coords);
}

void GL_APIENTRY glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
    return gl::TexCoordP4uiv(type, coords);
}

void GL_APIENTRY glVertexAttribDivisor(GLuint index, GLuint divisor)
{
    return gl::VertexAttribDivisor(index, divisor);
}

void GL_APIENTRY glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    return gl::VertexAttribP1ui(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP1uiv(GLuint index,
                                     GLenum type,
                                     GLboolean normalized,
                                     const GLuint *value)
{
    return gl::VertexAttribP1uiv(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    return gl::VertexAttribP2ui(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP2uiv(GLuint index,
                                     GLenum type,
                                     GLboolean normalized,
                                     const GLuint *value)
{
    return gl::VertexAttribP2uiv(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    return gl::VertexAttribP3ui(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP3uiv(GLuint index,
                                     GLenum type,
                                     GLboolean normalized,
                                     const GLuint *value)
{
    return gl::VertexAttribP3uiv(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
    return gl::VertexAttribP4ui(index, type, normalized, value);
}

void GL_APIENTRY glVertexAttribP4uiv(GLuint index,
                                     GLenum type,
                                     GLboolean normalized,
                                     const GLuint *value)
{
    return gl::VertexAttribP4uiv(index, type, normalized, value);
}

void GL_APIENTRY glVertexP2ui(GLenum type, GLuint value)
{
    return gl::VertexP2ui(type, value);
}

void GL_APIENTRY glVertexP2uiv(GLenum type, const GLuint *value)
{
    return gl::VertexP2uiv(type, value);
}

void GL_APIENTRY glVertexP3ui(GLenum type, GLuint value)
{
    return gl::VertexP3ui(type, value);
}

void GL_APIENTRY glVertexP3uiv(GLenum type, const GLuint *value)
{
    return gl::VertexP3uiv(type, value);
}

void GL_APIENTRY glVertexP4ui(GLenum type, GLuint value)
{
    return gl::VertexP4ui(type, value);
}

void GL_APIENTRY glVertexP4uiv(GLenum type, const GLuint *value)
{
    return gl::VertexP4uiv(type, value);
}

// GL 4.0
void GL_APIENTRY glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
{
    return gl::BeginQueryIndexed(target, index, id);
}

void GL_APIENTRY glBindTransformFeedback(GLenum target, GLuint id)
{
    return gl::BindTransformFeedback(target, id);
}

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 glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
{
    return gl::DeleteTransformFeedbacks(n, ids);
}

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 glDrawTransformFeedback(GLenum mode, GLuint id)
{
    return gl::DrawTransformFeedback(mode, id);
}

void GL_APIENTRY glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
{
    return gl::DrawTransformFeedbackStream(mode, id, stream);
}

void GL_APIENTRY glEndQueryIndexed(GLenum target, GLuint index)
{
    return gl::EndQueryIndexed(target, index);
}

void GL_APIENTRY glGenTransformFeedbacks(GLsizei n, GLuint *ids)
{
    return gl::GenTransformFeedbacks(n, ids);
}

void GL_APIENTRY glGetActiveSubroutineName(GLuint program,
                                           GLenum shadertype,
                                           GLuint index,
                                           GLsizei bufsize,
                                           GLsizei *length,
                                           GLchar *name)
{
    return gl::GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}

void GL_APIENTRY glGetActiveSubroutineUniformName(GLuint program,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLsizei bufsize,
                                                  GLsizei *length,
                                                  GLchar *name)
{
    return gl::GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}

void GL_APIENTRY glGetActiveSubroutineUniformiv(GLuint program,
                                                GLenum shadertype,
                                                GLuint index,
                                                GLenum pname,
                                                GLint *values)
{
    return gl::GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
}

void GL_APIENTRY glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
{
    return gl::GetProgramStageiv(program, shadertype, pname, values);
}

void GL_APIENTRY glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
{
    return gl::GetQueryIndexediv(target, index, pname, params);
}

GLuint GL_APIENTRY glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
{
    return gl::GetSubroutineIndex(program, shadertype, name);
}

GLint GL_APIENTRY glGetSubroutineUniformLocation(GLuint program,
                                                 GLenum shadertype,
                                                 const GLchar *name)
{
    return gl::GetSubroutineUniformLocation(program, shadertype, name);
}

void GL_APIENTRY glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
{
    return gl::GetUniformSubroutineuiv(shadertype, location, params);
}

void GL_APIENTRY glGetUniformdv(GLuint program, GLint location, GLdouble *params)
{
    return gl::GetUniformdv(program, location, params);
}

GLboolean GL_APIENTRY glIsTransformFeedback(GLuint id)
{
    return gl::IsTransformFeedback(id);
}

void GL_APIENTRY glMinSampleShading(GLfloat value)
{
    return gl::MinSampleShading(value);
}

void GL_APIENTRY glPatchParameterfv(GLenum pname, const GLfloat *values)
{
    return gl::PatchParameterfv(pname, values);
}

void GL_APIENTRY glPatchParameteri(GLenum pname, GLint value)
{
    return gl::PatchParameteri(pname, value);
}

void GL_APIENTRY glPauseTransformFeedback()
{
    return gl::PauseTransformFeedback();
}

void GL_APIENTRY glResumeTransformFeedback()
{
    return gl::ResumeTransformFeedback();
}

void GL_APIENTRY glUniform1d(GLint location, GLdouble x)
{
    return gl::Uniform1d(location, x);
}

void GL_APIENTRY glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
{
    return gl::Uniform1dv(location, count, value);
}

void GL_APIENTRY glUniform2d(GLint location, GLdouble x, GLdouble y)
{
    return gl::Uniform2d(location, x, y);
}

void GL_APIENTRY glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
{
    return gl::Uniform2dv(location, count, value);
}

void GL_APIENTRY glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
    return gl::Uniform3d(location, x, y, z);
}

void GL_APIENTRY glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
{
    return gl::Uniform3dv(location, count, value);
}

void GL_APIENTRY glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    return gl::Uniform4d(location, x, y, z, w);
}

void GL_APIENTRY glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
{
    return gl::Uniform4dv(location, count, value);
}

void GL_APIENTRY glUniformMatrix2dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{
    return gl::UniformMatrix2dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix2x3dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix2x3dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix2x4dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix2x4dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{
    return gl::UniformMatrix3dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x2dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix3x2dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix3x4dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix3x4dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4dv(GLint location,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{
    return gl::UniformMatrix4dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x2dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix4x2dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformMatrix4x3dv(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{
    return gl::UniformMatrix4x3dv(location, count, transpose, value);
}

void GL_APIENTRY glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
{
    return gl::UniformSubroutinesuiv(shadertype, count, indices);
}

// GL 4.1
void GL_APIENTRY glActiveShaderProgram(GLuint pipeline, GLuint program)
{
    return gl::ActiveShaderProgram(pipeline, program);
}

void GL_APIENTRY glBindProgramPipeline(GLuint pipeline)
{
    return gl::BindProgramPipeline(pipeline);
}

void GL_APIENTRY glClearDepthf(GLfloat d)
{
    return gl::ClearDepthf(d);
}

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 glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
{
    return gl::DepthRangeArrayv(first, count, v);
}

void GL_APIENTRY glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
{
    return gl::DepthRangeIndexed(index, n, f);
}

void GL_APIENTRY glDepthRangef(GLfloat n, GLfloat f)
{
    return gl::DepthRangef(n, f);
}

void GL_APIENTRY glGenProgramPipelines(GLsizei n, GLuint *pipelines)
{
    return gl::GenProgramPipelines(n, pipelines);
}

void GL_APIENTRY glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
{
    return gl::GetDoublei_v(target, index, data);
}

void GL_APIENTRY glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
{
    return gl::GetFloati_v(target, index, data);
}

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 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);
}

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

void GL_APIENTRY glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
{
    return gl::GetVertexAttribLdv(index, pname, params);
}

GLboolean GL_APIENTRY glIsProgramPipeline(GLuint pipeline)
{
    return gl::IsProgramPipeline(pipeline);
}

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 glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
{
    return gl::ProgramUniform1d(program, location, v0);
}

void GL_APIENTRY glProgramUniform1dv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLdouble *value)
{
    return gl::ProgramUniform1dv(program, location, count, value);
}

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 glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
{
    return gl::ProgramUniform2d(program, location, v0, v1);
}

void GL_APIENTRY glProgramUniform2dv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLdouble *value)
{
    return gl::ProgramUniform2dv(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
glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
{
    return gl::ProgramUniform3d(program, location, v0, v1, v2);
}

void GL_APIENTRY glProgramUniform3dv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLdouble *value)
{
    return gl::ProgramUniform3dv(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 glProgramUniform4d(GLuint program,
                                    GLint location,
                                    GLdouble v0,
                                    GLdouble v1,
                                    GLdouble v2,
                                    GLdouble v3)
{
    return gl::ProgramUniform4d(program, location, v0, v1, v2, v3);
}

void GL_APIENTRY glProgramUniform4dv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLdouble *value)
{
    return gl::ProgramUniform4dv(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 glProgramUniformMatrix2dv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{
    return gl::ProgramUniformMatrix2dv(program, location, count, transpose, 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 glProgramUniformMatrix2x3dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix2x3dv(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 glProgramUniformMatrix2x4dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix2x4dv(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 glProgramUniformMatrix3dv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{
    return gl::ProgramUniformMatrix3dv(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 glProgramUniformMatrix3x2dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix3x2dv(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 glProgramUniformMatrix3x4dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix3x4dv(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 glProgramUniformMatrix4dv(GLuint program,
                                           GLint location,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{
    return gl::ProgramUniformMatrix4dv(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 glProgramUniformMatrix4x2dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix4x2dv(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 glProgramUniformMatrix4x3dv(GLuint program,
                                             GLint location,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{
    return gl::ProgramUniformMatrix4x3dv(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 glReleaseShaderCompiler()
{
    return gl::ReleaseShaderCompiler();
}

void GL_APIENTRY glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
{
    return gl::ScissorArrayv(first, count, v);
}

void GL_APIENTRY
glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
{
    return gl::ScissorIndexed(index, left, bottom, width, height);
}

void GL_APIENTRY glScissorIndexedv(GLuint index, const GLint *v)
{
    return gl::ScissorIndexedv(index, v);
}

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 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 glVertexAttribL1d(GLuint index, GLdouble x)
{
    return gl::VertexAttribL1d(index, x);
}

void GL_APIENTRY glVertexAttribL1dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttribL1dv(index, v);
}

void GL_APIENTRY glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
{
    return gl::VertexAttribL2d(index, x, y);
}

void GL_APIENTRY glVertexAttribL2dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttribL2dv(index, v);
}

void GL_APIENTRY glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
    return gl::VertexAttribL3d(index, x, y, z);
}

void GL_APIENTRY glVertexAttribL3dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttribL3dv(index, v);
}

void GL_APIENTRY glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    return gl::VertexAttribL4d(index, x, y, z, w);
}

void GL_APIENTRY glVertexAttribL4dv(GLuint index, const GLdouble *v)
{
    return gl::VertexAttribL4dv(index, v);
}

void GL_APIENTRY
glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    return gl::VertexAttribLPointer(index, size, type, stride, pointer);
}

void GL_APIENTRY glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
{
    return gl::ViewportArrayv(first, count, v);
}

void GL_APIENTRY glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
{
    return gl::ViewportIndexedf(index, x, y, w, h);
}

void GL_APIENTRY glViewportIndexedfv(GLuint index, const GLfloat *v)
{
    return gl::ViewportIndexedfv(index, v);
}

// GL 4.2
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 glDrawArraysInstancedBaseInstance(GLenum mode,
                                                   GLint first,
                                                   GLsizei count,
                                                   GLsizei instancecount,
                                                   GLuint baseinstance)
{
    return gl::DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}

void GL_APIENTRY glDrawElementsInstancedBaseInstance(GLenum mode,
                                                     GLsizei count,
                                                     GLenum type,
                                                     const void *indices,
                                                     GLsizei instancecount,
                                                     GLuint baseinstance)
{
    return gl::DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount,
                                                 baseinstance);
}

void GL_APIENTRY glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode,
                                                               GLsizei count,
                                                               GLenum type,
                                                               const void *indices,
                                                               GLsizei instancecount,
                                                               GLint basevertex,
                                                               GLuint baseinstance)
{
    return gl::DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices,
                                                           instancecount, basevertex, baseinstance);
}

void GL_APIENTRY glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
{
    return gl::DrawTransformFeedbackInstanced(mode, id, instancecount);
}

void GL_APIENTRY glDrawTransformFeedbackStreamInstanced(GLenum mode,
                                                        GLuint id,
                                                        GLuint stream,
                                                        GLsizei instancecount)
{
    return gl::DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}

void GL_APIENTRY glGetActiveAtomicCounterBufferiv(GLuint program,
                                                  GLuint bufferIndex,
                                                  GLenum pname,
                                                  GLint *params)
{
    return gl::GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}

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 glMemoryBarrier(GLbitfield barriers)
{
    return gl::MemoryBarrier(barriers);
}

void GL_APIENTRY glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
    return gl::TexStorage1D(target, levels, internalformat, width);
}

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);
}

// GL 4.3
void GL_APIENTRY glBindVertexBuffer(GLuint bindingindex,
                                    GLuint buffer,
                                    GLintptr offset,
                                    GLsizei stride)
{
    return gl::BindVertexBuffer(bindingindex, buffer, offset, stride);
}

void GL_APIENTRY glClearBufferData(GLenum target,
                                   GLenum internalformat,
                                   GLenum format,
                                   GLenum type,
                                   const void *data)
{
    return gl::ClearBufferData(target, internalformat, format, type, data);
}

void GL_APIENTRY glClearBufferSubData(GLenum target,
                                      GLenum internalformat,
                                      GLintptr offset,
                                      GLsizeiptr size,
                                      GLenum format,
                                      GLenum type,
                                      const void *data)
{
    return gl::ClearBufferSubData(target, internalformat, offset, size, format, type, data);
}

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 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 glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
{
    return gl::FramebufferParameteri(target, pname, param);
}

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);
}

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

void GL_APIENTRY glGetInternalformati64v(GLenum target,
                                         GLenum internalformat,
                                         GLenum pname,
                                         GLsizei bufSize,
                                         GLint64 *params)
{
    return gl::GetInternalformati64v(target, internalformat, pname, bufSize, params);
}

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 glGetProgramInterfaceiv(GLuint program,
                                         GLenum programInterface,
                                         GLenum pname,
                                         GLint *params)
{
    return gl::GetProgramInterfaceiv(program, programInterface, 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);
}

GLint GL_APIENTRY glGetProgramResourceLocationIndex(GLuint program,
                                                    GLenum programInterface,
                                                    const GLchar *name)
{
    return gl::GetProgramResourceLocationIndex(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 glInvalidateBufferData(GLuint buffer)
{
    return gl::InvalidateBufferData(buffer);
}

void GL_APIENTRY glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
    return gl::InvalidateBufferSubData(buffer, offset, length);
}

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);
}

void GL_APIENTRY glInvalidateTexImage(GLuint texture, GLint level)
{
    return gl::InvalidateTexImage(texture, level);
}

void GL_APIENTRY glInvalidateTexSubImage(GLuint texture,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth)
{
    return gl::InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height,
                                     depth);
}

void GL_APIENTRY glMultiDrawArraysIndirect(GLenum mode,
                                           const void *indirect,
                                           GLsizei drawcount,
                                           GLsizei stride)
{
    return gl::MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}

void GL_APIENTRY glMultiDrawElementsIndirect(GLenum mode,
                                             GLenum type,
                                             const void *indirect,
                                             GLsizei drawcount,
                                             GLsizei stride)
{
    return gl::MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
}

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 glPopDebugGroup()
{
    return gl::PopDebugGroup();
}

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

void GL_APIENTRY glShaderStorageBlockBinding(GLuint program,
                                             GLuint storageBlockIndex,
                                             GLuint storageBlockBinding)
{
    return gl::ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}

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 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 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);
}

void GL_APIENTRY glTextureView(GLuint texture,
                               GLenum target,
                               GLuint origtexture,
                               GLenum internalformat,
                               GLuint minlevel,
                               GLuint numlevels,
                               GLuint minlayer,
                               GLuint numlayers)
{
    return gl::TextureView(texture, target, origtexture, internalformat, minlevel, numlevels,
                           minlayer, numlayers);
}

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 glVertexAttribLFormat(GLuint attribindex,
                                       GLint size,
                                       GLenum type,
                                       GLuint relativeoffset)
{
    return gl::VertexAttribLFormat(attribindex, size, type, relativeoffset);
}

void GL_APIENTRY glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
{
    return gl::VertexBindingDivisor(bindingindex, divisor);
}

// GL 4.4
void GL_APIENTRY glBindBuffersBase(GLenum target,
                                   GLuint first,
                                   GLsizei count,
                                   const GLuint *buffers)
{
    return gl::BindBuffersBase(target, first, count, buffers);
}

void GL_APIENTRY glBindBuffersRange(GLenum target,
                                    GLuint first,
                                    GLsizei count,
                                    const GLuint *buffers,
                                    const GLintptr *offsets,
                                    const GLsizeiptr *sizes)
{
    return gl::BindBuffersRange(target, first, count, buffers, offsets, sizes);
}

void GL_APIENTRY glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
{
    return gl::BindImageTextures(first, count, textures);
}

void GL_APIENTRY glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
{
    return gl::BindSamplers(first, count, samplers);
}

void GL_APIENTRY glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
{
    return gl::BindTextures(first, count, textures);
}

void GL_APIENTRY glBindVertexBuffers(GLuint first,
                                     GLsizei count,
                                     const GLuint *buffers,
                                     const GLintptr *offsets,
                                     const GLsizei *strides)
{
    return gl::BindVertexBuffers(first, count, buffers, offsets, strides);
}

void GL_APIENTRY glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
{
    return gl::BufferStorage(target, size, data, flags);
}

void GL_APIENTRY
glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
{
    return gl::ClearTexImage(texture, level, format, type, data);
}

void GL_APIENTRY glClearTexSubImage(GLuint texture,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLint zoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLenum format,
                                    GLenum type,
                                    const void *data)
{
    return gl::ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth,
                                format, type, data);
}

// GL 4.5
void GL_APIENTRY glBindTextureUnit(GLuint unit, GLuint texture)
{
    return gl::BindTextureUnit(unit, texture);
}

void GL_APIENTRY glBlitNamedFramebuffer(GLuint readFramebuffer,
                                        GLuint drawFramebuffer,
                                        GLint srcX0,
                                        GLint srcY0,
                                        GLint srcX1,
                                        GLint srcY1,
                                        GLint dstX0,
                                        GLint dstY0,
                                        GLint dstX1,
                                        GLint dstY1,
                                        GLbitfield mask,
                                        GLenum filter)
{
    return gl::BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1,
                                    dstX0, dstY0, dstX1, dstY1, mask, filter);
}

GLenum GL_APIENTRY glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
{
    return gl::CheckNamedFramebufferStatus(framebuffer, target);
}

void GL_APIENTRY glClearNamedBufferData(GLuint buffer,
                                        GLenum internalformat,
                                        GLenum format,
                                        GLenum type,
                                        const void *data)
{
    return gl::ClearNamedBufferData(buffer, internalformat, format, type, data);
}

void GL_APIENTRY glClearNamedBufferSubData(GLuint buffer,
                                           GLenum internalformat,
                                           GLintptr offset,
                                           GLsizeiptr size,
                                           GLenum format,
                                           GLenum type,
                                           const void *data)
{
    return gl::ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
}

void GL_APIENTRY glClearNamedFramebufferfi(GLuint framebuffer,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           GLfloat depth,
                                           GLint stencil)
{
    return gl::ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
}

void GL_APIENTRY glClearNamedFramebufferfv(GLuint framebuffer,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLfloat *value)
{
    return gl::ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
}

void GL_APIENTRY glClearNamedFramebufferiv(GLuint framebuffer,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLint *value)
{
    return gl::ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
}

void GL_APIENTRY glClearNamedFramebufferuiv(GLuint framebuffer,
                                            GLenum buffer,
                                            GLint drawbuffer,
                                            const GLuint *value)
{
    return gl::ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
}

void GL_APIENTRY glClipControl(GLenum origin, GLenum depth)
{
    return gl::ClipControl(origin, depth);
}

void GL_APIENTRY glCompressedTextureSubImage1D(GLuint texture,
                                               GLint level,
                                               GLint xoffset,
                                               GLsizei width,
                                               GLenum format,
                                               GLsizei imageSize,
                                               const void *data)
{
    return gl::CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}

void GL_APIENTRY glCompressedTextureSubImage2D(GLuint texture,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLenum format,
                                               GLsizei imageSize,
                                               const void *data)
{
    return gl::CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format,
                                           imageSize, data);
}

void GL_APIENTRY glCompressedTextureSubImage3D(GLuint texture,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLint zoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLenum format,
                                               GLsizei imageSize,
                                               const void *data)
{
    return gl::CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height,
                                           depth, format, imageSize, data);
}

void GL_APIENTRY glCopyNamedBufferSubData(GLuint readBuffer,
                                          GLuint writeBuffer,
                                          GLintptr readOffset,
                                          GLintptr writeOffset,
                                          GLsizeiptr size)
{
    return gl::CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
}

void GL_APIENTRY
glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
    return gl::CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}

void GL_APIENTRY glCopyTextureSubImage2D(GLuint texture,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height)
{
    return gl::CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}

void GL_APIENTRY glCopyTextureSubImage3D(GLuint texture,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height)
{
    return gl::CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width,
                                     height);
}

void GL_APIENTRY glCreateBuffers(GLsizei n, GLuint *buffers)
{
    return gl::CreateBuffers(n, buffers);
}

void GL_APIENTRY glCreateFramebuffers(GLsizei n, GLuint *framebuffers)
{
    return gl::CreateFramebuffers(n, framebuffers);
}

void GL_APIENTRY glCreateProgramPipelines(GLsizei n, GLuint *pipelines)
{
    return gl::CreateProgramPipelines(n, pipelines);
}

void GL_APIENTRY glCreateQueries(GLenum target, GLsizei n, GLuint *ids)
{
    return gl::CreateQueries(target, n, ids);
}

void GL_APIENTRY glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
{
    return gl::CreateRenderbuffers(n, renderbuffers);
}

void GL_APIENTRY glCreateSamplers(GLsizei n, GLuint *samplers)
{
    return gl::CreateSamplers(n, samplers);
}

void GL_APIENTRY glCreateTextures(GLenum target, GLsizei n, GLuint *textures)
{
    return gl::CreateTextures(target, n, textures);
}

void GL_APIENTRY glCreateTransformFeedbacks(GLsizei n, GLuint *ids)
{
    return gl::CreateTransformFeedbacks(n, ids);
}

void GL_APIENTRY glCreateVertexArrays(GLsizei n, GLuint *arrays)
{
    return gl::CreateVertexArrays(n, arrays);
}

void GL_APIENTRY glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
    return gl::DisableVertexArrayAttrib(vaobj, index);
}

void GL_APIENTRY glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
    return gl::EnableVertexArrayAttrib(vaobj, index);
}

void GL_APIENTRY glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
    return gl::FlushMappedNamedBufferRange(buffer, offset, length);
}

void GL_APIENTRY glGenerateTextureMipmap(GLuint texture)
{
    return gl::GenerateTextureMipmap(texture);
}

void GL_APIENTRY glGetCompressedTextureImage(GLuint texture,
                                             GLint level,
                                             GLsizei bufSize,
                                             void *pixels)
{
    return gl::GetCompressedTextureImage(texture, level, bufSize, pixels);
}

void GL_APIENTRY glGetCompressedTextureSubImage(GLuint texture,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLsizei bufSize,
                                                void *pixels)
{
    return gl::GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width,
                                            height, depth, bufSize, pixels);
}

GLenum GL_APIENTRY glGetGraphicsResetStatus()
{
    return gl::GetGraphicsResetStatus();
}

void GL_APIENTRY glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
{
    return gl::GetNamedBufferParameteri64v(buffer, pname, params);
}

void GL_APIENTRY glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
{
    return gl::GetNamedBufferParameteriv(buffer, pname, params);
}

void GL_APIENTRY glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void **params)
{
    return gl::GetNamedBufferPointerv(buffer, pname, params);
}

void GL_APIENTRY glGetNamedBufferSubData(GLuint buffer,
                                         GLintptr offset,
                                         GLsizeiptr size,
                                         void *data)
{
    return gl::GetNamedBufferSubData(buffer, offset, size, data);
}

void GL_APIENTRY glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer,
                                                            GLenum attachment,
                                                            GLenum pname,
                                                            GLint *params)
{
    return gl::GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
}

void GL_APIENTRY glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
{
    return gl::GetNamedFramebufferParameteriv(framebuffer, pname, param);
}

void GL_APIENTRY glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
{
    return gl::GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
}

void GL_APIENTRY glGetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
    return gl::GetQueryBufferObjecti64v(id, buffer, pname, offset);
}

void GL_APIENTRY glGetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
    return gl::GetQueryBufferObjectiv(id, buffer, pname, offset);
}

void GL_APIENTRY glGetQueryBufferObjectui64v(GLuint id,
                                             GLuint buffer,
                                             GLenum pname,
                                             GLintptr offset)
{
    return gl::GetQueryBufferObjectui64v(id, buffer, pname, offset);
}

void GL_APIENTRY glGetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
    return gl::GetQueryBufferObjectuiv(id, buffer, pname, offset);
}

void GL_APIENTRY glGetTextureImage(GLuint texture,
                                   GLint level,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   void *pixels)
{
    return gl::GetTextureImage(texture, level, format, type, bufSize, pixels);
}

void GL_APIENTRY glGetTextureLevelParameterfv(GLuint texture,
                                              GLint level,
                                              GLenum pname,
                                              GLfloat *params)
{
    return gl::GetTextureLevelParameterfv(texture, level, pname, params);
}

void GL_APIENTRY glGetTextureLevelParameteriv(GLuint texture,
                                              GLint level,
                                              GLenum pname,
                                              GLint *params)
{
    return gl::GetTextureLevelParameteriv(texture, level, pname, params);
}

void GL_APIENTRY glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
{
    return gl::GetTextureParameterIiv(texture, pname, params);
}

void GL_APIENTRY glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
{
    return gl::GetTextureParameterIuiv(texture, pname, params);
}

void GL_APIENTRY glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
{
    return gl::GetTextureParameterfv(texture, pname, params);
}

void GL_APIENTRY glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
{
    return gl::GetTextureParameteriv(texture, pname, params);
}

void GL_APIENTRY glGetTextureSubImage(GLuint texture,
                                      GLint level,
                                      GLint xoffset,
                                      GLint yoffset,
                                      GLint zoffset,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLenum format,
                                      GLenum type,
                                      GLsizei bufSize,
                                      void *pixels)
{
    return gl::GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth,
                                  format, type, bufSize, pixels);
}

void GL_APIENTRY glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
{
    return gl::GetTransformFeedbacki64_v(xfb, pname, index, param);
}

void GL_APIENTRY glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
{
    return gl::GetTransformFeedbacki_v(xfb, pname, index, param);
}

void GL_APIENTRY glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
{
    return gl::GetTransformFeedbackiv(xfb, pname, param);
}

void GL_APIENTRY glGetVertexArrayIndexed64iv(GLuint vaobj,
                                             GLuint index,
                                             GLenum pname,
                                             GLint64 *param)
{
    return gl::GetVertexArrayIndexed64iv(vaobj, index, pname, param);
}

void GL_APIENTRY glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
{
    return gl::GetVertexArrayIndexediv(vaobj, index, pname, param);
}

void GL_APIENTRY glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
{
    return gl::GetVertexArrayiv(vaobj, pname, param);
}

void GL_APIENTRY
glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
{
    return gl::GetnColorTable(target, format, type, bufSize, table);
}

void GL_APIENTRY glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
{
    return gl::GetnCompressedTexImage(target, lod, bufSize, pixels);
}

void GL_APIENTRY
glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
{
    return gl::GetnConvolutionFilter(target, format, type, bufSize, image);
}

void GL_APIENTRY glGetnHistogram(GLenum target,
                                 GLboolean reset,
                                 GLenum format,
                                 GLenum type,
                                 GLsizei bufSize,
                                 void *values)
{
    return gl::GetnHistogram(target, reset, format, type, bufSize, values);
}

void GL_APIENTRY glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
{
    return gl::GetnMapdv(target, query, bufSize, v);
}

void GL_APIENTRY glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
{
    return gl::GetnMapfv(target, query, bufSize, v);
}

void GL_APIENTRY glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
{
    return gl::GetnMapiv(target, query, bufSize, v);
}

void GL_APIENTRY glGetnMinmax(GLenum target,
                              GLboolean reset,
                              GLenum format,
                              GLenum type,
                              GLsizei bufSize,
                              void *values)
{
    return gl::GetnMinmax(target, reset, format, type, bufSize, values);
}

void GL_APIENTRY glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values)
{
    return gl::GetnPixelMapfv(map, bufSize, values);
}

void GL_APIENTRY glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values)
{
    return gl::GetnPixelMapuiv(map, bufSize, values);
}

void GL_APIENTRY glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values)
{
    return gl::GetnPixelMapusv(map, bufSize, values);
}

void GL_APIENTRY glGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern)
{
    return gl::GetnPolygonStipple(bufSize, pattern);
}

void GL_APIENTRY glGetnSeparableFilter(GLenum target,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei rowBufSize,
                                       void *row,
                                       GLsizei columnBufSize,
                                       void *column,
                                       void *span)
{
    return gl::GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column,
                                   span);
}

void GL_APIENTRY glGetnTexImage(GLenum target,
                                GLint level,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *pixels)
{
    return gl::GetnTexImage(target, level, format, type, bufSize, pixels);
}

void GL_APIENTRY glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
{
    return gl::GetnUniformdv(program, location, bufSize, 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);
}

void GL_APIENTRY glInvalidateNamedFramebufferData(GLuint framebuffer,
                                                  GLsizei numAttachments,
                                                  const GLenum *attachments)
{
    return gl::InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
}

void GL_APIENTRY glInvalidateNamedFramebufferSubData(GLuint framebuffer,
                                                     GLsizei numAttachments,
                                                     const GLenum *attachments,
                                                     GLint x,
                                                     GLint y,
                                                     GLsizei width,
                                                     GLsizei height)
{
    return gl::InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y,
                                                 width, height);
}

void *GL_APIENTRY glMapNamedBuffer(GLuint buffer, GLenum access)
{
    return gl::MapNamedBuffer(buffer, access);
}

void *GL_APIENTRY glMapNamedBufferRange(GLuint buffer,
                                        GLintptr offset,
                                        GLsizeiptr length,
                                        GLbitfield access)
{
    return gl::MapNamedBufferRange(buffer, offset, length, access);
}

void GL_APIENTRY glMemoryBarrierByRegion(GLbitfield barriers)
{
    return gl::MemoryBarrierByRegion(barriers);
}

void GL_APIENTRY glNamedBufferData(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
{
    return gl::NamedBufferData(buffer, size, data, usage);
}

void GL_APIENTRY glNamedBufferStorage(GLuint buffer,
                                      GLsizeiptr size,
                                      const void *data,
                                      GLbitfield flags)
{
    return gl::NamedBufferStorage(buffer, size, data, flags);
}

void GL_APIENTRY glNamedBufferSubData(GLuint buffer,
                                      GLintptr offset,
                                      GLsizeiptr size,
                                      const void *data)
{
    return gl::NamedBufferSubData(buffer, offset, size, data);
}

void GL_APIENTRY glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
{
    return gl::NamedFramebufferDrawBuffer(framebuffer, buf);
}

void GL_APIENTRY glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
{
    return gl::NamedFramebufferDrawBuffers(framebuffer, n, bufs);
}

void GL_APIENTRY glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
{
    return gl::NamedFramebufferParameteri(framebuffer, pname, param);
}

void GL_APIENTRY glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
{
    return gl::NamedFramebufferReadBuffer(framebuffer, src);
}

void GL_APIENTRY glNamedFramebufferRenderbuffer(GLuint framebuffer,
                                                GLenum attachment,
                                                GLenum renderbuffertarget,
                                                GLuint renderbuffer)
{
    return gl::NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget,
                                            renderbuffer);
}

void GL_APIENTRY glNamedFramebufferTexture(GLuint framebuffer,
                                           GLenum attachment,
                                           GLuint texture,
                                           GLint level)
{
    return gl::NamedFramebufferTexture(framebuffer, attachment, texture, level);
}

void GL_APIENTRY glNamedFramebufferTextureLayer(GLuint framebuffer,
                                                GLenum attachment,
                                                GLuint texture,
                                                GLint level,
                                                GLint layer)
{
    return gl::NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}

void GL_APIENTRY glNamedRenderbufferStorage(GLuint renderbuffer,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height)
{
    return gl::NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}

void GL_APIENTRY glNamedRenderbufferStorageMultisample(GLuint renderbuffer,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height)
{
    return gl::NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width,
                                                   height);
}

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 glTextureBarrier()
{
    return gl::TextureBarrier();
}

void GL_APIENTRY glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
{
    return gl::TextureBuffer(texture, internalformat, buffer);
}

void GL_APIENTRY glTextureBufferRange(GLuint texture,
                                      GLenum internalformat,
                                      GLuint buffer,
                                      GLintptr offset,
                                      GLsizeiptr size)
{
    return gl::TextureBufferRange(texture, internalformat, buffer, offset, size);
}

void GL_APIENTRY glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
{
    return gl::TextureParameterIiv(texture, pname, params);
}

void GL_APIENTRY glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
{
    return gl::TextureParameterIuiv(texture, pname, params);
}

void GL_APIENTRY glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
{
    return gl::TextureParameterf(texture, pname, param);
}

void GL_APIENTRY glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
{
    return gl::TextureParameterfv(texture, pname, param);
}

void GL_APIENTRY glTextureParameteri(GLuint texture, GLenum pname, GLint param)
{
    return gl::TextureParameteri(texture, pname, param);
}

void GL_APIENTRY glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
{
    return gl::TextureParameteriv(texture, pname, param);
}

void GL_APIENTRY glTextureStorage1D(GLuint texture,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width)
{
    return gl::TextureStorage1D(texture, levels, internalformat, width);
}

void GL_APIENTRY glTextureStorage2D(GLuint texture,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLsizei height)
{
    return gl::TextureStorage2D(texture, levels, internalformat, width, height);
}

void GL_APIENTRY glTextureStorage2DMultisample(GLuint texture,
                                               GLsizei samples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLboolean fixedsamplelocations)
{
    return gl::TextureStorage2DMultisample(texture, samples, internalformat, width, height,
                                           fixedsamplelocations);
}

void GL_APIENTRY glTextureStorage3D(GLuint texture,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth)
{
    return gl::TextureStorage3D(texture, levels, internalformat, width, height, depth);
}

void GL_APIENTRY glTextureStorage3DMultisample(GLuint texture,
                                               GLsizei samples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLboolean fixedsamplelocations)
{
    return gl::TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth,
                                           fixedsamplelocations);
}

void GL_APIENTRY glTextureSubImage1D(GLuint texture,
                                     GLint level,
                                     GLint xoffset,
                                     GLsizei width,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{
    return gl::TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
}

void GL_APIENTRY glTextureSubImage2D(GLuint texture,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{
    return gl::TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type,
                                 pixels);
}

void GL_APIENTRY glTextureSubImage3D(GLuint texture,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{
    return gl::TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth,
                                 format, type, pixels);
}

void GL_APIENTRY glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
{
    return gl::TransformFeedbackBufferBase(xfb, index, buffer);
}

void GL_APIENTRY glTransformFeedbackBufferRange(GLuint xfb,
                                                GLuint index,
                                                GLuint buffer,
                                                GLintptr offset,
                                                GLsizeiptr size)
{
    return gl::TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
}

GLboolean GL_APIENTRY glUnmapNamedBuffer(GLuint buffer)
{
    return gl::UnmapNamedBuffer(buffer);
}

void GL_APIENTRY glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
    return gl::VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}

void GL_APIENTRY glVertexArrayAttribFormat(GLuint vaobj,
                                           GLuint attribindex,
                                           GLint size,
                                           GLenum type,
                                           GLboolean normalized,
                                           GLuint relativeoffset)
{
    return gl::VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
}

void GL_APIENTRY glVertexArrayAttribIFormat(GLuint vaobj,
                                            GLuint attribindex,
                                            GLint size,
                                            GLenum type,
                                            GLuint relativeoffset)
{
    return gl::VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
}

void GL_APIENTRY glVertexArrayAttribLFormat(GLuint vaobj,
                                            GLuint attribindex,
                                            GLint size,
                                            GLenum type,
                                            GLuint relativeoffset)
{
    return gl::VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
}

void GL_APIENTRY glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
    return gl::VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}

void GL_APIENTRY glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
{
    return gl::VertexArrayElementBuffer(vaobj, buffer);
}

void GL_APIENTRY glVertexArrayVertexBuffer(GLuint vaobj,
                                           GLuint bindingindex,
                                           GLuint buffer,
                                           GLintptr offset,
                                           GLsizei stride)
{
    return gl::VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
}

void GL_APIENTRY glVertexArrayVertexBuffers(GLuint vaobj,
                                            GLuint first,
                                            GLsizei count,
                                            const GLuint *buffers,
                                            const GLintptr *offsets,
                                            const GLsizei *strides)
{
    return gl::VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
}

// GL 4.6
void GL_APIENTRY glMultiDrawArraysIndirectCount(GLenum mode,
                                                const void *indirect,
                                                GLintptr drawcount,
                                                GLsizei maxdrawcount,
                                                GLsizei stride)
{
    return gl::MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride);
}

void GL_APIENTRY glMultiDrawElementsIndirectCount(GLenum mode,
                                                  GLenum type,
                                                  const void *indirect,
                                                  GLintptr drawcount,
                                                  GLsizei maxdrawcount,
                                                  GLsizei stride)
{
    return gl::MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount,
                                              stride);
}

void GL_APIENTRY glPolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp)
{
    return gl::PolygonOffsetClamp(factor, units, clamp);
}

void GL_APIENTRY glSpecializeShader(GLuint shader,
                                    const GLchar *pEntryPoint,
                                    GLuint numSpecializationConstants,
                                    const GLuint *pConstantIndex,
                                    const GLuint *pConstantValue)
{
    return gl::SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex,
                                pConstantValue);
}

}  // extern "C"