text: #pragma once
  
  #include <glbinding/gl/nogl.h>
  
  #include <glbinding/gl/values.h>
  #include <glbinding/gl/boolean.h>
  
  namespace gl43
  {
  
  #include <glbinding/gl/types.inl>
  #include <glbinding/gl/boolean.inl>
  #include <glbinding/gl/values.inl>
  
  } // namespace gl43
  
  #include <glbinding/Binding.h>
  
  
  namespace gl43
  {
  
  inline void glAccum(GLenum op, GLfloat value)
  {
      return glbinding::Binding::Accum(op, value);
  }
  
  inline void glActiveShaderProgram(GLuint pipeline, GLuint program)
  {
      return glbinding::Binding::ActiveShaderProgram(pipeline, program);
  }
  
  inline void glActiveTexture(GLenum texture)
  {
      return glbinding::Binding::ActiveTexture(texture);
  }
  
  inline void glAlphaFunc(GLenum func, GLfloat ref)
  {
      return glbinding::Binding::AlphaFunc(func, ref);
  }
  
  inline GLboolean glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
  {
      return glbinding::Binding::AreTexturesResident(n, textures, residences);
  }
  
  inline void glArrayElement(GLint i)
  {
      return glbinding::Binding::ArrayElement(i);
  }
  
  inline void glAttachShader(GLuint program, GLuint shader)
  {
      return glbinding::Binding::AttachShader(program, shader);
  }
  
  inline void glBegin(GLenum mode)
  {
      return glbinding::Binding::Begin(mode);
  }
  
  inline void glBeginConditionalRender(GLuint id, GLenum mode)
  {
      return glbinding::Binding::BeginConditionalRender(id, mode);
  }
  
  inline void glBeginQuery(GLenum target, GLuint id)
  {
      return glbinding::Binding::BeginQuery(target, id);
  }
  
  inline void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
  {
      return glbinding::Binding::BeginQueryIndexed(target, index, id);
  }
  
  inline void glBeginTransformFeedback(GLenum primitiveMode)
  {
      return glbinding::Binding::BeginTransformFeedback(primitiveMode);
  }
  
  inline void glBindAttribLocation(GLuint program, GLuint index, const GLchar * name)
  {
      return glbinding::Binding::BindAttribLocation(program, index, name);
  }
  
  inline void glBindBuffer(GLenum target, GLuint buffer)
  {
      return glbinding::Binding::BindBuffer(target, buffer);
  }
  
  inline void glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
  {
      return glbinding::Binding::BindBufferBase(target, index, buffer);
  }
  
  inline void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
  {
      return glbinding::Binding::BindBufferRange(target, index, buffer, offset, size);
  }
  
  inline void glBindFragDataLocation(GLuint program, GLuint color, const GLchar * name)
  {
      return glbinding::Binding::BindFragDataLocation(program, color, name);
  }
  
  inline void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name)
  {
      return glbinding::Binding::BindFragDataLocationIndexed(program, colorNumber, index, name);
  }
  
  inline void glBindFramebuffer(GLenum target, GLuint framebuffer)
  {
      return glbinding::Binding::BindFramebuffer(target, framebuffer);
  }
  
  inline void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
  {
      return glbinding::Binding::BindImageTexture(unit, texture, level, layered, layer, access, format);
  }
  
  inline void glBindProgramPipeline(GLuint pipeline)
  {
      return glbinding::Binding::BindProgramPipeline(pipeline);
  }
  
  inline void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
  {
      return glbinding::Binding::BindRenderbuffer(target, renderbuffer);
  }
  
  inline void glBindSampler(GLuint unit, GLuint sampler)
  {
      return glbinding::Binding::BindSampler(unit, sampler);
  }
  
  inline void glBindTexture(GLenum target, GLuint texture)
  {
      return glbinding::Binding::BindTexture(target, texture);
  }
  
  inline void glBindTransformFeedback(GLenum target, GLuint id)
  {
      return glbinding::Binding::BindTransformFeedback(target, id);
  }
  
  inline void glBindVertexArray(GLuint array)
  {
      return glbinding::Binding::BindVertexArray(array);
  }
  
  inline void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
  {
      return glbinding::Binding::BindVertexBuffer(bindingindex, buffer, offset, stride);
  }
  
  inline void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
  {
      return glbinding::Binding::Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
  }
  
  inline void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  {
      return glbinding::Binding::BlendColor(red, green, blue, alpha);
  }
  
  inline void glBlendEquation(GLenum mode)
  {
      return glbinding::Binding::BlendEquation(mode);
  }
  
  inline void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
  {
      return glbinding::Binding::BlendEquationSeparate(modeRGB, modeAlpha);
  }
  
  inline void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
  {
      return glbinding::Binding::BlendEquationSeparatei(buf, modeRGB, modeAlpha);
  }
  
  inline void glBlendEquationi(GLuint buf, GLenum mode)
  {
      return glbinding::Binding::BlendEquationi(buf, mode);
  }
  
  inline void glBlendFunc(GLenum sfactor, GLenum dfactor)
  {
      return glbinding::Binding::BlendFunc(sfactor, dfactor);
  }
  
  inline void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
  {
      return glbinding::Binding::BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
  }
  
  inline void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
  {
      return glbinding::Binding::BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
  }
  
  inline void glBlendFunci(GLuint buf, GLenum src, GLenum dst)
  {
      return glbinding::Binding::BlendFunci(buf, src, dst);
  }
  
  inline void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, ClearBufferMask mask, GLenum filter)
  {
      return glbinding::Binding::BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
  }
  
  inline void glBufferData(GLenum target, GLsizeiptr size, const void * data, GLenum usage)
  {
      return glbinding::Binding::BufferData(target, size, data, usage);
  }
  
  inline void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void * data)
  {
      return glbinding::Binding::BufferSubData(target, offset, size, data);
  }
  
  inline void glCallList(GLuint list)
  {
      return glbinding::Binding::CallList(list);
  }
  
  inline void glCallLists(GLsizei n, GLenum type, const void * lists)
  {
      return glbinding::Binding::CallLists(n, type, lists);
  }
  
  inline GLenum glCheckFramebufferStatus(GLenum target)
  {
      return static_cast<gl43::GLenum>(glbinding::Binding::CheckFramebufferStatus(target));
  }
  
  inline void glClampColor(GLenum target, GLenum clamp)
  {
      return glbinding::Binding::ClampColor(target, clamp);
  }
  
  inline void glClear(ClearBufferMask mask)
  {
      return glbinding::Binding::Clear(mask);
  }
  
  inline void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  {
      return glbinding::Binding::ClearAccum(red, green, blue, alpha);
  }
  
  inline void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data)
  {
      return glbinding::Binding::ClearBufferData(target, internalformat, format, type, data);
  }
  
  inline void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data)
  {
      return glbinding::Binding::ClearBufferSubData(target, internalformat, offset, size, format, type, data);
  }
  
  inline void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
  {
      return glbinding::Binding::ClearBufferfi(buffer, drawbuffer, depth, stencil);
  }
  
  inline void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat * value)
  {
      return glbinding::Binding::ClearBufferfv(buffer, drawbuffer, value);
  }
  
  inline void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * value)
  {
      return glbinding::Binding::ClearBufferiv(buffer, drawbuffer, value);
  }
  
  inline void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint * value)
  {
      return glbinding::Binding::ClearBufferuiv(buffer, drawbuffer, value);
  }
  
  inline void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  {
      return glbinding::Binding::ClearColor(red, green, blue, alpha);
  }
  
  inline void glClearDepth(GLdouble depth)
  {
      return glbinding::Binding::ClearDepth(depth);
  }
  
  inline void glClearDepthf(GLfloat d)
  {
      return glbinding::Binding::ClearDepthf(d);
  }
  
  inline void glClearIndex(GLfloat c)
  {
      return glbinding::Binding::ClearIndex(c);
  }
  
  inline void glClearStencil(GLint s)
  {
      return glbinding::Binding::ClearStencil(s);
  }
  
  inline void glClientActiveTexture(GLenum texture)
  {
      return glbinding::Binding::ClientActiveTexture(texture);
  }
  
  inline GLenum glClientWaitSync(GLsync sync, SyncObjectMask flags, GLuint64 timeout)
  {
      return static_cast<gl43::GLenum>(glbinding::Binding::ClientWaitSync(sync, flags, timeout));
  }
  
  inline void glClipPlane(GLenum plane, const GLdouble * equation)
  {
      return glbinding::Binding::ClipPlane(plane, equation);
  }
  
  inline void glColor3b(GLbyte red, GLbyte green, GLbyte blue)
  {
      return glbinding::Binding::Color3b(red, green, blue);
  }
  
  inline void glColor3bv(const GLbyte * v)
  {
      return glbinding::Binding::Color3bv(v);
  }
  
  inline void glColor3d(GLdouble red, GLdouble green, GLdouble blue)
  {
      return glbinding::Binding::Color3d(red, green, blue);
  }
  
  inline void glColor3dv(const GLdouble * v)
  {
      return glbinding::Binding::Color3dv(v);
  }
  
  inline void glColor3f(GLfloat red, GLfloat green, GLfloat blue)
  {
      return glbinding::Binding::Color3f(red, green, blue);
  }
  
  inline void glColor3fv(const GLfloat * v)
  {
      return glbinding::Binding::Color3fv(v);
  }
  
  inline void glColor3i(GLint red, GLint green, GLint blue)
  {
      return glbinding::Binding::Color3i(red, green, blue);
  }
  
  inline void glColor3iv(const GLint * v)
  {
      return glbinding::Binding::Color3iv(v);
  }
  
  inline void glColor3s(GLshort red, GLshort green, GLshort blue)
  {
      return glbinding::Binding::Color3s(red, green, blue);
  }
  
  inline void glColor3sv(const GLshort * v)
  {
      return glbinding::Binding::Color3sv(v);
  }
  
  inline void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
  {
      return glbinding::Binding::Color3ub(red, green, blue);
  }
  
  inline void glColor3ubv(const GLubyte * v)
  {
      return glbinding::Binding::Color3ubv(v);
  }
  
  inline void glColor3ui(GLuint red, GLuint green, GLuint blue)
  {
      return glbinding::Binding::Color3ui(red, green, blue);
  }
  
  inline void glColor3uiv(const GLuint * v)
  {
      return glbinding::Binding::Color3uiv(v);
  }
  
  inline void glColor3us(GLushort red, GLushort green, GLushort blue)
  {
      return glbinding::Binding::Color3us(red, green, blue);
  }
  
  inline void glColor3usv(const GLushort * v)
  {
      return glbinding::Binding::Color3usv(v);
  }
  
  inline void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
  {
      return glbinding::Binding::Color4b(red, green, blue, alpha);
  }
  
  inline void glColor4bv(const GLbyte * v)
  {
      return glbinding::Binding::Color4bv(v);
  }
  
  inline void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
  {
      return glbinding::Binding::Color4d(red, green, blue, alpha);
  }
  
  inline void glColor4dv(const GLdouble * v)
  {
      return glbinding::Binding::Color4dv(v);
  }
  
  inline void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
  {
      return glbinding::Binding::Color4f(red, green, blue, alpha);
  }
  
  inline void glColor4fv(const GLfloat * v)
  {
      return glbinding::Binding::Color4fv(v);
  }
  
  inline void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
  {
      return glbinding::Binding::Color4i(red, green, blue, alpha);
  }
  
  inline void glColor4iv(const GLint * v)
  {
      return glbinding::Binding::Color4iv(v);
  }
  
  inline void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
  {
      return glbinding::Binding::Color4s(red, green, blue, alpha);
  }
  
  inline void glColor4sv(const GLshort * v)
  {
      return glbinding::Binding::Color4sv(v);
  }
  
  inline void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
  {
      return glbinding::Binding::Color4ub(red, green, blue, alpha);
  }
  
  inline void glColor4ubv(const GLubyte * v)
  {
      return glbinding::Binding::Color4ubv(v);
  }
  
  inline void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
  {
      return glbinding::Binding::Color4ui(red, green, blue, alpha);
  }
  
  inline void glColor4uiv(const GLuint * v)
  {
      return glbinding::Binding::Color4uiv(v);
  }
  
  inline void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
  {
      return glbinding::Binding::Color4us(red, green, blue, alpha);
  }
  
  inline void glColor4usv(const GLushort * v)
  {
      return glbinding::Binding::Color4usv(v);
  }
  
  inline void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
  {
      return glbinding::Binding::ColorMask(red, green, blue, alpha);
  }
  
  inline void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
  {
      return glbinding::Binding::ColorMaski(index, r, g, b, a);
  }
  
  inline void glColorMaterial(GLenum face, GLenum mode)
  {
      return glbinding::Binding::ColorMaterial(face, mode);
  }
  
  inline void glColorP3ui(GLenum type, GLuint color)
  {
      return glbinding::Binding::ColorP3ui(type, color);
  }
  
  inline void glColorP3uiv(GLenum type, const GLuint * color)
  {
      return glbinding::Binding::ColorP3uiv(type, color);
  }
  
  inline void glColorP4ui(GLenum type, GLuint color)
  {
      return glbinding::Binding::ColorP4ui(type, color);
  }
  
  inline void glColorP4uiv(GLenum type, const GLuint * color)
  {
      return glbinding::Binding::ColorP4uiv(type, color);
  }
  
  inline void glColorPointer(GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::ColorPointer(size, type, stride, pointer);
  }
  
  inline void glCompileShader(GLuint shader)
  {
      return glbinding::Binding::CompileShader(shader);
  }
  
  inline void glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data)
  {
      return glbinding::Binding::CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
  }
  
  inline void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data)
  {
      return glbinding::Binding::CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
  }
  
  inline void glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data)
  {
      return glbinding::Binding::CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
  }
  
  inline void glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data)
  {
      return glbinding::Binding::CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
  }
  
  inline void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data)
  {
      return glbinding::Binding::CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
  }
  
  inline void 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 glbinding::Binding::CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
  }
  
  inline void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
  {
      return glbinding::Binding::CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
  }
  
  inline void 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 glbinding::Binding::CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
  }
  
  inline void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
  {
      return glbinding::Binding::CopyPixels(x, y, width, height, type);
  }
  
  inline void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
  {
      return glbinding::Binding::CopyTexImage1D(target, level, internalformat, x, y, width, border);
  }
  
  inline void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
  {
      return glbinding::Binding::CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
  }
  
  inline void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
  {
      return glbinding::Binding::CopyTexSubImage1D(target, level, xoffset, x, y, width);
  }
  
  inline void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
  }
  
  inline void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
  }
  
  inline GLuint glCreateProgram()
  {
      return glbinding::Binding::CreateProgram();
  }
  
  inline GLuint glCreateShader(GLenum type)
  {
      return glbinding::Binding::CreateShader(type);
  }
  
  inline GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const* strings)
  {
      return glbinding::Binding::CreateShaderProgramv(type, count, strings);
  }
  
  inline void glCullFace(GLenum mode)
  {
      return glbinding::Binding::CullFace(mode);
  }
  
  inline void glDebugMessageCallback(GLDEBUGPROC callback, const void * userParam)
  {
      return glbinding::Binding::DebugMessageCallback(callback, userParam);
  }
  
  inline void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled)
  {
      return glbinding::Binding::DebugMessageControl(source, type, severity, count, ids, enabled);
  }
  
  inline void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf)
  {
      return glbinding::Binding::DebugMessageInsert(source, type, id, severity, length, buf);
  }
  
  inline void glDeleteBuffers(GLsizei n, const GLuint * buffers)
  {
      return glbinding::Binding::DeleteBuffers(n, buffers);
  }
  
  inline void glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers)
  {
      return glbinding::Binding::DeleteFramebuffers(n, framebuffers);
  }
  
  inline void glDeleteLists(GLuint list, GLsizei range)
  {
      return glbinding::Binding::DeleteLists(list, range);
  }
  
  inline void glDeleteProgram(GLuint program)
  {
      return glbinding::Binding::DeleteProgram(program);
  }
  
  inline void glDeleteProgramPipelines(GLsizei n, const GLuint * pipelines)
  {
      return glbinding::Binding::DeleteProgramPipelines(n, pipelines);
  }
  
  inline void glDeleteQueries(GLsizei n, const GLuint * ids)
  {
      return glbinding::Binding::DeleteQueries(n, ids);
  }
  
  inline void glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers)
  {
      return glbinding::Binding::DeleteRenderbuffers(n, renderbuffers);
  }
  
  inline void glDeleteSamplers(GLsizei count, const GLuint * samplers)
  {
      return glbinding::Binding::DeleteSamplers(count, samplers);
  }
  
  inline void glDeleteShader(GLuint shader)
  {
      return glbinding::Binding::DeleteShader(shader);
  }
  
  inline void glDeleteSync(GLsync sync)
  {
      return glbinding::Binding::DeleteSync(sync);
  }
  
  inline void glDeleteTextures(GLsizei n, const GLuint * textures)
  {
      return glbinding::Binding::DeleteTextures(n, textures);
  }
  
  inline void glDeleteTransformFeedbacks(GLsizei n, const GLuint * ids)
  {
      return glbinding::Binding::DeleteTransformFeedbacks(n, ids);
  }
  
  inline void glDeleteVertexArrays(GLsizei n, const GLuint * arrays)
  {
      return glbinding::Binding::DeleteVertexArrays(n, arrays);
  }
  
  inline void glDepthFunc(GLenum func)
  {
      return glbinding::Binding::DepthFunc(func);
  }
  
  inline void glDepthMask(GLboolean flag)
  {
      return glbinding::Binding::DepthMask(flag);
  }
  
  inline void glDepthRange(GLdouble near_, GLdouble far_)
  {
      return glbinding::Binding::DepthRange(near_, far_);
  }
  
  inline void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble * v)
  {
      return glbinding::Binding::DepthRangeArrayv(first, count, v);
  }
  
  inline void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
  {
      return glbinding::Binding::DepthRangeIndexed(index, n, f);
  }
  
  inline void glDepthRangef(GLfloat n, GLfloat f)
  {
      return glbinding::Binding::DepthRangef(n, f);
  }
  
  inline void glDetachShader(GLuint program, GLuint shader)
  {
      return glbinding::Binding::DetachShader(program, shader);
  }
  
  inline void glDisable(GLenum cap)
  {
      return glbinding::Binding::Disable(cap);
  }
  
  inline void glDisableClientState(GLenum array)
  {
      return glbinding::Binding::DisableClientState(array);
  }
  
  inline void glDisableVertexAttribArray(GLuint index)
  {
      return glbinding::Binding::DisableVertexAttribArray(index);
  }
  
  inline void glDisablei(GLenum target, GLuint index)
  {
      return glbinding::Binding::Disablei(target, index);
  }
  
  inline void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
  {
      return glbinding::Binding::DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
  }
  
  inline void glDispatchComputeIndirect(GLintptr indirect)
  {
      return glbinding::Binding::DispatchComputeIndirect(indirect);
  }
  
  inline void glDrawArrays(GLenum mode, GLint first, GLsizei count)
  {
      return glbinding::Binding::DrawArrays(mode, first, count);
  }
  
  inline void glDrawArraysIndirect(GLenum mode, const void * indirect)
  {
      return glbinding::Binding::DrawArraysIndirect(mode, indirect);
  }
  
  inline void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
  {
      return glbinding::Binding::DrawArraysInstanced(mode, first, count, instancecount);
  }
  
  inline void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
  {
      return glbinding::Binding::DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
  }
  
  inline void glDrawBuffer(GLenum buf)
  {
      return glbinding::Binding::DrawBuffer(buf);
  }
  
  inline void glDrawBuffers(GLsizei n, const GLenum * bufs)
  {
      return glbinding::Binding::DrawBuffers(n, bufs);
  }
  
  inline void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void * indices)
  {
      return glbinding::Binding::DrawElements(mode, count, type, indices);
  }
  
  inline void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex)
  {
      return glbinding::Binding::DrawElementsBaseVertex(mode, count, type, indices, basevertex);
  }
  
  inline void glDrawElementsIndirect(GLenum mode, GLenum type, const void * indirect)
  {
      return glbinding::Binding::DrawElementsIndirect(mode, type, indirect);
  }
  
  inline void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount)
  {
      return glbinding::Binding::DrawElementsInstanced(mode, count, type, indices, instancecount);
  }
  
  inline void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance)
  {
      return glbinding::Binding::DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
  }
  
  inline void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex)
  {
      return glbinding::Binding::DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
  }
  
  inline void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
  {
      return glbinding::Binding::DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
  }
  
  inline void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::DrawPixels(width, height, format, type, pixels);
  }
  
  inline void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices)
  {
      return glbinding::Binding::DrawRangeElements(mode, start, end, count, type, indices);
  }
  
  inline void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex)
  {
      return glbinding::Binding::DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
  }
  
  inline void glDrawTransformFeedback(GLenum mode, GLuint id)
  {
      return glbinding::Binding::DrawTransformFeedback(mode, id);
  }
  
  inline void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
  {
      return glbinding::Binding::DrawTransformFeedbackInstanced(mode, id, instancecount);
  }
  
  inline void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
  {
      return glbinding::Binding::DrawTransformFeedbackStream(mode, id, stream);
  }
  
  inline void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
  {
      return glbinding::Binding::DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
  }
  
  inline void glEdgeFlag(GLboolean flag)
  {
      return glbinding::Binding::EdgeFlag(flag);
  }
  
  inline void glEdgeFlagPointer(GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::EdgeFlagPointer(stride, pointer);
  }
  
  inline void glEdgeFlagv(const GLboolean * flag)
  {
      return glbinding::Binding::EdgeFlagv(flag);
  }
  
  inline void glEnable(GLenum cap)
  {
      return glbinding::Binding::Enable(cap);
  }
  
  inline void glEnableClientState(GLenum array)
  {
      return glbinding::Binding::EnableClientState(array);
  }
  
  inline void glEnableVertexAttribArray(GLuint index)
  {
      return glbinding::Binding::EnableVertexAttribArray(index);
  }
  
  inline void glEnablei(GLenum target, GLuint index)
  {
      return glbinding::Binding::Enablei(target, index);
  }
  
  inline void glEnd()
  {
      return glbinding::Binding::End();
  }
  
  inline void glEndConditionalRender()
  {
      return glbinding::Binding::EndConditionalRender();
  }
  
  inline void glEndList()
  {
      return glbinding::Binding::EndList();
  }
  
  inline void glEndQuery(GLenum target)
  {
      return glbinding::Binding::EndQuery(target);
  }
  
  inline void glEndQueryIndexed(GLenum target, GLuint index)
  {
      return glbinding::Binding::EndQueryIndexed(target, index);
  }
  
  inline void glEndTransformFeedback()
  {
      return glbinding::Binding::EndTransformFeedback();
  }
  
  inline void glEvalCoord1d(GLdouble u)
  {
      return glbinding::Binding::EvalCoord1d(u);
  }
  
  inline void glEvalCoord1dv(const GLdouble * u)
  {
      return glbinding::Binding::EvalCoord1dv(u);
  }
  
  inline void glEvalCoord1f(GLfloat u)
  {
      return glbinding::Binding::EvalCoord1f(u);
  }
  
  inline void glEvalCoord1fv(const GLfloat * u)
  {
      return glbinding::Binding::EvalCoord1fv(u);
  }
  
  inline void glEvalCoord2d(GLdouble u, GLdouble v)
  {
      return glbinding::Binding::EvalCoord2d(u, v);
  }
  
  inline void glEvalCoord2dv(const GLdouble * u)
  {
      return glbinding::Binding::EvalCoord2dv(u);
  }
  
  inline void glEvalCoord2f(GLfloat u, GLfloat v)
  {
      return glbinding::Binding::EvalCoord2f(u, v);
  }
  
  inline void glEvalCoord2fv(const GLfloat * u)
  {
      return glbinding::Binding::EvalCoord2fv(u);
  }
  
  inline void glEvalMesh1(GLenum mode, GLint i1, GLint i2)
  {
      return glbinding::Binding::EvalMesh1(mode, i1, i2);
  }
  
  inline void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
  {
      return glbinding::Binding::EvalMesh2(mode, i1, i2, j1, j2);
  }
  
  inline void glEvalPoint1(GLint i)
  {
      return glbinding::Binding::EvalPoint1(i);
  }
  
  inline void glEvalPoint2(GLint i, GLint j)
  {
      return glbinding::Binding::EvalPoint2(i, j);
  }
  
  inline void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
  {
      return glbinding::Binding::FeedbackBuffer(size, type, buffer);
  }
  
  inline GLsync glFenceSync(GLenum condition, UnusedMask flags)
  {
      return glbinding::Binding::FenceSync(condition, flags);
  }
  
  inline void glFinish()
  {
      return glbinding::Binding::Finish();
  }
  
  inline void glFlush()
  {
      return glbinding::Binding::Flush();
  }
  
  inline void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
  {
      return glbinding::Binding::FlushMappedBufferRange(target, offset, length);
  }
  
  inline void glFogCoordPointer(GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::FogCoordPointer(type, stride, pointer);
  }
  
  inline void glFogCoordd(GLdouble coord)
  {
      return glbinding::Binding::FogCoordd(coord);
  }
  
  inline void glFogCoorddv(const GLdouble * coord)
  {
      return glbinding::Binding::FogCoorddv(coord);
  }
  
  inline void glFogCoordf(GLfloat coord)
  {
      return glbinding::Binding::FogCoordf(coord);
  }
  
  inline void glFogCoordfv(const GLfloat * coord)
  {
      return glbinding::Binding::FogCoordfv(coord);
  }
  
  inline void glFogf(GLenum pname, GLfloat param)
  {
      return glbinding::Binding::Fogf(pname, param);
  }
  
  inline void glFogfv(GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::Fogfv(pname, params);
  }
  
  inline void glFogi(GLenum pname, GLint param)
  {
      return glbinding::Binding::Fogi(pname, param);
  }
  
  inline void glFogiv(GLenum pname, const GLint * params)
  {
      return glbinding::Binding::Fogiv(pname, params);
  }
  
  inline void glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
  {
      return glbinding::Binding::FramebufferParameteri(target, pname, param);
  }
  
  inline void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
  {
      return glbinding::Binding::FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
  }
  
  inline void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
  {
      return glbinding::Binding::FramebufferTexture(target, attachment, texture, level);
  }
  
  inline void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
  {
      return glbinding::Binding::FramebufferTexture1D(target, attachment, textarget, texture, level);
  }
  
  inline void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
  {
      return glbinding::Binding::FramebufferTexture2D(target, attachment, textarget, texture, level);
  }
  
  inline void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
  {
      return glbinding::Binding::FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
  }
  
  inline void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
  {
      return glbinding::Binding::FramebufferTextureLayer(target, attachment, texture, level, layer);
  }
  
  inline void glFrontFace(GLenum mode)
  {
      return glbinding::Binding::FrontFace(mode);
  }
  
  inline void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
  {
      return glbinding::Binding::Frustum(left, right, bottom, top, zNear, zFar);
  }
  
  inline void glGenBuffers(GLsizei n, GLuint * buffers)
  {
      return glbinding::Binding::GenBuffers(n, buffers);
  }
  
  inline void glGenFramebuffers(GLsizei n, GLuint * framebuffers)
  {
      return glbinding::Binding::GenFramebuffers(n, framebuffers);
  }
  
  inline GLuint glGenLists(GLsizei range)
  {
      return glbinding::Binding::GenLists(range);
  }
  
  inline void glGenProgramPipelines(GLsizei n, GLuint * pipelines)
  {
      return glbinding::Binding::GenProgramPipelines(n, pipelines);
  }
  
  inline void glGenQueries(GLsizei n, GLuint * ids)
  {
      return glbinding::Binding::GenQueries(n, ids);
  }
  
  inline void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers)
  {
      return glbinding::Binding::GenRenderbuffers(n, renderbuffers);
  }
  
  inline void glGenSamplers(GLsizei count, GLuint * samplers)
  {
      return glbinding::Binding::GenSamplers(count, samplers);
  }
  
  inline void glGenTextures(GLsizei n, GLuint * textures)
  {
      return glbinding::Binding::GenTextures(n, textures);
  }
  
  inline void glGenTransformFeedbacks(GLsizei n, GLuint * ids)
  {
      return glbinding::Binding::GenTransformFeedbacks(n, ids);
  }
  
  inline void glGenVertexArrays(GLsizei n, GLuint * arrays)
  {
      return glbinding::Binding::GenVertexArrays(n, arrays);
  }
  
  inline void glGenerateMipmap(GLenum target)
  {
      return glbinding::Binding::GenerateMipmap(target);
  }
  
  inline void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
  }
  
  inline void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
  {
      return glbinding::Binding::GetActiveAttrib(program, index, bufSize, length, size, type, name);
  }
  
  inline void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
  {
      return glbinding::Binding::GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
  }
  
  inline void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
  {
      return glbinding::Binding::GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
  }
  
  inline void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values)
  {
      return glbinding::Binding::GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
  }
  
  inline void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
  {
      return glbinding::Binding::GetActiveUniform(program, index, bufSize, length, size, type, name);
  }
  
  inline void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName)
  {
      return glbinding::Binding::GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
  }
  
  inline void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
  }
  
  inline void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName)
  {
      return glbinding::Binding::GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
  }
  
  inline void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
  }
  
  inline void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders)
  {
      return glbinding::Binding::GetAttachedShaders(program, maxCount, count, shaders);
  }
  
  inline GLint glGetAttribLocation(GLuint program, const GLchar * name)
  {
      return glbinding::Binding::GetAttribLocation(program, name);
  }
  
  inline void glGetBooleani_v(GLenum target, GLuint index, GLboolean * data)
  {
      return glbinding::Binding::GetBooleani_v(target, index, data);
  }
  
  inline void glGetBooleanv(GLenum pname, GLboolean * data)
  {
      return glbinding::Binding::GetBooleanv(pname, data);
  }
  
  inline void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 * params)
  {
      return glbinding::Binding::GetBufferParameteri64v(target, pname, params);
  }
  
  inline void glGetBufferParameteriv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetBufferParameteriv(target, pname, params);
  }
  
  inline void glGetBufferPointerv(GLenum target, GLenum pname, void ** params)
  {
      return glbinding::Binding::GetBufferPointerv(target, pname, params);
  }
  
  inline void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void * data)
  {
      return glbinding::Binding::GetBufferSubData(target, offset, size, data);
  }
  
  inline void glGetClipPlane(GLenum plane, GLdouble * equation)
  {
      return glbinding::Binding::GetClipPlane(plane, equation);
  }
  
  inline void glGetCompressedTexImage(GLenum target, GLint level, void * img)
  {
      return glbinding::Binding::GetCompressedTexImage(target, level, img);
  }
  
  inline GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog)
  {
      return glbinding::Binding::GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
  }
  
  inline void glGetDoublei_v(GLenum target, GLuint index, GLdouble * data)
  {
      return glbinding::Binding::GetDoublei_v(target, index, data);
  }
  
  inline void glGetDoublev(GLenum pname, GLdouble * data)
  {
      return glbinding::Binding::GetDoublev(pname, data);
  }
  
  inline GLenum glGetError()
  {
      return static_cast<gl43::GLenum>(glbinding::Binding::GetError());
  }
  
  inline void glGetFloati_v(GLenum target, GLuint index, GLfloat * data)
  {
      return glbinding::Binding::GetFloati_v(target, index, data);
  }
  
  inline void glGetFloatv(GLenum pname, GLfloat * data)
  {
      return glbinding::Binding::GetFloatv(pname, data);
  }
  
  inline GLint glGetFragDataIndex(GLuint program, const GLchar * name)
  {
      return glbinding::Binding::GetFragDataIndex(program, name);
  }
  
  inline GLint glGetFragDataLocation(GLuint program, const GLchar * name)
  {
      return glbinding::Binding::GetFragDataLocation(program, name);
  }
  
  inline void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
  }
  
  inline void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetFramebufferParameteriv(target, pname, params);
  }
  
  inline void glGetInteger64i_v(GLenum target, GLuint index, GLint64 * data)
  {
      return glbinding::Binding::GetInteger64i_v(target, index, data);
  }
  
  inline void glGetInteger64v(GLenum pname, GLint64 * data)
  {
      return glbinding::Binding::GetInteger64v(pname, data);
  }
  
  inline void glGetIntegeri_v(GLenum target, GLuint index, GLint * data)
  {
      return glbinding::Binding::GetIntegeri_v(target, index, data);
  }
  
  inline void glGetIntegerv(GLenum pname, GLint * data)
  {
      return glbinding::Binding::GetIntegerv(pname, data);
  }
  
  inline void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params)
  {
      return glbinding::Binding::GetInternalformati64v(target, internalformat, pname, bufSize, params);
  }
  
  inline void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params)
  {
      return glbinding::Binding::GetInternalformativ(target, internalformat, pname, bufSize, params);
  }
  
  inline void glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetLightfv(light, pname, params);
  }
  
  inline void glGetLightiv(GLenum light, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetLightiv(light, pname, params);
  }
  
  inline void glGetMapdv(GLenum target, GLenum query, GLdouble * v)
  {
      return glbinding::Binding::GetMapdv(target, query, v);
  }
  
  inline void glGetMapfv(GLenum target, GLenum query, GLfloat * v)
  {
      return glbinding::Binding::GetMapfv(target, query, v);
  }
  
  inline void glGetMapiv(GLenum target, GLenum query, GLint * v)
  {
      return glbinding::Binding::GetMapiv(target, query, v);
  }
  
  inline void glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetMaterialfv(face, pname, params);
  }
  
  inline void glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetMaterialiv(face, pname, params);
  }
  
  inline void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat * val)
  {
      return glbinding::Binding::GetMultisamplefv(pname, index, val);
  }
  
  inline void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label)
  {
      return glbinding::Binding::GetObjectLabel(identifier, name, bufSize, length, label);
  }
  
  inline void glGetObjectPtrLabel(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label)
  {
      return glbinding::Binding::GetObjectPtrLabel(ptr, bufSize, length, label);
  }
  
  inline void glGetPixelMapfv(GLenum map, GLfloat * values)
  {
      return glbinding::Binding::GetPixelMapfv(map, values);
  }
  
  inline void glGetPixelMapuiv(GLenum map, GLuint * values)
  {
      return glbinding::Binding::GetPixelMapuiv(map, values);
  }
  
  inline void glGetPixelMapusv(GLenum map, GLushort * values)
  {
      return glbinding::Binding::GetPixelMapusv(map, values);
  }
  
  inline void glGetPointerv(GLenum pname, void ** params)
  {
      return glbinding::Binding::GetPointerv(pname, params);
  }
  
  inline void glGetPolygonStipple(GLubyte * mask)
  {
      return glbinding::Binding::GetPolygonStipple(mask);
  }
  
  inline void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary)
  {
      return glbinding::Binding::GetProgramBinary(program, bufSize, length, binaryFormat, binary);
  }
  
  inline void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
  {
      return glbinding::Binding::GetProgramInfoLog(program, bufSize, length, infoLog);
  }
  
  inline void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetProgramInterfaceiv(program, programInterface, pname, params);
  }
  
  inline void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
  {
      return glbinding::Binding::GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
  }
  
  inline void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetProgramPipelineiv(pipeline, pname, params);
  }
  
  inline GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar * name)
  {
      return glbinding::Binding::GetProgramResourceIndex(program, programInterface, name);
  }
  
  inline GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar * name)
  {
      return glbinding::Binding::GetProgramResourceLocation(program, programInterface, name);
  }
  
  inline GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar * name)
  {
      return glbinding::Binding::GetProgramResourceLocationIndex(program, programInterface, name);
  }
  
  inline void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name)
  {
      return glbinding::Binding::GetProgramResourceName(program, programInterface, index, bufSize, length, name);
  }
  
  inline void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params)
  {
      return glbinding::Binding::GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
  }
  
  inline void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint * values)
  {
      return glbinding::Binding::GetProgramStageiv(program, shadertype, pname, values);
  }
  
  inline void glGetProgramiv(GLuint program, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetProgramiv(program, pname, params);
  }
  
  inline void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetQueryIndexediv(target, index, pname, params);
  }
  
  inline void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 * params)
  {
      return glbinding::Binding::GetQueryObjecti64v(id, pname, params);
  }
  
  inline void glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetQueryObjectiv(id, pname, params);
  }
  
  inline void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 * params)
  {
      return glbinding::Binding::GetQueryObjectui64v(id, pname, params);
  }
  
  inline void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params)
  {
      return glbinding::Binding::GetQueryObjectuiv(id, pname, params);
  }
  
  inline void glGetQueryiv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetQueryiv(target, pname, params);
  }
  
  inline void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetRenderbufferParameteriv(target, pname, params);
  }
  
  inline void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetSamplerParameterIiv(sampler, pname, params);
  }
  
  inline void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint * params)
  {
      return glbinding::Binding::GetSamplerParameterIuiv(sampler, pname, params);
  }
  
  inline void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetSamplerParameterfv(sampler, pname, params);
  }
  
  inline void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetSamplerParameteriv(sampler, pname, params);
  }
  
  inline void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
  {
      return glbinding::Binding::GetShaderInfoLog(shader, bufSize, length, infoLog);
  }
  
  inline void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision)
  {
      return glbinding::Binding::GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
  }
  
  inline void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)
  {
      return glbinding::Binding::GetShaderSource(shader, bufSize, length, source);
  }
  
  inline void glGetShaderiv(GLuint shader, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetShaderiv(shader, pname, params);
  }
  
  inline const GLubyte * glGetString(GLenum name)
  {
      return glbinding::Binding::GetString(name);
  }
  
  inline const GLubyte * glGetStringi(GLenum name, GLuint index)
  {
      return glbinding::Binding::GetStringi(name, index);
  }
  
  inline GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar * name)
  {
      return glbinding::Binding::GetSubroutineIndex(program, shadertype, name);
  }
  
  inline GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar * name)
  {
      return glbinding::Binding::GetSubroutineUniformLocation(program, shadertype, name);
  }
  
  inline void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values)
  {
      return glbinding::Binding::GetSynciv(sync, pname, bufSize, length, values);
  }
  
  inline void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetTexEnvfv(target, pname, params);
  }
  
  inline void glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetTexEnviv(target, pname, params);
  }
  
  inline void glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
  {
      return glbinding::Binding::GetTexGendv(coord, pname, params);
  }
  
  inline void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetTexGenfv(coord, pname, params);
  }
  
  inline void glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetTexGeniv(coord, pname, params);
  }
  
  inline void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void * pixels)
  {
      return glbinding::Binding::GetTexImage(target, level, format, type, pixels);
  }
  
  inline void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetTexLevelParameterfv(target, level, pname, params);
  }
  
  inline void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetTexLevelParameteriv(target, level, pname, params);
  }
  
  inline void glGetTexParameterIiv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetTexParameterIiv(target, pname, params);
  }
  
  inline void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint * params)
  {
      return glbinding::Binding::GetTexParameterIuiv(target, pname, params);
  }
  
  inline void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetTexParameterfv(target, pname, params);
  }
  
  inline void glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetTexParameteriv(target, pname, params);
  }
  
  inline void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
  {
      return glbinding::Binding::GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
  }
  
  inline GLuint glGetUniformBlockIndex(GLuint program, const GLchar * uniformBlockName)
  {
      return glbinding::Binding::GetUniformBlockIndex(program, uniformBlockName);
  }
  
  inline void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices)
  {
      return glbinding::Binding::GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
  }
  
  inline GLint glGetUniformLocation(GLuint program, const GLchar * name)
  {
      return glbinding::Binding::GetUniformLocation(program, name);
  }
  
  inline void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint * params)
  {
      return glbinding::Binding::GetUniformSubroutineuiv(shadertype, location, params);
  }
  
  inline void glGetUniformdv(GLuint program, GLint location, GLdouble * params)
  {
      return glbinding::Binding::GetUniformdv(program, location, params);
  }
  
  inline void glGetUniformfv(GLuint program, GLint location, GLfloat * params)
  {
      return glbinding::Binding::GetUniformfv(program, location, params);
  }
  
  inline void glGetUniformiv(GLuint program, GLint location, GLint * params)
  {
      return glbinding::Binding::GetUniformiv(program, location, params);
  }
  
  inline void glGetUniformuiv(GLuint program, GLint location, GLuint * params)
  {
      return glbinding::Binding::GetUniformuiv(program, location, params);
  }
  
  inline void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetVertexAttribIiv(index, pname, params);
  }
  
  inline void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint * params)
  {
      return glbinding::Binding::GetVertexAttribIuiv(index, pname, params);
  }
  
  inline void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble * params)
  {
      return glbinding::Binding::GetVertexAttribLdv(index, pname, params);
  }
  
  inline void glGetVertexAttribPointerv(GLuint index, GLenum pname, void ** pointer)
  {
      return glbinding::Binding::GetVertexAttribPointerv(index, pname, pointer);
  }
  
  inline void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble * params)
  {
      return glbinding::Binding::GetVertexAttribdv(index, pname, params);
  }
  
  inline void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat * params)
  {
      return glbinding::Binding::GetVertexAttribfv(index, pname, params);
  }
  
  inline void glGetVertexAttribiv(GLuint index, GLenum pname, GLint * params)
  {
      return glbinding::Binding::GetVertexAttribiv(index, pname, params);
  }
  
  inline void glHint(GLenum target, GLenum mode)
  {
      return glbinding::Binding::Hint(target, mode);
  }
  
  inline void glIndexMask(GLuint mask)
  {
      return glbinding::Binding::IndexMask(mask);
  }
  
  inline void glIndexPointer(GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::IndexPointer(type, stride, pointer);
  }
  
  inline void glIndexd(GLdouble c)
  {
      return glbinding::Binding::Indexd(c);
  }
  
  inline void glIndexdv(const GLdouble * c)
  {
      return glbinding::Binding::Indexdv(c);
  }
  
  inline void glIndexf(GLfloat c)
  {
      return glbinding::Binding::Indexf(c);
  }
  
  inline void glIndexfv(const GLfloat * c)
  {
      return glbinding::Binding::Indexfv(c);
  }
  
  inline void glIndexi(GLint c)
  {
      return glbinding::Binding::Indexi(c);
  }
  
  inline void glIndexiv(const GLint * c)
  {
      return glbinding::Binding::Indexiv(c);
  }
  
  inline void glIndexs(GLshort c)
  {
      return glbinding::Binding::Indexs(c);
  }
  
  inline void glIndexsv(const GLshort * c)
  {
      return glbinding::Binding::Indexsv(c);
  }
  
  inline void glIndexub(GLubyte c)
  {
      return glbinding::Binding::Indexub(c);
  }
  
  inline void glIndexubv(const GLubyte * c)
  {
      return glbinding::Binding::Indexubv(c);
  }
  
  inline void glInitNames()
  {
      return glbinding::Binding::InitNames();
  }
  
  inline void glInterleavedArrays(GLenum format, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::InterleavedArrays(format, stride, pointer);
  }
  
  inline void glInvalidateBufferData(GLuint buffer)
  {
      return glbinding::Binding::InvalidateBufferData(buffer);
  }
  
  inline void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
  {
      return glbinding::Binding::InvalidateBufferSubData(buffer, offset, length);
  }
  
  inline void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments)
  {
      return glbinding::Binding::InvalidateFramebuffer(target, numAttachments, attachments);
  }
  
  inline void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
  }
  
  inline void glInvalidateTexImage(GLuint texture, GLint level)
  {
      return glbinding::Binding::InvalidateTexImage(texture, level);
  }
  
  inline void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
  {
      return glbinding::Binding::InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
  }
  
  inline GLboolean glIsBuffer(GLuint buffer)
  {
      return glbinding::Binding::IsBuffer(buffer);
  }
  
  inline GLboolean glIsEnabled(GLenum cap)
  {
      return glbinding::Binding::IsEnabled(cap);
  }
  
  inline GLboolean glIsEnabledi(GLenum target, GLuint index)
  {
      return glbinding::Binding::IsEnabledi(target, index);
  }
  
  inline GLboolean glIsFramebuffer(GLuint framebuffer)
  {
      return glbinding::Binding::IsFramebuffer(framebuffer);
  }
  
  inline GLboolean glIsList(GLuint list)
  {
      return glbinding::Binding::IsList(list);
  }
  
  inline GLboolean glIsProgram(GLuint program)
  {
      return glbinding::Binding::IsProgram(program);
  }
  
  inline GLboolean glIsProgramPipeline(GLuint pipeline)
  {
      return glbinding::Binding::IsProgramPipeline(pipeline);
  }
  
  inline GLboolean glIsQuery(GLuint id)
  {
      return glbinding::Binding::IsQuery(id);
  }
  
  inline GLboolean glIsRenderbuffer(GLuint renderbuffer)
  {
      return glbinding::Binding::IsRenderbuffer(renderbuffer);
  }
  
  inline GLboolean glIsSampler(GLuint sampler)
  {
      return glbinding::Binding::IsSampler(sampler);
  }
  
  inline GLboolean glIsShader(GLuint shader)
  {
      return glbinding::Binding::IsShader(shader);
  }
  
  inline GLboolean glIsSync(GLsync sync)
  {
      return glbinding::Binding::IsSync(sync);
  }
  
  inline GLboolean glIsTexture(GLuint texture)
  {
      return glbinding::Binding::IsTexture(texture);
  }
  
  inline GLboolean glIsTransformFeedback(GLuint id)
  {
      return glbinding::Binding::IsTransformFeedback(id);
  }
  
  inline GLboolean glIsVertexArray(GLuint array)
  {
      return glbinding::Binding::IsVertexArray(array);
  }
  
  inline void glLightModelf(GLenum pname, GLfloat param)
  {
      return glbinding::Binding::LightModelf(pname, param);
  }
  
  inline void glLightModelfv(GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::LightModelfv(pname, params);
  }
  
  inline void glLightModeli(GLenum pname, GLint param)
  {
      return glbinding::Binding::LightModeli(pname, param);
  }
  
  inline void glLightModeliv(GLenum pname, const GLint * params)
  {
      return glbinding::Binding::LightModeliv(pname, params);
  }
  
  inline void glLightf(GLenum light, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::Lightf(light, pname, param);
  }
  
  inline void glLightfv(GLenum light, GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::Lightfv(light, pname, params);
  }
  
  inline void glLighti(GLenum light, GLenum pname, GLint param)
  {
      return glbinding::Binding::Lighti(light, pname, param);
  }
  
  inline void glLightiv(GLenum light, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::Lightiv(light, pname, params);
  }
  
  inline void glLineStipple(GLint factor, GLushort pattern)
  {
      return glbinding::Binding::LineStipple(factor, pattern);
  }
  
  inline void glLineWidth(GLfloat width)
  {
      return glbinding::Binding::LineWidth(width);
  }
  
  inline void glLinkProgram(GLuint program)
  {
      return glbinding::Binding::LinkProgram(program);
  }
  
  inline void glListBase(GLuint base)
  {
      return glbinding::Binding::ListBase(base);
  }
  
  inline void glLoadIdentity()
  {
      return glbinding::Binding::LoadIdentity();
  }
  
  inline void glLoadMatrixd(const GLdouble * m)
  {
      return glbinding::Binding::LoadMatrixd(m);
  }
  
  inline void glLoadMatrixf(const GLfloat * m)
  {
      return glbinding::Binding::LoadMatrixf(m);
  }
  
  inline void glLoadName(GLuint name)
  {
      return glbinding::Binding::LoadName(name);
  }
  
  inline void glLoadTransposeMatrixd(const GLdouble * m)
  {
      return glbinding::Binding::LoadTransposeMatrixd(m);
  }
  
  inline void glLoadTransposeMatrixf(const GLfloat * m)
  {
      return glbinding::Binding::LoadTransposeMatrixf(m);
  }
  
  inline void glLogicOp(GLenum opcode)
  {
      return glbinding::Binding::LogicOp(opcode);
  }
  
  inline void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points)
  {
      return glbinding::Binding::Map1d(target, u1, u2, stride, order, points);
  }
  
  inline void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points)
  {
      return glbinding::Binding::Map1f(target, u1, u2, stride, order, points);
  }
  
  inline void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points)
  {
      return glbinding::Binding::Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  }
  
  inline void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points)
  {
      return glbinding::Binding::Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
  }
  
  inline void * glMapBuffer(GLenum target, GLenum access)
  {
      return glbinding::Binding::MapBuffer(target, access);
  }
  
  inline void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, BufferAccessMask access)
  {
      return glbinding::Binding::MapBufferRange(target, offset, length, access);
  }
  
  inline void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
  {
      return glbinding::Binding::MapGrid1d(un, u1, u2);
  }
  
  inline void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
  {
      return glbinding::Binding::MapGrid1f(un, u1, u2);
  }
  
  inline void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
  {
      return glbinding::Binding::MapGrid2d(un, u1, u2, vn, v1, v2);
  }
  
  inline void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
  {
      return glbinding::Binding::MapGrid2f(un, u1, u2, vn, v1, v2);
  }
  
  inline void glMaterialf(GLenum face, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::Materialf(face, pname, param);
  }
  
  inline void glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::Materialfv(face, pname, params);
  }
  
  inline void glMateriali(GLenum face, GLenum pname, GLint param)
  {
      return glbinding::Binding::Materiali(face, pname, param);
  }
  
  inline void glMaterialiv(GLenum face, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::Materialiv(face, pname, params);
  }
  
  inline void glMatrixMode(GLenum mode)
  {
      return glbinding::Binding::MatrixMode(mode);
  }
  
  inline void glMemoryBarrier(MemoryBarrierMask barriers)
  {
      return glbinding::Binding::MemoryBarrier(barriers);
  }
  
  inline void glMinSampleShading(GLfloat value)
  {
      return glbinding::Binding::MinSampleShading(value);
  }
  
  inline void glMultMatrixd(const GLdouble * m)
  {
      return glbinding::Binding::MultMatrixd(m);
  }
  
  inline void glMultMatrixf(const GLfloat * m)
  {
      return glbinding::Binding::MultMatrixf(m);
  }
  
  inline void glMultTransposeMatrixd(const GLdouble * m)
  {
      return glbinding::Binding::MultTransposeMatrixd(m);
  }
  
  inline void glMultTransposeMatrixf(const GLfloat * m)
  {
      return glbinding::Binding::MultTransposeMatrixf(m);
  }
  
  inline void glMultiDrawArrays(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount)
  {
      return glbinding::Binding::MultiDrawArrays(mode, first, count, drawcount);
  }
  
  inline void glMultiDrawArraysIndirect(GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride)
  {
      return glbinding::Binding::MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
  }
  
  inline void glMultiDrawElements(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount)
  {
      return glbinding::Binding::MultiDrawElements(mode, count, type, indices, drawcount);
  }
  
  inline void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex)
  {
      return glbinding::Binding::MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
  }
  
  inline void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride)
  {
      return glbinding::Binding::MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
  }
  
  inline void glMultiTexCoord1d(GLenum target, GLdouble s)
  {
      return glbinding::Binding::MultiTexCoord1d(target, s);
  }
  
  inline void glMultiTexCoord1dv(GLenum target, const GLdouble * v)
  {
      return glbinding::Binding::MultiTexCoord1dv(target, v);
  }
  
  inline void glMultiTexCoord1f(GLenum target, GLfloat s)
  {
      return glbinding::Binding::MultiTexCoord1f(target, s);
  }
  
  inline void glMultiTexCoord1fv(GLenum target, const GLfloat * v)
  {
      return glbinding::Binding::MultiTexCoord1fv(target, v);
  }
  
  inline void glMultiTexCoord1i(GLenum target, GLint s)
  {
      return glbinding::Binding::MultiTexCoord1i(target, s);
  }
  
  inline void glMultiTexCoord1iv(GLenum target, const GLint * v)
  {
      return glbinding::Binding::MultiTexCoord1iv(target, v);
  }
  
  inline void glMultiTexCoord1s(GLenum target, GLshort s)
  {
      return glbinding::Binding::MultiTexCoord1s(target, s);
  }
  
  inline void glMultiTexCoord1sv(GLenum target, const GLshort * v)
  {
      return glbinding::Binding::MultiTexCoord1sv(target, v);
  }
  
  inline void glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
  {
      return glbinding::Binding::MultiTexCoord2d(target, s, t);
  }
  
  inline void glMultiTexCoord2dv(GLenum target, const GLdouble * v)
  {
      return glbinding::Binding::MultiTexCoord2dv(target, v);
  }
  
  inline void glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
  {
      return glbinding::Binding::MultiTexCoord2f(target, s, t);
  }
  
  inline void glMultiTexCoord2fv(GLenum target, const GLfloat * v)
  {
      return glbinding::Binding::MultiTexCoord2fv(target, v);
  }
  
  inline void glMultiTexCoord2i(GLenum target, GLint s, GLint t)
  {
      return glbinding::Binding::MultiTexCoord2i(target, s, t);
  }
  
  inline void glMultiTexCoord2iv(GLenum target, const GLint * v)
  {
      return glbinding::Binding::MultiTexCoord2iv(target, v);
  }
  
  inline void glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
  {
      return glbinding::Binding::MultiTexCoord2s(target, s, t);
  }
  
  inline void glMultiTexCoord2sv(GLenum target, const GLshort * v)
  {
      return glbinding::Binding::MultiTexCoord2sv(target, v);
  }
  
  inline void glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
  {
      return glbinding::Binding::MultiTexCoord3d(target, s, t, r);
  }
  
  inline void glMultiTexCoord3dv(GLenum target, const GLdouble * v)
  {
      return glbinding::Binding::MultiTexCoord3dv(target, v);
  }
  
  inline void glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
  {
      return glbinding::Binding::MultiTexCoord3f(target, s, t, r);
  }
  
  inline void glMultiTexCoord3fv(GLenum target, const GLfloat * v)
  {
      return glbinding::Binding::MultiTexCoord3fv(target, v);
  }
  
  inline void glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
  {
      return glbinding::Binding::MultiTexCoord3i(target, s, t, r);
  }
  
  inline void glMultiTexCoord3iv(GLenum target, const GLint * v)
  {
      return glbinding::Binding::MultiTexCoord3iv(target, v);
  }
  
  inline void glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
  {
      return glbinding::Binding::MultiTexCoord3s(target, s, t, r);
  }
  
  inline void glMultiTexCoord3sv(GLenum target, const GLshort * v)
  {
      return glbinding::Binding::MultiTexCoord3sv(target, v);
  }
  
  inline void glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
  {
      return glbinding::Binding::MultiTexCoord4d(target, s, t, r, q);
  }
  
  inline void glMultiTexCoord4dv(GLenum target, const GLdouble * v)
  {
      return glbinding::Binding::MultiTexCoord4dv(target, v);
  }
  
  inline void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
  {
      return glbinding::Binding::MultiTexCoord4f(target, s, t, r, q);
  }
  
  inline void glMultiTexCoord4fv(GLenum target, const GLfloat * v)
  {
      return glbinding::Binding::MultiTexCoord4fv(target, v);
  }
  
  inline void glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
  {
      return glbinding::Binding::MultiTexCoord4i(target, s, t, r, q);
  }
  
  inline void glMultiTexCoord4iv(GLenum target, const GLint * v)
  {
      return glbinding::Binding::MultiTexCoord4iv(target, v);
  }
  
  inline void glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
  {
      return glbinding::Binding::MultiTexCoord4s(target, s, t, r, q);
  }
  
  inline void glMultiTexCoord4sv(GLenum target, const GLshort * v)
  {
      return glbinding::Binding::MultiTexCoord4sv(target, v);
  }
  
  inline void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
  {
      return glbinding::Binding::MultiTexCoordP1ui(texture, type, coords);
  }
  
  inline void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::MultiTexCoordP1uiv(texture, type, coords);
  }
  
  inline void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
  {
      return glbinding::Binding::MultiTexCoordP2ui(texture, type, coords);
  }
  
  inline void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::MultiTexCoordP2uiv(texture, type, coords);
  }
  
  inline void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
  {
      return glbinding::Binding::MultiTexCoordP3ui(texture, type, coords);
  }
  
  inline void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::MultiTexCoordP3uiv(texture, type, coords);
  }
  
  inline void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
  {
      return glbinding::Binding::MultiTexCoordP4ui(texture, type, coords);
  }
  
  inline void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::MultiTexCoordP4uiv(texture, type, coords);
  }
  
  inline void glNewList(GLuint list, GLenum mode)
  {
      return glbinding::Binding::NewList(list, mode);
  }
  
  inline void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
  {
      return glbinding::Binding::Normal3b(nx, ny, nz);
  }
  
  inline void glNormal3bv(const GLbyte * v)
  {
      return glbinding::Binding::Normal3bv(v);
  }
  
  inline void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
  {
      return glbinding::Binding::Normal3d(nx, ny, nz);
  }
  
  inline void glNormal3dv(const GLdouble * v)
  {
      return glbinding::Binding::Normal3dv(v);
  }
  
  inline void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
  {
      return glbinding::Binding::Normal3f(nx, ny, nz);
  }
  
  inline void glNormal3fv(const GLfloat * v)
  {
      return glbinding::Binding::Normal3fv(v);
  }
  
  inline void glNormal3i(GLint nx, GLint ny, GLint nz)
  {
      return glbinding::Binding::Normal3i(nx, ny, nz);
  }
  
  inline void glNormal3iv(const GLint * v)
  {
      return glbinding::Binding::Normal3iv(v);
  }
  
  inline void glNormal3s(GLshort nx, GLshort ny, GLshort nz)
  {
      return glbinding::Binding::Normal3s(nx, ny, nz);
  }
  
  inline void glNormal3sv(const GLshort * v)
  {
      return glbinding::Binding::Normal3sv(v);
  }
  
  inline void glNormalP3ui(GLenum type, GLuint coords)
  {
      return glbinding::Binding::NormalP3ui(type, coords);
  }
  
  inline void glNormalP3uiv(GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::NormalP3uiv(type, coords);
  }
  
  inline void glNormalPointer(GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::NormalPointer(type, stride, pointer);
  }
  
  inline void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar * label)
  {
      return glbinding::Binding::ObjectLabel(identifier, name, length, label);
  }
  
  inline void glObjectPtrLabel(const void * ptr, GLsizei length, const GLchar * label)
  {
      return glbinding::Binding::ObjectPtrLabel(ptr, length, label);
  }
  
  inline void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
  {
      return glbinding::Binding::Ortho(left, right, bottom, top, zNear, zFar);
  }
  
  inline void glPassThrough(GLfloat token)
  {
      return glbinding::Binding::PassThrough(token);
  }
  
  inline void glPatchParameterfv(GLenum pname, const GLfloat * values)
  {
      return glbinding::Binding::PatchParameterfv(pname, values);
  }
  
  inline void glPatchParameteri(GLenum pname, GLint value)
  {
      return glbinding::Binding::PatchParameteri(pname, value);
  }
  
  inline void glPauseTransformFeedback()
  {
      return glbinding::Binding::PauseTransformFeedback();
  }
  
  inline void glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
  {
      return glbinding::Binding::PixelMapfv(map, mapsize, values);
  }
  
  inline void glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
  {
      return glbinding::Binding::PixelMapuiv(map, mapsize, values);
  }
  
  inline void glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
  {
      return glbinding::Binding::PixelMapusv(map, mapsize, values);
  }
  
  inline void glPixelStoref(GLenum pname, GLfloat param)
  {
      return glbinding::Binding::PixelStoref(pname, param);
  }
  
  inline void glPixelStorei(GLenum pname, GLint param)
  {
      return glbinding::Binding::PixelStorei(pname, param);
  }
  
  inline void glPixelTransferf(GLenum pname, GLfloat param)
  {
      return glbinding::Binding::PixelTransferf(pname, param);
  }
  
  inline void glPixelTransferi(GLenum pname, GLint param)
  {
      return glbinding::Binding::PixelTransferi(pname, param);
  }
  
  inline void glPixelZoom(GLfloat xfactor, GLfloat yfactor)
  {
      return glbinding::Binding::PixelZoom(xfactor, yfactor);
  }
  
  inline void glPointParameterf(GLenum pname, GLfloat param)
  {
      return glbinding::Binding::PointParameterf(pname, param);
  }
  
  inline void glPointParameterfv(GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::PointParameterfv(pname, params);
  }
  
  inline void glPointParameteri(GLenum pname, GLint param)
  {
      return glbinding::Binding::PointParameteri(pname, param);
  }
  
  inline void glPointParameteriv(GLenum pname, const GLint * params)
  {
      return glbinding::Binding::PointParameteriv(pname, params);
  }
  
  inline void glPointSize(GLfloat size)
  {
      return glbinding::Binding::PointSize(size);
  }
  
  inline void glPolygonMode(GLenum face, GLenum mode)
  {
      return glbinding::Binding::PolygonMode(face, mode);
  }
  
  inline void glPolygonOffset(GLfloat factor, GLfloat units)
  {
      return glbinding::Binding::PolygonOffset(factor, units);
  }
  
  inline void glPolygonStipple(const GLubyte * mask)
  {
      return glbinding::Binding::PolygonStipple(mask);
  }
  
  inline void glPopAttrib()
  {
      return glbinding::Binding::PopAttrib();
  }
  
  inline void glPopClientAttrib()
  {
      return glbinding::Binding::PopClientAttrib();
  }
  
  inline void glPopDebugGroup()
  {
      return glbinding::Binding::PopDebugGroup();
  }
  
  inline void glPopMatrix()
  {
      return glbinding::Binding::PopMatrix();
  }
  
  inline void glPopName()
  {
      return glbinding::Binding::PopName();
  }
  
  inline void glPrimitiveRestartIndex(GLuint index)
  {
      return glbinding::Binding::PrimitiveRestartIndex(index);
  }
  
  inline void glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLfloat * priorities)
  {
      return glbinding::Binding::PrioritizeTextures(n, textures, priorities);
  }
  
  inline void glProgramBinary(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length)
  {
      return glbinding::Binding::ProgramBinary(program, binaryFormat, binary, length);
  }
  
  inline void glProgramParameteri(GLuint program, GLenum pname, GLint value)
  {
      return glbinding::Binding::ProgramParameteri(program, pname, value);
  }
  
  inline void glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
  {
      return glbinding::Binding::ProgramUniform1d(program, location, v0);
  }
  
  inline void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniform1dv(program, location, count, value);
  }
  
  inline void glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
  {
      return glbinding::Binding::ProgramUniform1f(program, location, v0);
  }
  
  inline void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniform1fv(program, location, count, value);
  }
  
  inline void glProgramUniform1i(GLuint program, GLint location, GLint v0)
  {
      return glbinding::Binding::ProgramUniform1i(program, location, v0);
  }
  
  inline void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::ProgramUniform1iv(program, location, count, value);
  }
  
  inline void glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
  {
      return glbinding::Binding::ProgramUniform1ui(program, location, v0);
  }
  
  inline void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::ProgramUniform1uiv(program, location, count, value);
  }
  
  inline void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
  {
      return glbinding::Binding::ProgramUniform2d(program, location, v0, v1);
  }
  
  inline void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniform2dv(program, location, count, value);
  }
  
  inline void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
  {
      return glbinding::Binding::ProgramUniform2f(program, location, v0, v1);
  }
  
  inline void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniform2fv(program, location, count, value);
  }
  
  inline void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
  {
      return glbinding::Binding::ProgramUniform2i(program, location, v0, v1);
  }
  
  inline void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::ProgramUniform2iv(program, location, count, value);
  }
  
  inline void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
  {
      return glbinding::Binding::ProgramUniform2ui(program, location, v0, v1);
  }
  
  inline void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::ProgramUniform2uiv(program, location, count, value);
  }
  
  inline void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
  {
      return glbinding::Binding::ProgramUniform3d(program, location, v0, v1, v2);
  }
  
  inline void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniform3dv(program, location, count, value);
  }
  
  inline void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
  {
      return glbinding::Binding::ProgramUniform3f(program, location, v0, v1, v2);
  }
  
  inline void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniform3fv(program, location, count, value);
  }
  
  inline void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
  {
      return glbinding::Binding::ProgramUniform3i(program, location, v0, v1, v2);
  }
  
  inline void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::ProgramUniform3iv(program, location, count, value);
  }
  
  inline void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
  {
      return glbinding::Binding::ProgramUniform3ui(program, location, v0, v1, v2);
  }
  
  inline void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::ProgramUniform3uiv(program, location, count, value);
  }
  
  inline void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
  {
      return glbinding::Binding::ProgramUniform4d(program, location, v0, v1, v2, v3);
  }
  
  inline void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniform4dv(program, location, count, value);
  }
  
  inline void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
  {
      return glbinding::Binding::ProgramUniform4f(program, location, v0, v1, v2, v3);
  }
  
  inline void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniform4fv(program, location, count, value);
  }
  
  inline void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
  {
      return glbinding::Binding::ProgramUniform4i(program, location, v0, v1, v2, v3);
  }
  
  inline void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::ProgramUniform4iv(program, location, count, value);
  }
  
  inline void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
  {
      return glbinding::Binding::ProgramUniform4ui(program, location, v0, v1, v2, v3);
  }
  
  inline void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::ProgramUniform4uiv(program, location, count, value);
  }
  
  inline void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
  }
  
  inline void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
  }
  
  inline void glProvokingVertex(GLenum mode)
  {
      return glbinding::Binding::ProvokingVertex(mode);
  }
  
  inline void glPushAttrib(AttribMask mask)
  {
      return glbinding::Binding::PushAttrib(mask);
  }
  
  inline void glPushClientAttrib(ClientAttribMask mask)
  {
      return glbinding::Binding::PushClientAttrib(mask);
  }
  
  inline void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar * message)
  {
      return glbinding::Binding::PushDebugGroup(source, id, length, message);
  }
  
  inline void glPushMatrix()
  {
      return glbinding::Binding::PushMatrix();
  }
  
  inline void glPushName(GLuint name)
  {
      return glbinding::Binding::PushName(name);
  }
  
  inline void glQueryCounter(GLuint id, GLenum target)
  {
      return glbinding::Binding::QueryCounter(id, target);
  }
  
  inline void glRasterPos2d(GLdouble x, GLdouble y)
  {
      return glbinding::Binding::RasterPos2d(x, y);
  }
  
  inline void glRasterPos2dv(const GLdouble * v)
  {
      return glbinding::Binding::RasterPos2dv(v);
  }
  
  inline void glRasterPos2f(GLfloat x, GLfloat y)
  {
      return glbinding::Binding::RasterPos2f(x, y);
  }
  
  inline void glRasterPos2fv(const GLfloat * v)
  {
      return glbinding::Binding::RasterPos2fv(v);
  }
  
  inline void glRasterPos2i(GLint x, GLint y)
  {
      return glbinding::Binding::RasterPos2i(x, y);
  }
  
  inline void glRasterPos2iv(const GLint * v)
  {
      return glbinding::Binding::RasterPos2iv(v);
  }
  
  inline void glRasterPos2s(GLshort x, GLshort y)
  {
      return glbinding::Binding::RasterPos2s(x, y);
  }
  
  inline void glRasterPos2sv(const GLshort * v)
  {
      return glbinding::Binding::RasterPos2sv(v);
  }
  
  inline void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::RasterPos3d(x, y, z);
  }
  
  inline void glRasterPos3dv(const GLdouble * v)
  {
      return glbinding::Binding::RasterPos3dv(v);
  }
  
  inline void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::RasterPos3f(x, y, z);
  }
  
  inline void glRasterPos3fv(const GLfloat * v)
  {
      return glbinding::Binding::RasterPos3fv(v);
  }
  
  inline void glRasterPos3i(GLint x, GLint y, GLint z)
  {
      return glbinding::Binding::RasterPos3i(x, y, z);
  }
  
  inline void glRasterPos3iv(const GLint * v)
  {
      return glbinding::Binding::RasterPos3iv(v);
  }
  
  inline void glRasterPos3s(GLshort x, GLshort y, GLshort z)
  {
      return glbinding::Binding::RasterPos3s(x, y, z);
  }
  
  inline void glRasterPos3sv(const GLshort * v)
  {
      return glbinding::Binding::RasterPos3sv(v);
  }
  
  inline void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      return glbinding::Binding::RasterPos4d(x, y, z, w);
  }
  
  inline void glRasterPos4dv(const GLdouble * v)
  {
      return glbinding::Binding::RasterPos4dv(v);
  }
  
  inline void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  {
      return glbinding::Binding::RasterPos4f(x, y, z, w);
  }
  
  inline void glRasterPos4fv(const GLfloat * v)
  {
      return glbinding::Binding::RasterPos4fv(v);
  }
  
  inline void glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
  {
      return glbinding::Binding::RasterPos4i(x, y, z, w);
  }
  
  inline void glRasterPos4iv(const GLint * v)
  {
      return glbinding::Binding::RasterPos4iv(v);
  }
  
  inline void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
  {
      return glbinding::Binding::RasterPos4s(x, y, z, w);
  }
  
  inline void glRasterPos4sv(const GLshort * v)
  {
      return glbinding::Binding::RasterPos4sv(v);
  }
  
  inline void glReadBuffer(GLenum src)
  {
      return glbinding::Binding::ReadBuffer(src);
  }
  
  inline void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels)
  {
      return glbinding::Binding::ReadPixels(x, y, width, height, format, type, pixels);
  }
  
  inline void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
  {
      return glbinding::Binding::Rectd(x1, y1, x2, y2);
  }
  
  inline void glRectdv(const GLdouble * v1, const GLdouble * v2)
  {
      return glbinding::Binding::Rectdv(v1, v2);
  }
  
  inline void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
  {
      return glbinding::Binding::Rectf(x1, y1, x2, y2);
  }
  
  inline void glRectfv(const GLfloat * v1, const GLfloat * v2)
  {
      return glbinding::Binding::Rectfv(v1, v2);
  }
  
  inline void glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
  {
      return glbinding::Binding::Recti(x1, y1, x2, y2);
  }
  
  inline void glRectiv(const GLint * v1, const GLint * v2)
  {
      return glbinding::Binding::Rectiv(v1, v2);
  }
  
  inline void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
  {
      return glbinding::Binding::Rects(x1, y1, x2, y2);
  }
  
  inline void glRectsv(const GLshort * v1, const GLshort * v2)
  {
      return glbinding::Binding::Rectsv(v1, v2);
  }
  
  inline void glReleaseShaderCompiler()
  {
      return glbinding::Binding::ReleaseShaderCompiler();
  }
  
  inline GLint glRenderMode(GLenum mode)
  {
      return glbinding::Binding::RenderMode(mode);
  }
  
  inline void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::RenderbufferStorage(target, internalformat, width, height);
  }
  
  inline void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::RenderbufferStorageMultisample(target, samples, internalformat, width, height);
  }
  
  inline void glResumeTransformFeedback()
  {
      return glbinding::Binding::ResumeTransformFeedback();
  }
  
  inline void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::Rotated(angle, x, y, z);
  }
  
  inline void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::Rotatef(angle, x, y, z);
  }
  
  inline void glSampleCoverage(GLfloat value, GLboolean invert)
  {
      return glbinding::Binding::SampleCoverage(value, invert);
  }
  
  inline void glSampleMaski(GLuint maskNumber, GLbitfield mask)
  {
      return glbinding::Binding::SampleMaski(maskNumber, mask);
  }
  
  inline void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint * param)
  {
      return glbinding::Binding::SamplerParameterIiv(sampler, pname, param);
  }
  
  inline void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint * param)
  {
      return glbinding::Binding::SamplerParameterIuiv(sampler, pname, param);
  }
  
  inline void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::SamplerParameterf(sampler, pname, param);
  }
  
  inline void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * param)
  {
      return glbinding::Binding::SamplerParameterfv(sampler, pname, param);
  }
  
  inline void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
  {
      return glbinding::Binding::SamplerParameteri(sampler, pname, param);
  }
  
  inline void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * param)
  {
      return glbinding::Binding::SamplerParameteriv(sampler, pname, param);
  }
  
  inline void glScaled(GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::Scaled(x, y, z);
  }
  
  inline void glScalef(GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::Scalef(x, y, z);
  }
  
  inline void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::Scissor(x, y, width, height);
  }
  
  inline void glScissorArrayv(GLuint first, GLsizei count, const GLint * v)
  {
      return glbinding::Binding::ScissorArrayv(first, count, v);
  }
  
  inline void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::ScissorIndexed(index, left, bottom, width, height);
  }
  
  inline void glScissorIndexedv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::ScissorIndexedv(index, v);
  }
  
  inline void glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
  {
      return glbinding::Binding::SecondaryColor3b(red, green, blue);
  }
  
  inline void glSecondaryColor3bv(const GLbyte * v)
  {
      return glbinding::Binding::SecondaryColor3bv(v);
  }
  
  inline void glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
  {
      return glbinding::Binding::SecondaryColor3d(red, green, blue);
  }
  
  inline void glSecondaryColor3dv(const GLdouble * v)
  {
      return glbinding::Binding::SecondaryColor3dv(v);
  }
  
  inline void glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
  {
      return glbinding::Binding::SecondaryColor3f(red, green, blue);
  }
  
  inline void glSecondaryColor3fv(const GLfloat * v)
  {
      return glbinding::Binding::SecondaryColor3fv(v);
  }
  
  inline void glSecondaryColor3i(GLint red, GLint green, GLint blue)
  {
      return glbinding::Binding::SecondaryColor3i(red, green, blue);
  }
  
  inline void glSecondaryColor3iv(const GLint * v)
  {
      return glbinding::Binding::SecondaryColor3iv(v);
  }
  
  inline void glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
  {
      return glbinding::Binding::SecondaryColor3s(red, green, blue);
  }
  
  inline void glSecondaryColor3sv(const GLshort * v)
  {
      return glbinding::Binding::SecondaryColor3sv(v);
  }
  
  inline void glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
  {
      return glbinding::Binding::SecondaryColor3ub(red, green, blue);
  }
  
  inline void glSecondaryColor3ubv(const GLubyte * v)
  {
      return glbinding::Binding::SecondaryColor3ubv(v);
  }
  
  inline void glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
  {
      return glbinding::Binding::SecondaryColor3ui(red, green, blue);
  }
  
  inline void glSecondaryColor3uiv(const GLuint * v)
  {
      return glbinding::Binding::SecondaryColor3uiv(v);
  }
  
  inline void glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
  {
      return glbinding::Binding::SecondaryColor3us(red, green, blue);
  }
  
  inline void glSecondaryColor3usv(const GLushort * v)
  {
      return glbinding::Binding::SecondaryColor3usv(v);
  }
  
  inline void glSecondaryColorP3ui(GLenum type, GLuint color)
  {
      return glbinding::Binding::SecondaryColorP3ui(type, color);
  }
  
  inline void glSecondaryColorP3uiv(GLenum type, const GLuint * color)
  {
      return glbinding::Binding::SecondaryColorP3uiv(type, color);
  }
  
  inline void glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::SecondaryColorPointer(size, type, stride, pointer);
  }
  
  inline void glSelectBuffer(GLsizei size, GLuint * buffer)
  {
      return glbinding::Binding::SelectBuffer(size, buffer);
  }
  
  inline void glShadeModel(GLenum mode)
  {
      return glbinding::Binding::ShadeModel(mode);
  }
  
  inline void glShaderBinary(GLsizei count, const GLuint * shaders, GLenum binaryformat, const void * binary, GLsizei length)
  {
      return glbinding::Binding::ShaderBinary(count, shaders, binaryformat, binary, length);
  }
  
  inline void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length)
  {
      return glbinding::Binding::ShaderSource(shader, count, string, length);
  }
  
  inline void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
  {
      return glbinding::Binding::ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
  }
  
  inline void glStencilFunc(GLenum func, GLint ref, GLuint mask)
  {
      return glbinding::Binding::StencilFunc(func, ref, mask);
  }
  
  inline void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
  {
      return glbinding::Binding::StencilFuncSeparate(face, func, ref, mask);
  }
  
  inline void glStencilMask(GLuint mask)
  {
      return glbinding::Binding::StencilMask(mask);
  }
  
  inline void glStencilMaskSeparate(GLenum face, GLuint mask)
  {
      return glbinding::Binding::StencilMaskSeparate(face, mask);
  }
  
  inline void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
  {
      return glbinding::Binding::StencilOp(fail, zfail, zpass);
  }
  
  inline void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
  {
      return glbinding::Binding::StencilOpSeparate(face, sfail, dpfail, dppass);
  }
  
  inline void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
  {
      return glbinding::Binding::TexBuffer(target, internalformat, buffer);
  }
  
  inline void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
  {
      return glbinding::Binding::TexBufferRange(target, internalformat, buffer, offset, size);
  }
  
  inline void glTexCoord1d(GLdouble s)
  {
      return glbinding::Binding::TexCoord1d(s);
  }
  
  inline void glTexCoord1dv(const GLdouble * v)
  {
      return glbinding::Binding::TexCoord1dv(v);
  }
  
  inline void glTexCoord1f(GLfloat s)
  {
      return glbinding::Binding::TexCoord1f(s);
  }
  
  inline void glTexCoord1fv(const GLfloat * v)
  {
      return glbinding::Binding::TexCoord1fv(v);
  }
  
  inline void glTexCoord1i(GLint s)
  {
      return glbinding::Binding::TexCoord1i(s);
  }
  
  inline void glTexCoord1iv(const GLint * v)
  {
      return glbinding::Binding::TexCoord1iv(v);
  }
  
  inline void glTexCoord1s(GLshort s)
  {
      return glbinding::Binding::TexCoord1s(s);
  }
  
  inline void glTexCoord1sv(const GLshort * v)
  {
      return glbinding::Binding::TexCoord1sv(v);
  }
  
  inline void glTexCoord2d(GLdouble s, GLdouble t)
  {
      return glbinding::Binding::TexCoord2d(s, t);
  }
  
  inline void glTexCoord2dv(const GLdouble * v)
  {
      return glbinding::Binding::TexCoord2dv(v);
  }
  
  inline void glTexCoord2f(GLfloat s, GLfloat t)
  {
      return glbinding::Binding::TexCoord2f(s, t);
  }
  
  inline void glTexCoord2fv(const GLfloat * v)
  {
      return glbinding::Binding::TexCoord2fv(v);
  }
  
  inline void glTexCoord2i(GLint s, GLint t)
  {
      return glbinding::Binding::TexCoord2i(s, t);
  }
  
  inline void glTexCoord2iv(const GLint * v)
  {
      return glbinding::Binding::TexCoord2iv(v);
  }
  
  inline void glTexCoord2s(GLshort s, GLshort t)
  {
      return glbinding::Binding::TexCoord2s(s, t);
  }
  
  inline void glTexCoord2sv(const GLshort * v)
  {
      return glbinding::Binding::TexCoord2sv(v);
  }
  
  inline void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
  {
      return glbinding::Binding::TexCoord3d(s, t, r);
  }
  
  inline void glTexCoord3dv(const GLdouble * v)
  {
      return glbinding::Binding::TexCoord3dv(v);
  }
  
  inline void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
  {
      return glbinding::Binding::TexCoord3f(s, t, r);
  }
  
  inline void glTexCoord3fv(const GLfloat * v)
  {
      return glbinding::Binding::TexCoord3fv(v);
  }
  
  inline void glTexCoord3i(GLint s, GLint t, GLint r)
  {
      return glbinding::Binding::TexCoord3i(s, t, r);
  }
  
  inline void glTexCoord3iv(const GLint * v)
  {
      return glbinding::Binding::TexCoord3iv(v);
  }
  
  inline void glTexCoord3s(GLshort s, GLshort t, GLshort r)
  {
      return glbinding::Binding::TexCoord3s(s, t, r);
  }
  
  inline void glTexCoord3sv(const GLshort * v)
  {
      return glbinding::Binding::TexCoord3sv(v);
  }
  
  inline void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
  {
      return glbinding::Binding::TexCoord4d(s, t, r, q);
  }
  
  inline void glTexCoord4dv(const GLdouble * v)
  {
      return glbinding::Binding::TexCoord4dv(v);
  }
  
  inline void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
  {
      return glbinding::Binding::TexCoord4f(s, t, r, q);
  }
  
  inline void glTexCoord4fv(const GLfloat * v)
  {
      return glbinding::Binding::TexCoord4fv(v);
  }
  
  inline void glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
  {
      return glbinding::Binding::TexCoord4i(s, t, r, q);
  }
  
  inline void glTexCoord4iv(const GLint * v)
  {
      return glbinding::Binding::TexCoord4iv(v);
  }
  
  inline void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
  {
      return glbinding::Binding::TexCoord4s(s, t, r, q);
  }
  
  inline void glTexCoord4sv(const GLshort * v)
  {
      return glbinding::Binding::TexCoord4sv(v);
  }
  
  inline void glTexCoordP1ui(GLenum type, GLuint coords)
  {
      return glbinding::Binding::TexCoordP1ui(type, coords);
  }
  
  inline void glTexCoordP1uiv(GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::TexCoordP1uiv(type, coords);
  }
  
  inline void glTexCoordP2ui(GLenum type, GLuint coords)
  {
      return glbinding::Binding::TexCoordP2ui(type, coords);
  }
  
  inline void glTexCoordP2uiv(GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::TexCoordP2uiv(type, coords);
  }
  
  inline void glTexCoordP3ui(GLenum type, GLuint coords)
  {
      return glbinding::Binding::TexCoordP3ui(type, coords);
  }
  
  inline void glTexCoordP3uiv(GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::TexCoordP3uiv(type, coords);
  }
  
  inline void glTexCoordP4ui(GLenum type, GLuint coords)
  {
      return glbinding::Binding::TexCoordP4ui(type, coords);
  }
  
  inline void glTexCoordP4uiv(GLenum type, const GLuint * coords)
  {
      return glbinding::Binding::TexCoordP4uiv(type, coords);
  }
  
  inline void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::TexCoordPointer(size, type, stride, pointer);
  }
  
  inline void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::TexEnvf(target, pname, param);
  }
  
  inline void glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::TexEnvfv(target, pname, params);
  }
  
  inline void glTexEnvi(GLenum target, GLenum pname, GLint param)
  {
      return glbinding::Binding::TexEnvi(target, pname, param);
  }
  
  inline void glTexEnviv(GLenum target, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::TexEnviv(target, pname, params);
  }
  
  inline void glTexGend(GLenum coord, GLenum pname, GLdouble param)
  {
      return glbinding::Binding::TexGend(coord, pname, param);
  }
  
  inline void glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
  {
      return glbinding::Binding::TexGendv(coord, pname, params);
  }
  
  inline void glTexGenf(GLenum coord, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::TexGenf(coord, pname, param);
  }
  
  inline void glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::TexGenfv(coord, pname, params);
  }
  
  inline void glTexGeni(GLenum coord, GLenum pname, GLint param)
  {
      return glbinding::Binding::TexGeni(coord, pname, param);
  }
  
  inline void glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::TexGeniv(coord, pname, params);
  }
  
  inline void glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::TexImage1D(target, level, internalformat, width, border, format, type, pixels);
  }
  
  inline void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
  }
  
  inline void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
  {
      return glbinding::Binding::TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
  }
  
  inline void glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
  }
  
  inline void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
  {
      return glbinding::Binding::TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
  }
  
  inline void glTexParameterIiv(GLenum target, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::TexParameterIiv(target, pname, params);
  }
  
  inline void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint * params)
  {
      return glbinding::Binding::TexParameterIuiv(target, pname, params);
  }
  
  inline void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
  {
      return glbinding::Binding::TexParameterf(target, pname, param);
  }
  
  inline void glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
  {
      return glbinding::Binding::TexParameterfv(target, pname, params);
  }
  
  inline void glTexParameteri(GLenum target, GLenum pname, GLint param)
  {
      return glbinding::Binding::TexParameteri(target, pname, param);
  }
  
  inline void glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
  {
      return glbinding::Binding::TexParameteriv(target, pname, params);
  }
  
  inline void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
  {
      return glbinding::Binding::TexStorage1D(target, levels, internalformat, width);
  }
  
  inline void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::TexStorage2D(target, levels, internalformat, width, height);
  }
  
  inline void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
  {
      return glbinding::Binding::TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
  }
  
  inline void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
  {
      return glbinding::Binding::TexStorage3D(target, levels, internalformat, width, height, depth);
  }
  
  inline void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
  {
      return glbinding::Binding::TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
  }
  
  inline void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::TexSubImage1D(target, level, xoffset, width, format, type, pixels);
  }
  
  inline void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
  {
      return glbinding::Binding::TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
  }
  
  inline void 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 glbinding::Binding::TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
  }
  
  inline void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
  {
      return glbinding::Binding::TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
  }
  
  inline void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode)
  {
      return glbinding::Binding::TransformFeedbackVaryings(program, count, varyings, bufferMode);
  }
  
  inline void glTranslated(GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::Translated(x, y, z);
  }
  
  inline void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::Translatef(x, y, z);
  }
  
  inline void glUniform1d(GLint location, GLdouble x)
  {
      return glbinding::Binding::Uniform1d(location, x);
  }
  
  inline void glUniform1dv(GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::Uniform1dv(location, count, value);
  }
  
  inline void glUniform1f(GLint location, GLfloat v0)
  {
      return glbinding::Binding::Uniform1f(location, v0);
  }
  
  inline void glUniform1fv(GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::Uniform1fv(location, count, value);
  }
  
  inline void glUniform1i(GLint location, GLint v0)
  {
      return glbinding::Binding::Uniform1i(location, v0);
  }
  
  inline void glUniform1iv(GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::Uniform1iv(location, count, value);
  }
  
  inline void glUniform1ui(GLint location, GLuint v0)
  {
      return glbinding::Binding::Uniform1ui(location, v0);
  }
  
  inline void glUniform1uiv(GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::Uniform1uiv(location, count, value);
  }
  
  inline void glUniform2d(GLint location, GLdouble x, GLdouble y)
  {
      return glbinding::Binding::Uniform2d(location, x, y);
  }
  
  inline void glUniform2dv(GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::Uniform2dv(location, count, value);
  }
  
  inline void glUniform2f(GLint location, GLfloat v0, GLfloat v1)
  {
      return glbinding::Binding::Uniform2f(location, v0, v1);
  }
  
  inline void glUniform2fv(GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::Uniform2fv(location, count, value);
  }
  
  inline void glUniform2i(GLint location, GLint v0, GLint v1)
  {
      return glbinding::Binding::Uniform2i(location, v0, v1);
  }
  
  inline void glUniform2iv(GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::Uniform2iv(location, count, value);
  }
  
  inline void glUniform2ui(GLint location, GLuint v0, GLuint v1)
  {
      return glbinding::Binding::Uniform2ui(location, v0, v1);
  }
  
  inline void glUniform2uiv(GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::Uniform2uiv(location, count, value);
  }
  
  inline void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::Uniform3d(location, x, y, z);
  }
  
  inline void glUniform3dv(GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::Uniform3dv(location, count, value);
  }
  
  inline void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
  {
      return glbinding::Binding::Uniform3f(location, v0, v1, v2);
  }
  
  inline void glUniform3fv(GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::Uniform3fv(location, count, value);
  }
  
  inline void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
  {
      return glbinding::Binding::Uniform3i(location, v0, v1, v2);
  }
  
  inline void glUniform3iv(GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::Uniform3iv(location, count, value);
  }
  
  inline void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
  {
      return glbinding::Binding::Uniform3ui(location, v0, v1, v2);
  }
  
  inline void glUniform3uiv(GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::Uniform3uiv(location, count, value);
  }
  
  inline void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      return glbinding::Binding::Uniform4d(location, x, y, z, w);
  }
  
  inline void glUniform4dv(GLint location, GLsizei count, const GLdouble * value)
  {
      return glbinding::Binding::Uniform4dv(location, count, value);
  }
  
  inline void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
  {
      return glbinding::Binding::Uniform4f(location, v0, v1, v2, v3);
  }
  
  inline void glUniform4fv(GLint location, GLsizei count, const GLfloat * value)
  {
      return glbinding::Binding::Uniform4fv(location, count, value);
  }
  
  inline void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
  {
      return glbinding::Binding::Uniform4i(location, v0, v1, v2, v3);
  }
  
  inline void glUniform4iv(GLint location, GLsizei count, const GLint * value)
  {
      return glbinding::Binding::Uniform4iv(location, count, value);
  }
  
  inline void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
  {
      return glbinding::Binding::Uniform4ui(location, v0, v1, v2, v3);
  }
  
  inline void glUniform4uiv(GLint location, GLsizei count, const GLuint * value)
  {
      return glbinding::Binding::Uniform4uiv(location, count, value);
  }
  
  inline void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
  {
      return glbinding::Binding::UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
  }
  
  inline void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix2dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix2fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix2x3dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix2x3fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix2x4dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix2x4fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix3dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix3fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix3x2dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix3x2fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix3x4dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix3x4fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix4dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix4fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix4x2dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix4x2fv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
  {
      return glbinding::Binding::UniformMatrix4x3dv(location, count, transpose, value);
  }
  
  inline void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
  {
      return glbinding::Binding::UniformMatrix4x3fv(location, count, transpose, value);
  }
  
  inline void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint * indices)
  {
      return glbinding::Binding::UniformSubroutinesuiv(shadertype, count, indices);
  }
  
  inline GLboolean glUnmapBuffer(GLenum target)
  {
      return glbinding::Binding::UnmapBuffer(target);
  }
  
  inline void glUseProgram(GLuint program)
  {
      return glbinding::Binding::UseProgram(program);
  }
  
  inline void glUseProgramStages(GLuint pipeline, UseProgramStageMask stages, GLuint program)
  {
      return glbinding::Binding::UseProgramStages(pipeline, stages, program);
  }
  
  inline void glValidateProgram(GLuint program)
  {
      return glbinding::Binding::ValidateProgram(program);
  }
  
  inline void glValidateProgramPipeline(GLuint pipeline)
  {
      return glbinding::Binding::ValidateProgramPipeline(pipeline);
  }
  
  inline void glVertex2d(GLdouble x, GLdouble y)
  {
      return glbinding::Binding::Vertex2d(x, y);
  }
  
  inline void glVertex2dv(const GLdouble * v)
  {
      return glbinding::Binding::Vertex2dv(v);
  }
  
  inline void glVertex2f(GLfloat x, GLfloat y)
  {
      return glbinding::Binding::Vertex2f(x, y);
  }
  
  inline void glVertex2fv(const GLfloat * v)
  {
      return glbinding::Binding::Vertex2fv(v);
  }
  
  inline void glVertex2i(GLint x, GLint y)
  {
      return glbinding::Binding::Vertex2i(x, y);
  }
  
  inline void glVertex2iv(const GLint * v)
  {
      return glbinding::Binding::Vertex2iv(v);
  }
  
  inline void glVertex2s(GLshort x, GLshort y)
  {
      return glbinding::Binding::Vertex2s(x, y);
  }
  
  inline void glVertex2sv(const GLshort * v)
  {
      return glbinding::Binding::Vertex2sv(v);
  }
  
  inline void glVertex3d(GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::Vertex3d(x, y, z);
  }
  
  inline void glVertex3dv(const GLdouble * v)
  {
      return glbinding::Binding::Vertex3dv(v);
  }
  
  inline void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::Vertex3f(x, y, z);
  }
  
  inline void glVertex3fv(const GLfloat * v)
  {
      return glbinding::Binding::Vertex3fv(v);
  }
  
  inline void glVertex3i(GLint x, GLint y, GLint z)
  {
      return glbinding::Binding::Vertex3i(x, y, z);
  }
  
  inline void glVertex3iv(const GLint * v)
  {
      return glbinding::Binding::Vertex3iv(v);
  }
  
  inline void glVertex3s(GLshort x, GLshort y, GLshort z)
  {
      return glbinding::Binding::Vertex3s(x, y, z);
  }
  
  inline void glVertex3sv(const GLshort * v)
  {
      return glbinding::Binding::Vertex3sv(v);
  }
  
  inline void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      return glbinding::Binding::Vertex4d(x, y, z, w);
  }
  
  inline void glVertex4dv(const GLdouble * v)
  {
      return glbinding::Binding::Vertex4dv(v);
  }
  
  inline void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  {
      return glbinding::Binding::Vertex4f(x, y, z, w);
  }
  
  inline void glVertex4fv(const GLfloat * v)
  {
      return glbinding::Binding::Vertex4fv(v);
  }
  
  inline void glVertex4i(GLint x, GLint y, GLint z, GLint w)
  {
      return glbinding::Binding::Vertex4i(x, y, z, w);
  }
  
  inline void glVertex4iv(const GLint * v)
  {
      return glbinding::Binding::Vertex4iv(v);
  }
  
  inline void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
  {
      return glbinding::Binding::Vertex4s(x, y, z, w);
  }
  
  inline void glVertex4sv(const GLshort * v)
  {
      return glbinding::Binding::Vertex4sv(v);
  }
  
  inline void glVertexAttrib1d(GLuint index, GLdouble x)
  {
      return glbinding::Binding::VertexAttrib1d(index, x);
  }
  
  inline void glVertexAttrib1dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttrib1dv(index, v);
  }
  
  inline void glVertexAttrib1f(GLuint index, GLfloat x)
  {
      return glbinding::Binding::VertexAttrib1f(index, x);
  }
  
  inline void glVertexAttrib1fv(GLuint index, const GLfloat * v)
  {
      return glbinding::Binding::VertexAttrib1fv(index, v);
  }
  
  inline void glVertexAttrib1s(GLuint index, GLshort x)
  {
      return glbinding::Binding::VertexAttrib1s(index, x);
  }
  
  inline void glVertexAttrib1sv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttrib1sv(index, v);
  }
  
  inline void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
  {
      return glbinding::Binding::VertexAttrib2d(index, x, y);
  }
  
  inline void glVertexAttrib2dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttrib2dv(index, v);
  }
  
  inline void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
  {
      return glbinding::Binding::VertexAttrib2f(index, x, y);
  }
  
  inline void glVertexAttrib2fv(GLuint index, const GLfloat * v)
  {
      return glbinding::Binding::VertexAttrib2fv(index, v);
  }
  
  inline void glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
  {
      return glbinding::Binding::VertexAttrib2s(index, x, y);
  }
  
  inline void glVertexAttrib2sv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttrib2sv(index, v);
  }
  
  inline void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::VertexAttrib3d(index, x, y, z);
  }
  
  inline void glVertexAttrib3dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttrib3dv(index, v);
  }
  
  inline void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::VertexAttrib3f(index, x, y, z);
  }
  
  inline void glVertexAttrib3fv(GLuint index, const GLfloat * v)
  {
      return glbinding::Binding::VertexAttrib3fv(index, v);
  }
  
  inline void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
  {
      return glbinding::Binding::VertexAttrib3s(index, x, y, z);
  }
  
  inline void glVertexAttrib3sv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttrib3sv(index, v);
  }
  
  inline void glVertexAttrib4Nbv(GLuint index, const GLbyte * v)
  {
      return glbinding::Binding::VertexAttrib4Nbv(index, v);
  }
  
  inline void glVertexAttrib4Niv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttrib4Niv(index, v);
  }
  
  inline void glVertexAttrib4Nsv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttrib4Nsv(index, v);
  }
  
  inline void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
  {
      return glbinding::Binding::VertexAttrib4Nub(index, x, y, z, w);
  }
  
  inline void glVertexAttrib4Nubv(GLuint index, const GLubyte * v)
  {
      return glbinding::Binding::VertexAttrib4Nubv(index, v);
  }
  
  inline void glVertexAttrib4Nuiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttrib4Nuiv(index, v);
  }
  
  inline void glVertexAttrib4Nusv(GLuint index, const GLushort * v)
  {
      return glbinding::Binding::VertexAttrib4Nusv(index, v);
  }
  
  inline void glVertexAttrib4bv(GLuint index, const GLbyte * v)
  {
      return glbinding::Binding::VertexAttrib4bv(index, v);
  }
  
  inline void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      return glbinding::Binding::VertexAttrib4d(index, x, y, z, w);
  }
  
  inline void glVertexAttrib4dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttrib4dv(index, v);
  }
  
  inline void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  {
      return glbinding::Binding::VertexAttrib4f(index, x, y, z, w);
  }
  
  inline void glVertexAttrib4fv(GLuint index, const GLfloat * v)
  {
      return glbinding::Binding::VertexAttrib4fv(index, v);
  }
  
  inline void glVertexAttrib4iv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttrib4iv(index, v);
  }
  
  inline void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
  {
      return glbinding::Binding::VertexAttrib4s(index, x, y, z, w);
  }
  
  inline void glVertexAttrib4sv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttrib4sv(index, v);
  }
  
  inline void glVertexAttrib4ubv(GLuint index, const GLubyte * v)
  {
      return glbinding::Binding::VertexAttrib4ubv(index, v);
  }
  
  inline void glVertexAttrib4uiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttrib4uiv(index, v);
  }
  
  inline void glVertexAttrib4usv(GLuint index, const GLushort * v)
  {
      return glbinding::Binding::VertexAttrib4usv(index, v);
  }
  
  inline void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
  {
      return glbinding::Binding::VertexAttribBinding(attribindex, bindingindex);
  }
  
  inline void glVertexAttribDivisor(GLuint index, GLuint divisor)
  {
      return glbinding::Binding::VertexAttribDivisor(index, divisor);
  }
  
  inline void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
  {
      return glbinding::Binding::VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
  }
  
  inline void glVertexAttribI1i(GLuint index, GLint x)
  {
      return glbinding::Binding::VertexAttribI1i(index, x);
  }
  
  inline void glVertexAttribI1iv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttribI1iv(index, v);
  }
  
  inline void glVertexAttribI1ui(GLuint index, GLuint x)
  {
      return glbinding::Binding::VertexAttribI1ui(index, x);
  }
  
  inline void glVertexAttribI1uiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttribI1uiv(index, v);
  }
  
  inline void glVertexAttribI2i(GLuint index, GLint x, GLint y)
  {
      return glbinding::Binding::VertexAttribI2i(index, x, y);
  }
  
  inline void glVertexAttribI2iv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttribI2iv(index, v);
  }
  
  inline void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
  {
      return glbinding::Binding::VertexAttribI2ui(index, x, y);
  }
  
  inline void glVertexAttribI2uiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttribI2uiv(index, v);
  }
  
  inline void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
  {
      return glbinding::Binding::VertexAttribI3i(index, x, y, z);
  }
  
  inline void glVertexAttribI3iv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttribI3iv(index, v);
  }
  
  inline void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
  {
      return glbinding::Binding::VertexAttribI3ui(index, x, y, z);
  }
  
  inline void glVertexAttribI3uiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttribI3uiv(index, v);
  }
  
  inline void glVertexAttribI4bv(GLuint index, const GLbyte * v)
  {
      return glbinding::Binding::VertexAttribI4bv(index, v);
  }
  
  inline void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
  {
      return glbinding::Binding::VertexAttribI4i(index, x, y, z, w);
  }
  
  inline void glVertexAttribI4iv(GLuint index, const GLint * v)
  {
      return glbinding::Binding::VertexAttribI4iv(index, v);
  }
  
  inline void glVertexAttribI4sv(GLuint index, const GLshort * v)
  {
      return glbinding::Binding::VertexAttribI4sv(index, v);
  }
  
  inline void glVertexAttribI4ubv(GLuint index, const GLubyte * v)
  {
      return glbinding::Binding::VertexAttribI4ubv(index, v);
  }
  
  inline void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
  {
      return glbinding::Binding::VertexAttribI4ui(index, x, y, z, w);
  }
  
  inline void glVertexAttribI4uiv(GLuint index, const GLuint * v)
  {
      return glbinding::Binding::VertexAttribI4uiv(index, v);
  }
  
  inline void glVertexAttribI4usv(GLuint index, const GLushort * v)
  {
      return glbinding::Binding::VertexAttribI4usv(index, v);
  }
  
  inline void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
  {
      return glbinding::Binding::VertexAttribIFormat(attribindex, size, type, relativeoffset);
  }
  
  inline void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::VertexAttribIPointer(index, size, type, stride, pointer);
  }
  
  inline void glVertexAttribL1d(GLuint index, GLdouble x)
  {
      return glbinding::Binding::VertexAttribL1d(index, x);
  }
  
  inline void glVertexAttribL1dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttribL1dv(index, v);
  }
  
  inline void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
  {
      return glbinding::Binding::VertexAttribL2d(index, x, y);
  }
  
  inline void glVertexAttribL2dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttribL2dv(index, v);
  }
  
  inline void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::VertexAttribL3d(index, x, y, z);
  }
  
  inline void glVertexAttribL3dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttribL3dv(index, v);
  }
  
  inline void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
      return glbinding::Binding::VertexAttribL4d(index, x, y, z, w);
  }
  
  inline void glVertexAttribL4dv(GLuint index, const GLdouble * v)
  {
      return glbinding::Binding::VertexAttribL4dv(index, v);
  }
  
  inline void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
  {
      return glbinding::Binding::VertexAttribLFormat(attribindex, size, type, relativeoffset);
  }
  
  inline void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::VertexAttribLPointer(index, size, type, stride, pointer);
  }
  
  inline void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      return glbinding::Binding::VertexAttribP1ui(index, type, normalized, value);
  }
  
  inline void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
  {
      return glbinding::Binding::VertexAttribP1uiv(index, type, normalized, value);
  }
  
  inline void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      return glbinding::Binding::VertexAttribP2ui(index, type, normalized, value);
  }
  
  inline void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
  {
      return glbinding::Binding::VertexAttribP2uiv(index, type, normalized, value);
  }
  
  inline void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      return glbinding::Binding::VertexAttribP3ui(index, type, normalized, value);
  }
  
  inline void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
  {
      return glbinding::Binding::VertexAttribP3uiv(index, type, normalized, value);
  }
  
  inline void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      return glbinding::Binding::VertexAttribP4ui(index, type, normalized, value);
  }
  
  inline void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
  {
      return glbinding::Binding::VertexAttribP4uiv(index, type, normalized, value);
  }
  
  inline void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::VertexAttribPointer(index, size, type, normalized, stride, pointer);
  }
  
  inline void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
  {
      return glbinding::Binding::VertexBindingDivisor(bindingindex, divisor);
  }
  
  inline void glVertexP2ui(GLenum type, GLuint value)
  {
      return glbinding::Binding::VertexP2ui(type, value);
  }
  
  inline void glVertexP2uiv(GLenum type, const GLuint * value)
  {
      return glbinding::Binding::VertexP2uiv(type, value);
  }
  
  inline void glVertexP3ui(GLenum type, GLuint value)
  {
      return glbinding::Binding::VertexP3ui(type, value);
  }
  
  inline void glVertexP3uiv(GLenum type, const GLuint * value)
  {
      return glbinding::Binding::VertexP3uiv(type, value);
  }
  
  inline void glVertexP4ui(GLenum type, GLuint value)
  {
      return glbinding::Binding::VertexP4ui(type, value);
  }
  
  inline void glVertexP4uiv(GLenum type, const GLuint * value)
  {
      return glbinding::Binding::VertexP4uiv(type, value);
  }
  
  inline void glVertexPointer(GLint size, GLenum type, GLsizei stride, const void * pointer)
  {
      return glbinding::Binding::VertexPointer(size, type, stride, pointer);
  }
  
  inline void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
  {
      return glbinding::Binding::Viewport(x, y, width, height);
  }
  
  inline void glViewportArrayv(GLuint first, GLsizei count, const GLfloat * v)
  {
      return glbinding::Binding::ViewportArrayv(first, count, v);
  }
  
  inline void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
  {
      return glbinding::Binding::ViewportIndexedf(index, x, y, w, h);
  }
  
  inline void glViewportIndexedfv(GLuint index, const GLfloat * v)
  {
      return glbinding::Binding::ViewportIndexedfv(index, v);
  }
  
  inline void glWaitSync(GLsync sync, UnusedMask flags, GLuint64 timeout)
  {
      return glbinding::Binding::WaitSync(sync, flags, timeout);
  }
  
  inline void glWindowPos2d(GLdouble x, GLdouble y)
  {
      return glbinding::Binding::WindowPos2d(x, y);
  }
  
  inline void glWindowPos2dv(const GLdouble * v)
  {
      return glbinding::Binding::WindowPos2dv(v);
  }
  
  inline void glWindowPos2f(GLfloat x, GLfloat y)
  {
      return glbinding::Binding::WindowPos2f(x, y);
  }
  
  inline void glWindowPos2fv(const GLfloat * v)
  {
      return glbinding::Binding::WindowPos2fv(v);
  }
  
  inline void glWindowPos2i(GLint x, GLint y)
  {
      return glbinding::Binding::WindowPos2i(x, y);
  }
  
  inline void glWindowPos2iv(const GLint * v)
  {
      return glbinding::Binding::WindowPos2iv(v);
  }
  
  inline void glWindowPos2s(GLshort x, GLshort y)
  {
      return glbinding::Binding::WindowPos2s(x, y);
  }
  
  inline void glWindowPos2sv(const GLshort * v)
  {
      return glbinding::Binding::WindowPos2sv(v);
  }
  
  inline void glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
  {
      return glbinding::Binding::WindowPos3d(x, y, z);
  }
  
  inline void glWindowPos3dv(const GLdouble * v)
  {
      return glbinding::Binding::WindowPos3dv(v);
  }
  
  inline void glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
  {
      return glbinding::Binding::WindowPos3f(x, y, z);
  }
  
  inline void glWindowPos3fv(const GLfloat * v)
  {
      return glbinding::Binding::WindowPos3fv(v);
  }
  
  inline void glWindowPos3i(GLint x, GLint y, GLint z)
  {
      return glbinding::Binding::WindowPos3i(x, y, z);
  }
  
  inline void glWindowPos3iv(const GLint * v)
  {
      return glbinding::Binding::WindowPos3iv(v);
  }
  
  inline void glWindowPos3s(GLshort x, GLshort y, GLshort z)
  {
      return glbinding::Binding::WindowPos3s(x, y, z);
  }
  
  inline void glWindowPos3sv(const GLshort * v)
  {
      return glbinding::Binding::WindowPos3sv(v);
  }
  
  
  } // namespace gl43
  