// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and wgl.xml.
//
// Copyright 2019 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 "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);
}

}  // extern "C"