/* Automatically generated from /usr/share/opengl/api/gl.xml - DO NOT EDIT */

void glCullFaceWrapper(GLenum mode_)
{
  glCullFace( mode_ );
}

void glFrontFaceWrapper(GLenum mode_)
{
  glFrontFace( mode_ );
}

void glHintWrapper(GLenum target_, GLenum mode_)
{
  glHint( target_, mode_ );
}

void glLineWidthWrapper(GLfloat width_)
{
  glLineWidth( width_ );
}

void glPointSizeWrapper(GLfloat size_)
{
  glPointSize( size_ );
}

void glPolygonModeWrapper(GLenum face_, GLenum mode_)
{
  glPolygonMode( face_, mode_ );
}

void glScissorWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  glScissor( x_, y_, width_, height_ );
}

void glTexParameterfWrapper(GLenum target_, GLenum pname_, GLfloat param_)
{
  glTexParameterf( target_, pname_, param_ );
}

void glTexParameterfvWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  glTexParameterfv( target_, pname_, params_ );
}

void glTexParameteriWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  glTexParameteri( target_, pname_, param_ );
}

void glTexParameterivWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  glTexParameteriv( target_, pname_, params_ );
}

void glTexImage1DWrapper(GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  glTexImage1D( target_, level_, internalformat_, width_, border_, format_, type_, pixels_ );
}

void glTexImage2DWrapper(GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  glTexImage2D( target_, level_, internalformat_, width_, height_, border_, format_, type_, pixels_ );
}

void glDrawBufferWrapper(GLenum buf_)
{
  glDrawBuffer( buf_ );
}

void glClearWrapper(GLbitfield mask_)
{
  glClear( mask_ );
}

void glClearColorWrapper(GLfloat red_, GLfloat green_, GLfloat blue_, GLfloat alpha_)
{
  glClearColor( red_, green_, blue_, alpha_ );
}

void glClearStencilWrapper(GLint s_)
{
  glClearStencil( s_ );
}

void glClearDepthWrapper(GLdouble depth_)
{
  glClearDepth( depth_ );
}

void glStencilMaskWrapper(GLuint mask_)
{
  glStencilMask( mask_ );
}

void glColorMaskWrapper(GLboolean red_, GLboolean green_, GLboolean blue_, GLboolean alpha_)
{
  glColorMask( red_, green_, blue_, alpha_ );
}

void glDepthMaskWrapper(GLboolean flag_)
{
  glDepthMask( flag_ );
}

void glDisableWrapper(GLenum cap_)
{
  glDisable( cap_ );
}

void glEnableWrapper(GLenum cap_)
{
  glEnable( cap_ );
}

void glFinishWrapper(void)
{
  glFinish(  );
}

void glFlushWrapper(void)
{
  glFlush(  );
}

void glBlendFuncWrapper(GLenum sfactor_, GLenum dfactor_)
{
  glBlendFunc( sfactor_, dfactor_ );
}

void glLogicOpWrapper(GLenum opcode_)
{
  glLogicOp( opcode_ );
}

void glStencilFuncWrapper(GLenum func_, GLint ref_, GLuint mask_)
{
  glStencilFunc( func_, ref_, mask_ );
}

void glStencilOpWrapper(GLenum fail_, GLenum zfail_, GLenum zpass_)
{
  glStencilOp( fail_, zfail_, zpass_ );
}

void glDepthFuncWrapper(GLenum func_)
{
  glDepthFunc( func_ );
}

void glPixelStorefWrapper(GLenum pname_, GLfloat param_)
{
  glPixelStoref( pname_, param_ );
}

void glPixelStoreiWrapper(GLenum pname_, GLint param_)
{
  glPixelStorei( pname_, param_ );
}

void glReadBufferWrapper(GLenum src_)
{
  glReadBuffer( src_ );
}

void glReadPixelsWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, void * pixels_)
{
  glReadPixels( x_, y_, width_, height_, format_, type_, pixels_ );
}

void glGetBooleanvWrapper(GLenum pname_, GLboolean* data_)
{
  glGetBooleanv( pname_, data_ );
}

void glGetDoublevWrapper(GLenum pname_, GLdouble* data_)
{
  glGetDoublev( pname_, data_ );
}

GLenum glGetErrorWrapper(void)
{
  return glGetError(  );
}

void glGetFloatvWrapper(GLenum pname_, GLfloat* data_)
{
  glGetFloatv( pname_, data_ );
}

void glGetIntegervWrapper(GLenum pname_, GLint* data_)
{
  glGetIntegerv( pname_, data_ );
}

const GLubyte * glGetStringWrapper(GLenum name_)
{
  return glGetString( name_ );
}

void glGetTexImageWrapper(GLenum target_, GLint level_, GLenum format_, GLenum type_, void * pixels_)
{
  glGetTexImage( target_, level_, format_, type_, pixels_ );
}

void glGetTexParameterfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  glGetTexParameterfv( target_, pname_, params_ );
}

void glGetTexParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  glGetTexParameteriv( target_, pname_, params_ );
}

void glGetTexLevelParameterfvWrapper(GLenum target_, GLint level_, GLenum pname_, GLfloat* params_)
{
  glGetTexLevelParameterfv( target_, level_, pname_, params_ );
}

void glGetTexLevelParameterivWrapper(GLenum target_, GLint level_, GLenum pname_, GLint* params_)
{
  glGetTexLevelParameteriv( target_, level_, pname_, params_ );
}

GLboolean glIsEnabledWrapper(GLenum cap_)
{
  return glIsEnabled( cap_ );
}

void glDepthRangeWrapper(GLdouble near_, GLdouble far_)
{
  glDepthRange( near_, far_ );
}

void glViewportWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  glViewport( x_, y_, width_, height_ );
}

void glNewListWrapper(GLuint list_, GLenum mode_)
{
  glNewList( list_, mode_ );
}

void glEndListWrapper(void)
{
  glEndList(  );
}

void glCallListWrapper(GLuint list_)
{
  glCallList( list_ );
}

void glCallListsWrapper(GLsizei n_, GLenum type_, const void * lists_)
{
  glCallLists( n_, type_, lists_ );
}

void glDeleteListsWrapper(GLuint list_, GLsizei range_)
{
  glDeleteLists( list_, range_ );
}

GLuint glGenListsWrapper(GLsizei range_)
{
  return glGenLists( range_ );
}

void glListBaseWrapper(GLuint base_)
{
  glListBase( base_ );
}

void glBeginWrapper(GLenum mode_)
{
  glBegin( mode_ );
}

void glBitmapWrapper(GLsizei width_, GLsizei height_, GLfloat xorig_, GLfloat yorig_, GLfloat xmove_, GLfloat ymove_, const GLubyte* bitmap_)
{
  glBitmap( width_, height_, xorig_, yorig_, xmove_, ymove_, bitmap_ );
}

void glColor3bWrapper(GLbyte red_, GLbyte green_, GLbyte blue_)
{
  glColor3b( red_, green_, blue_ );
}

void glColor3bvWrapper(const GLbyte* v_)
{
  glColor3bv( v_ );
}

void glColor3dWrapper(GLdouble red_, GLdouble green_, GLdouble blue_)
{
  glColor3d( red_, green_, blue_ );
}

void glColor3dvWrapper(const GLdouble* v_)
{
  glColor3dv( v_ );
}

void glColor3fWrapper(GLfloat red_, GLfloat green_, GLfloat blue_)
{
  glColor3f( red_, green_, blue_ );
}

void glColor3fvWrapper(const GLfloat* v_)
{
  glColor3fv( v_ );
}

void glColor3iWrapper(GLint red_, GLint green_, GLint blue_)
{
  glColor3i( red_, green_, blue_ );
}

void glColor3ivWrapper(const GLint* v_)
{
  glColor3iv( v_ );
}

void glColor3sWrapper(GLshort red_, GLshort green_, GLshort blue_)
{
  glColor3s( red_, green_, blue_ );
}

void glColor3svWrapper(const GLshort* v_)
{
  glColor3sv( v_ );
}

void glColor3ubWrapper(GLubyte red_, GLubyte green_, GLubyte blue_)
{
  glColor3ub( red_, green_, blue_ );
}

void glColor3ubvWrapper(const GLubyte* v_)
{
  glColor3ubv( v_ );
}

void glColor3uiWrapper(GLuint red_, GLuint green_, GLuint blue_)
{
  glColor3ui( red_, green_, blue_ );
}

void glColor3uivWrapper(const GLuint* v_)
{
  glColor3uiv( v_ );
}

void glColor3usWrapper(GLushort red_, GLushort green_, GLushort blue_)
{
  glColor3us( red_, green_, blue_ );
}

void glColor3usvWrapper(const GLushort* v_)
{
  glColor3usv( v_ );
}

void glColor4bWrapper(GLbyte red_, GLbyte green_, GLbyte blue_, GLbyte alpha_)
{
  glColor4b( red_, green_, blue_, alpha_ );
}

void glColor4bvWrapper(const GLbyte* v_)
{
  glColor4bv( v_ );
}

void glColor4dWrapper(GLdouble red_, GLdouble green_, GLdouble blue_, GLdouble alpha_)
{
  glColor4d( red_, green_, blue_, alpha_ );
}

void glColor4dvWrapper(const GLdouble* v_)
{
  glColor4dv( v_ );
}

void glColor4fWrapper(GLfloat red_, GLfloat green_, GLfloat blue_, GLfloat alpha_)
{
  glColor4f( red_, green_, blue_, alpha_ );
}

void glColor4fvWrapper(const GLfloat* v_)
{
  glColor4fv( v_ );
}

void glColor4iWrapper(GLint red_, GLint green_, GLint blue_, GLint alpha_)
{
  glColor4i( red_, green_, blue_, alpha_ );
}

void glColor4ivWrapper(const GLint* v_)
{
  glColor4iv( v_ );
}

void glColor4sWrapper(GLshort red_, GLshort green_, GLshort blue_, GLshort alpha_)
{
  glColor4s( red_, green_, blue_, alpha_ );
}

void glColor4svWrapper(const GLshort* v_)
{
  glColor4sv( v_ );
}

void glColor4ubWrapper(GLubyte red_, GLubyte green_, GLubyte blue_, GLubyte alpha_)
{
  glColor4ub( red_, green_, blue_, alpha_ );
}

void glColor4ubvWrapper(const GLubyte* v_)
{
  glColor4ubv( v_ );
}

void glColor4uiWrapper(GLuint red_, GLuint green_, GLuint blue_, GLuint alpha_)
{
  glColor4ui( red_, green_, blue_, alpha_ );
}

void glColor4uivWrapper(const GLuint* v_)
{
  glColor4uiv( v_ );
}

void glColor4usWrapper(GLushort red_, GLushort green_, GLushort blue_, GLushort alpha_)
{
  glColor4us( red_, green_, blue_, alpha_ );
}

void glColor4usvWrapper(const GLushort* v_)
{
  glColor4usv( v_ );
}

void glEdgeFlagWrapper(GLboolean flag_)
{
  glEdgeFlag( flag_ );
}

void glEdgeFlagvWrapper(const GLboolean* flag_)
{
  glEdgeFlagv( flag_ );
}

void glEndWrapper(void)
{
  glEnd(  );
}

void glIndexdWrapper(GLdouble c_)
{
  glIndexd( c_ );
}

void glIndexdvWrapper(const GLdouble* c_)
{
  glIndexdv( c_ );
}

void glIndexfWrapper(GLfloat c_)
{
  glIndexf( c_ );
}

void glIndexfvWrapper(const GLfloat* c_)
{
  glIndexfv( c_ );
}

void glIndexiWrapper(GLint c_)
{
  glIndexi( c_ );
}

void glIndexivWrapper(const GLint* c_)
{
  glIndexiv( c_ );
}

void glIndexsWrapper(GLshort c_)
{
  glIndexs( c_ );
}

void glIndexsvWrapper(const GLshort* c_)
{
  glIndexsv( c_ );
}

void glNormal3bWrapper(GLbyte nx_, GLbyte ny_, GLbyte nz_)
{
  glNormal3b( nx_, ny_, nz_ );
}

void glNormal3bvWrapper(const GLbyte* v_)
{
  glNormal3bv( v_ );
}

void glNormal3dWrapper(GLdouble nx_, GLdouble ny_, GLdouble nz_)
{
  glNormal3d( nx_, ny_, nz_ );
}

void glNormal3dvWrapper(const GLdouble* v_)
{
  glNormal3dv( v_ );
}

void glNormal3fWrapper(GLfloat nx_, GLfloat ny_, GLfloat nz_)
{
  glNormal3f( nx_, ny_, nz_ );
}

void glNormal3fvWrapper(const GLfloat* v_)
{
  glNormal3fv( v_ );
}

void glNormal3iWrapper(GLint nx_, GLint ny_, GLint nz_)
{
  glNormal3i( nx_, ny_, nz_ );
}

void glNormal3ivWrapper(const GLint* v_)
{
  glNormal3iv( v_ );
}

void glNormal3sWrapper(GLshort nx_, GLshort ny_, GLshort nz_)
{
  glNormal3s( nx_, ny_, nz_ );
}

void glNormal3svWrapper(const GLshort* v_)
{
  glNormal3sv( v_ );
}

void glRasterPos2dWrapper(GLdouble x_, GLdouble y_)
{
  glRasterPos2d( x_, y_ );
}

void glRasterPos2dvWrapper(const GLdouble* v_)
{
  glRasterPos2dv( v_ );
}

void glRasterPos2fWrapper(GLfloat x_, GLfloat y_)
{
  glRasterPos2f( x_, y_ );
}

void glRasterPos2fvWrapper(const GLfloat* v_)
{
  glRasterPos2fv( v_ );
}

void glRasterPos2iWrapper(GLint x_, GLint y_)
{
  glRasterPos2i( x_, y_ );
}

void glRasterPos2ivWrapper(const GLint* v_)
{
  glRasterPos2iv( v_ );
}

void glRasterPos2sWrapper(GLshort x_, GLshort y_)
{
  glRasterPos2s( x_, y_ );
}

void glRasterPos2svWrapper(const GLshort* v_)
{
  glRasterPos2sv( v_ );
}

void glRasterPos3dWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  glRasterPos3d( x_, y_, z_ );
}

void glRasterPos3dvWrapper(const GLdouble* v_)
{
  glRasterPos3dv( v_ );
}

void glRasterPos3fWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  glRasterPos3f( x_, y_, z_ );
}

void glRasterPos3fvWrapper(const GLfloat* v_)
{
  glRasterPos3fv( v_ );
}

void glRasterPos3iWrapper(GLint x_, GLint y_, GLint z_)
{
  glRasterPos3i( x_, y_, z_ );
}

void glRasterPos3ivWrapper(const GLint* v_)
{
  glRasterPos3iv( v_ );
}

void glRasterPos3sWrapper(GLshort x_, GLshort y_, GLshort z_)
{
  glRasterPos3s( x_, y_, z_ );
}

void glRasterPos3svWrapper(const GLshort* v_)
{
  glRasterPos3sv( v_ );
}

void glRasterPos4dWrapper(GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  glRasterPos4d( x_, y_, z_, w_ );
}

void glRasterPos4dvWrapper(const GLdouble* v_)
{
  glRasterPos4dv( v_ );
}

void glRasterPos4fWrapper(GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  glRasterPos4f( x_, y_, z_, w_ );
}

void glRasterPos4fvWrapper(const GLfloat* v_)
{
  glRasterPos4fv( v_ );
}

void glRasterPos4iWrapper(GLint x_, GLint y_, GLint z_, GLint w_)
{
  glRasterPos4i( x_, y_, z_, w_ );
}

void glRasterPos4ivWrapper(const GLint* v_)
{
  glRasterPos4iv( v_ );
}

void glRasterPos4sWrapper(GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  glRasterPos4s( x_, y_, z_, w_ );
}

void glRasterPos4svWrapper(const GLshort* v_)
{
  glRasterPos4sv( v_ );
}

void glRectdWrapper(GLdouble x1_, GLdouble y1_, GLdouble x2_, GLdouble y2_)
{
  glRectd( x1_, y1_, x2_, y2_ );
}

void glRectdvWrapper(const GLdouble* v1_, const GLdouble* v2_)
{
  glRectdv( v1_, v2_ );
}

void glRectfWrapper(GLfloat x1_, GLfloat y1_, GLfloat x2_, GLfloat y2_)
{
  glRectf( x1_, y1_, x2_, y2_ );
}

void glRectfvWrapper(const GLfloat* v1_, const GLfloat* v2_)
{
  glRectfv( v1_, v2_ );
}

void glRectiWrapper(GLint x1_, GLint y1_, GLint x2_, GLint y2_)
{
  glRecti( x1_, y1_, x2_, y2_ );
}

void glRectivWrapper(const GLint* v1_, const GLint* v2_)
{
  glRectiv( v1_, v2_ );
}

void glRectsWrapper(GLshort x1_, GLshort y1_, GLshort x2_, GLshort y2_)
{
  glRects( x1_, y1_, x2_, y2_ );
}

void glRectsvWrapper(const GLshort* v1_, const GLshort* v2_)
{
  glRectsv( v1_, v2_ );
}

void glTexCoord1dWrapper(GLdouble s_)
{
  glTexCoord1d( s_ );
}

void glTexCoord1dvWrapper(const GLdouble* v_)
{
  glTexCoord1dv( v_ );
}

void glTexCoord1fWrapper(GLfloat s_)
{
  glTexCoord1f( s_ );
}

void glTexCoord1fvWrapper(const GLfloat* v_)
{
  glTexCoord1fv( v_ );
}

void glTexCoord1iWrapper(GLint s_)
{
  glTexCoord1i( s_ );
}

void glTexCoord1ivWrapper(const GLint* v_)
{
  glTexCoord1iv( v_ );
}

void glTexCoord1sWrapper(GLshort s_)
{
  glTexCoord1s( s_ );
}

void glTexCoord1svWrapper(const GLshort* v_)
{
  glTexCoord1sv( v_ );
}

void glTexCoord2dWrapper(GLdouble s_, GLdouble t_)
{
  glTexCoord2d( s_, t_ );
}

void glTexCoord2dvWrapper(const GLdouble* v_)
{
  glTexCoord2dv( v_ );
}

void glTexCoord2fWrapper(GLfloat s_, GLfloat t_)
{
  glTexCoord2f( s_, t_ );
}

void glTexCoord2fvWrapper(const GLfloat* v_)
{
  glTexCoord2fv( v_ );
}

void glTexCoord2iWrapper(GLint s_, GLint t_)
{
  glTexCoord2i( s_, t_ );
}

void glTexCoord2ivWrapper(const GLint* v_)
{
  glTexCoord2iv( v_ );
}

void glTexCoord2sWrapper(GLshort s_, GLshort t_)
{
  glTexCoord2s( s_, t_ );
}

void glTexCoord2svWrapper(const GLshort* v_)
{
  glTexCoord2sv( v_ );
}

void glTexCoord3dWrapper(GLdouble s_, GLdouble t_, GLdouble r_)
{
  glTexCoord3d( s_, t_, r_ );
}

void glTexCoord3dvWrapper(const GLdouble* v_)
{
  glTexCoord3dv( v_ );
}

void glTexCoord3fWrapper(GLfloat s_, GLfloat t_, GLfloat r_)
{
  glTexCoord3f( s_, t_, r_ );
}

void glTexCoord3fvWrapper(const GLfloat* v_)
{
  glTexCoord3fv( v_ );
}

void glTexCoord3iWrapper(GLint s_, GLint t_, GLint r_)
{
  glTexCoord3i( s_, t_, r_ );
}

void glTexCoord3ivWrapper(const GLint* v_)
{
  glTexCoord3iv( v_ );
}

void glTexCoord3sWrapper(GLshort s_, GLshort t_, GLshort r_)
{
  glTexCoord3s( s_, t_, r_ );
}

void glTexCoord3svWrapper(const GLshort* v_)
{
  glTexCoord3sv( v_ );
}

void glTexCoord4dWrapper(GLdouble s_, GLdouble t_, GLdouble r_, GLdouble q_)
{
  glTexCoord4d( s_, t_, r_, q_ );
}

void glTexCoord4dvWrapper(const GLdouble* v_)
{
  glTexCoord4dv( v_ );
}

void glTexCoord4fWrapper(GLfloat s_, GLfloat t_, GLfloat r_, GLfloat q_)
{
  glTexCoord4f( s_, t_, r_, q_ );
}

void glTexCoord4fvWrapper(const GLfloat* v_)
{
  glTexCoord4fv( v_ );
}

void glTexCoord4iWrapper(GLint s_, GLint t_, GLint r_, GLint q_)
{
  glTexCoord4i( s_, t_, r_, q_ );
}

void glTexCoord4ivWrapper(const GLint* v_)
{
  glTexCoord4iv( v_ );
}

void glTexCoord4sWrapper(GLshort s_, GLshort t_, GLshort r_, GLshort q_)
{
  glTexCoord4s( s_, t_, r_, q_ );
}

void glTexCoord4svWrapper(const GLshort* v_)
{
  glTexCoord4sv( v_ );
}

void glVertex2dWrapper(GLdouble x_, GLdouble y_)
{
  glVertex2d( x_, y_ );
}

void glVertex2dvWrapper(const GLdouble* v_)
{
  glVertex2dv( v_ );
}

void glVertex2fWrapper(GLfloat x_, GLfloat y_)
{
  glVertex2f( x_, y_ );
}

void glVertex2fvWrapper(const GLfloat* v_)
{
  glVertex2fv( v_ );
}

void glVertex2iWrapper(GLint x_, GLint y_)
{
  glVertex2i( x_, y_ );
}

void glVertex2ivWrapper(const GLint* v_)
{
  glVertex2iv( v_ );
}

void glVertex2sWrapper(GLshort x_, GLshort y_)
{
  glVertex2s( x_, y_ );
}

void glVertex2svWrapper(const GLshort* v_)
{
  glVertex2sv( v_ );
}

void glVertex3dWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  glVertex3d( x_, y_, z_ );
}

void glVertex3dvWrapper(const GLdouble* v_)
{
  glVertex3dv( v_ );
}

void glVertex3fWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  glVertex3f( x_, y_, z_ );
}

void glVertex3fvWrapper(const GLfloat* v_)
{
  glVertex3fv( v_ );
}

void glVertex3iWrapper(GLint x_, GLint y_, GLint z_)
{
  glVertex3i( x_, y_, z_ );
}

void glVertex3ivWrapper(const GLint* v_)
{
  glVertex3iv( v_ );
}

void glVertex3sWrapper(GLshort x_, GLshort y_, GLshort z_)
{
  glVertex3s( x_, y_, z_ );
}

void glVertex3svWrapper(const GLshort* v_)
{
  glVertex3sv( v_ );
}

void glVertex4dWrapper(GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  glVertex4d( x_, y_, z_, w_ );
}

void glVertex4dvWrapper(const GLdouble* v_)
{
  glVertex4dv( v_ );
}

void glVertex4fWrapper(GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  glVertex4f( x_, y_, z_, w_ );
}

void glVertex4fvWrapper(const GLfloat* v_)
{
  glVertex4fv( v_ );
}

void glVertex4iWrapper(GLint x_, GLint y_, GLint z_, GLint w_)
{
  glVertex4i( x_, y_, z_, w_ );
}

void glVertex4ivWrapper(const GLint* v_)
{
  glVertex4iv( v_ );
}

void glVertex4sWrapper(GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  glVertex4s( x_, y_, z_, w_ );
}

void glVertex4svWrapper(const GLshort* v_)
{
  glVertex4sv( v_ );
}

void glClipPlaneWrapper(GLenum plane_, const GLdouble* equation_)
{
  glClipPlane( plane_, equation_ );
}

void glColorMaterialWrapper(GLenum face_, GLenum mode_)
{
  glColorMaterial( face_, mode_ );
}

void glFogfWrapper(GLenum pname_, GLfloat param_)
{
  glFogf( pname_, param_ );
}

void glFogfvWrapper(GLenum pname_, const GLfloat* params_)
{
  glFogfv( pname_, params_ );
}

void glFogiWrapper(GLenum pname_, GLint param_)
{
  glFogi( pname_, param_ );
}

void glFogivWrapper(GLenum pname_, const GLint* params_)
{
  glFogiv( pname_, params_ );
}

void glLightfWrapper(GLenum light_, GLenum pname_, GLfloat param_)
{
  glLightf( light_, pname_, param_ );
}

void glLightfvWrapper(GLenum light_, GLenum pname_, const GLfloat* params_)
{
  glLightfv( light_, pname_, params_ );
}

void glLightiWrapper(GLenum light_, GLenum pname_, GLint param_)
{
  glLighti( light_, pname_, param_ );
}

void glLightivWrapper(GLenum light_, GLenum pname_, const GLint* params_)
{
  glLightiv( light_, pname_, params_ );
}

void glLightModelfWrapper(GLenum pname_, GLfloat param_)
{
  glLightModelf( pname_, param_ );
}

void glLightModelfvWrapper(GLenum pname_, const GLfloat* params_)
{
  glLightModelfv( pname_, params_ );
}

void glLightModeliWrapper(GLenum pname_, GLint param_)
{
  glLightModeli( pname_, param_ );
}

void glLightModelivWrapper(GLenum pname_, const GLint* params_)
{
  glLightModeliv( pname_, params_ );
}

void glLineStippleWrapper(GLint factor_, GLushort pattern_)
{
  glLineStipple( factor_, pattern_ );
}

void glMaterialfWrapper(GLenum face_, GLenum pname_, GLfloat param_)
{
  glMaterialf( face_, pname_, param_ );
}

void glMaterialfvWrapper(GLenum face_, GLenum pname_, const GLfloat* params_)
{
  glMaterialfv( face_, pname_, params_ );
}

void glMaterialiWrapper(GLenum face_, GLenum pname_, GLint param_)
{
  glMateriali( face_, pname_, param_ );
}

void glMaterialivWrapper(GLenum face_, GLenum pname_, const GLint* params_)
{
  glMaterialiv( face_, pname_, params_ );
}

void glPolygonStippleWrapper(const GLubyte* mask_)
{
  glPolygonStipple( mask_ );
}

void glShadeModelWrapper(GLenum mode_)
{
  glShadeModel( mode_ );
}

void glTexEnvfWrapper(GLenum target_, GLenum pname_, GLfloat param_)
{
  glTexEnvf( target_, pname_, param_ );
}

void glTexEnvfvWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  glTexEnvfv( target_, pname_, params_ );
}

void glTexEnviWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  glTexEnvi( target_, pname_, param_ );
}

void glTexEnvivWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  glTexEnviv( target_, pname_, params_ );
}

void glTexGendWrapper(GLenum coord_, GLenum pname_, GLdouble param_)
{
  glTexGend( coord_, pname_, param_ );
}

void glTexGendvWrapper(GLenum coord_, GLenum pname_, const GLdouble* params_)
{
  glTexGendv( coord_, pname_, params_ );
}

void glTexGenfWrapper(GLenum coord_, GLenum pname_, GLfloat param_)
{
  glTexGenf( coord_, pname_, param_ );
}

void glTexGenfvWrapper(GLenum coord_, GLenum pname_, const GLfloat* params_)
{
  glTexGenfv( coord_, pname_, params_ );
}

void glTexGeniWrapper(GLenum coord_, GLenum pname_, GLint param_)
{
  glTexGeni( coord_, pname_, param_ );
}

void glTexGenivWrapper(GLenum coord_, GLenum pname_, const GLint* params_)
{
  glTexGeniv( coord_, pname_, params_ );
}

void glFeedbackBufferWrapper(GLsizei size_, GLenum type_, GLfloat* buffer_)
{
  glFeedbackBuffer( size_, type_, buffer_ );
}

void glSelectBufferWrapper(GLsizei size_, GLuint* buffer_)
{
  glSelectBuffer( size_, buffer_ );
}

GLint glRenderModeWrapper(GLenum mode_)
{
  return glRenderMode( mode_ );
}

void glInitNamesWrapper(void)
{
  glInitNames(  );
}

void glLoadNameWrapper(GLuint name_)
{
  glLoadName( name_ );
}

void glPassThroughWrapper(GLfloat token_)
{
  glPassThrough( token_ );
}

void glPopNameWrapper(void)
{
  glPopName(  );
}

void glPushNameWrapper(GLuint name_)
{
  glPushName( name_ );
}

void glClearAccumWrapper(GLfloat red_, GLfloat green_, GLfloat blue_, GLfloat alpha_)
{
  glClearAccum( red_, green_, blue_, alpha_ );
}

void glClearIndexWrapper(GLfloat c_)
{
  glClearIndex( c_ );
}

void glIndexMaskWrapper(GLuint mask_)
{
  glIndexMask( mask_ );
}

void glAccumWrapper(GLenum op_, GLfloat value_)
{
  glAccum( op_, value_ );
}

void glPopAttribWrapper(void)
{
  glPopAttrib(  );
}

void glPushAttribWrapper(GLbitfield mask_)
{
  glPushAttrib( mask_ );
}

void glMap1dWrapper(GLenum target_, GLdouble u1_, GLdouble u2_, GLint stride_, GLint order_, const GLdouble* points_)
{
  glMap1d( target_, u1_, u2_, stride_, order_, points_ );
}

void glMap1fWrapper(GLenum target_, GLfloat u1_, GLfloat u2_, GLint stride_, GLint order_, const GLfloat* points_)
{
  glMap1f( target_, u1_, u2_, stride_, order_, points_ );
}

void glMap2dWrapper(GLenum target_, GLdouble u1_, GLdouble u2_, GLint ustride_, GLint uorder_, GLdouble v1_, GLdouble v2_, GLint vstride_, GLint vorder_, const GLdouble* points_)
{
  glMap2d( target_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, points_ );
}

void glMap2fWrapper(GLenum target_, GLfloat u1_, GLfloat u2_, GLint ustride_, GLint uorder_, GLfloat v1_, GLfloat v2_, GLint vstride_, GLint vorder_, const GLfloat* points_)
{
  glMap2f( target_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, points_ );
}

void glMapGrid1dWrapper(GLint un_, GLdouble u1_, GLdouble u2_)
{
  glMapGrid1d( un_, u1_, u2_ );
}

void glMapGrid1fWrapper(GLint un_, GLfloat u1_, GLfloat u2_)
{
  glMapGrid1f( un_, u1_, u2_ );
}

void glMapGrid2dWrapper(GLint un_, GLdouble u1_, GLdouble u2_, GLint vn_, GLdouble v1_, GLdouble v2_)
{
  glMapGrid2d( un_, u1_, u2_, vn_, v1_, v2_ );
}

void glMapGrid2fWrapper(GLint un_, GLfloat u1_, GLfloat u2_, GLint vn_, GLfloat v1_, GLfloat v2_)
{
  glMapGrid2f( un_, u1_, u2_, vn_, v1_, v2_ );
}

void glEvalCoord1dWrapper(GLdouble u_)
{
  glEvalCoord1d( u_ );
}

void glEvalCoord1dvWrapper(const GLdouble* u_)
{
  glEvalCoord1dv( u_ );
}

void glEvalCoord1fWrapper(GLfloat u_)
{
  glEvalCoord1f( u_ );
}

void glEvalCoord1fvWrapper(const GLfloat* u_)
{
  glEvalCoord1fv( u_ );
}

void glEvalCoord2dWrapper(GLdouble u_, GLdouble v_)
{
  glEvalCoord2d( u_, v_ );
}

void glEvalCoord2dvWrapper(const GLdouble* u_)
{
  glEvalCoord2dv( u_ );
}

void glEvalCoord2fWrapper(GLfloat u_, GLfloat v_)
{
  glEvalCoord2f( u_, v_ );
}

void glEvalCoord2fvWrapper(const GLfloat* u_)
{
  glEvalCoord2fv( u_ );
}

void glEvalMesh1Wrapper(GLenum mode_, GLint i1_, GLint i2_)
{
  glEvalMesh1( mode_, i1_, i2_ );
}

void glEvalPoint1Wrapper(GLint i_)
{
  glEvalPoint1( i_ );
}

void glEvalMesh2Wrapper(GLenum mode_, GLint i1_, GLint i2_, GLint j1_, GLint j2_)
{
  glEvalMesh2( mode_, i1_, i2_, j1_, j2_ );
}

void glEvalPoint2Wrapper(GLint i_, GLint j_)
{
  glEvalPoint2( i_, j_ );
}

void glAlphaFuncWrapper(GLenum func_, GLfloat ref_)
{
  glAlphaFunc( func_, ref_ );
}

void glPixelZoomWrapper(GLfloat xfactor_, GLfloat yfactor_)
{
  glPixelZoom( xfactor_, yfactor_ );
}

void glPixelTransferfWrapper(GLenum pname_, GLfloat param_)
{
  glPixelTransferf( pname_, param_ );
}

void glPixelTransferiWrapper(GLenum pname_, GLint param_)
{
  glPixelTransferi( pname_, param_ );
}

void glPixelMapfvWrapper(GLenum map_, GLsizei mapsize_, const GLfloat* values_)
{
  glPixelMapfv( map_, mapsize_, values_ );
}

void glPixelMapuivWrapper(GLenum map_, GLsizei mapsize_, const GLuint* values_)
{
  glPixelMapuiv( map_, mapsize_, values_ );
}

void glPixelMapusvWrapper(GLenum map_, GLsizei mapsize_, const GLushort* values_)
{
  glPixelMapusv( map_, mapsize_, values_ );
}

void glCopyPixelsWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLenum type_)
{
  glCopyPixels( x_, y_, width_, height_, type_ );
}

void glDrawPixelsWrapper(GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  glDrawPixels( width_, height_, format_, type_, pixels_ );
}

void glGetClipPlaneWrapper(GLenum plane_, GLdouble* equation_)
{
  glGetClipPlane( plane_, equation_ );
}

void glGetLightfvWrapper(GLenum light_, GLenum pname_, GLfloat* params_)
{
  glGetLightfv( light_, pname_, params_ );
}

void glGetLightivWrapper(GLenum light_, GLenum pname_, GLint* params_)
{
  glGetLightiv( light_, pname_, params_ );
}

void glGetMapdvWrapper(GLenum target_, GLenum query_, GLdouble* v_)
{
  glGetMapdv( target_, query_, v_ );
}

void glGetMapfvWrapper(GLenum target_, GLenum query_, GLfloat* v_)
{
  glGetMapfv( target_, query_, v_ );
}

void glGetMapivWrapper(GLenum target_, GLenum query_, GLint* v_)
{
  glGetMapiv( target_, query_, v_ );
}

void glGetMaterialfvWrapper(GLenum face_, GLenum pname_, GLfloat* params_)
{
  glGetMaterialfv( face_, pname_, params_ );
}

void glGetMaterialivWrapper(GLenum face_, GLenum pname_, GLint* params_)
{
  glGetMaterialiv( face_, pname_, params_ );
}

void glGetPixelMapfvWrapper(GLenum map_, GLfloat* values_)
{
  glGetPixelMapfv( map_, values_ );
}

void glGetPixelMapuivWrapper(GLenum map_, GLuint* values_)
{
  glGetPixelMapuiv( map_, values_ );
}

void glGetPixelMapusvWrapper(GLenum map_, GLushort* values_)
{
  glGetPixelMapusv( map_, values_ );
}

void glGetPolygonStippleWrapper(GLubyte* mask_)
{
  glGetPolygonStipple( mask_ );
}

void glGetTexEnvfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  glGetTexEnvfv( target_, pname_, params_ );
}

void glGetTexEnvivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  glGetTexEnviv( target_, pname_, params_ );
}

void glGetTexGendvWrapper(GLenum coord_, GLenum pname_, GLdouble* params_)
{
  glGetTexGendv( coord_, pname_, params_ );
}

void glGetTexGenfvWrapper(GLenum coord_, GLenum pname_, GLfloat* params_)
{
  glGetTexGenfv( coord_, pname_, params_ );
}

void glGetTexGenivWrapper(GLenum coord_, GLenum pname_, GLint* params_)
{
  glGetTexGeniv( coord_, pname_, params_ );
}

GLboolean glIsListWrapper(GLuint list_)
{
  return glIsList( list_ );
}

void glFrustumWrapper(GLdouble left_, GLdouble right_, GLdouble bottom_, GLdouble top_, GLdouble zNear_, GLdouble zFar_)
{
  glFrustum( left_, right_, bottom_, top_, zNear_, zFar_ );
}

void glLoadIdentityWrapper(void)
{
  glLoadIdentity(  );
}

void glLoadMatrixfWrapper(const GLfloat* m_)
{
  glLoadMatrixf( m_ );
}

void glLoadMatrixdWrapper(const GLdouble* m_)
{
  glLoadMatrixd( m_ );
}

void glMatrixModeWrapper(GLenum mode_)
{
  glMatrixMode( mode_ );
}

void glMultMatrixfWrapper(const GLfloat* m_)
{
  glMultMatrixf( m_ );
}

void glMultMatrixdWrapper(const GLdouble* m_)
{
  glMultMatrixd( m_ );
}

void glOrthoWrapper(GLdouble left_, GLdouble right_, GLdouble bottom_, GLdouble top_, GLdouble zNear_, GLdouble zFar_)
{
  glOrtho( left_, right_, bottom_, top_, zNear_, zFar_ );
}

void glPopMatrixWrapper(void)
{
  glPopMatrix(  );
}

void glPushMatrixWrapper(void)
{
  glPushMatrix(  );
}

void glRotatedWrapper(GLdouble angle_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  glRotated( angle_, x_, y_, z_ );
}

void glRotatefWrapper(GLfloat angle_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  glRotatef( angle_, x_, y_, z_ );
}

void glScaledWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  glScaled( x_, y_, z_ );
}

void glScalefWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  glScalef( x_, y_, z_ );
}

void glTranslatedWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  glTranslated( x_, y_, z_ );
}

void glTranslatefWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  glTranslatef( x_, y_, z_ );
}

void glDrawArraysWrapper(GLenum mode_, GLint first_, GLsizei count_)
{
  glDrawArrays( mode_, first_, count_ );
}

void glDrawElementsWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_)
{
  glDrawElements( mode_, count_, type_, indices_ );
}

void glGetPointervWrapper(GLenum pname_, void ** params_)
{
  glGetPointerv( pname_, params_ );
}

void glPolygonOffsetWrapper(GLfloat factor_, GLfloat units_)
{
  glPolygonOffset( factor_, units_ );
}

void glCopyTexImage1DWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLint border_)
{
  glCopyTexImage1D( target_, level_, internalformat_, x_, y_, width_, border_ );
}

void glCopyTexImage2DWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLint border_)
{
  glCopyTexImage2D( target_, level_, internalformat_, x_, y_, width_, height_, border_ );
}

void glCopyTexSubImage1DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint x_, GLint y_, GLsizei width_)
{
  glCopyTexSubImage1D( target_, level_, xoffset_, x_, y_, width_ );
}

void glCopyTexSubImage2DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  glCopyTexSubImage2D( target_, level_, xoffset_, yoffset_, x_, y_, width_, height_ );
}

void glTexSubImage1DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLenum type_, const void * pixels_)
{
  glTexSubImage1D( target_, level_, xoffset_, width_, format_, type_, pixels_ );
}

void glTexSubImage2DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  glTexSubImage2D( target_, level_, xoffset_, yoffset_, width_, height_, format_, type_, pixels_ );
}

void glBindTextureWrapper(GLenum target_, GLuint texture_)
{
  glBindTexture( target_, texture_ );
}

void glDeleteTexturesWrapper(GLsizei n_, const GLuint* textures_)
{
  glDeleteTextures( n_, textures_ );
}

void glGenTexturesWrapper(GLsizei n_, GLuint* textures_)
{
  glGenTextures( n_, textures_ );
}

GLboolean glIsTextureWrapper(GLuint texture_)
{
  return glIsTexture( texture_ );
}

void glArrayElementWrapper(GLint i_)
{
  glArrayElement( i_ );
}

void glColorPointerWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  glColorPointer( size_, type_, stride_, pointer_ );
}

void glDisableClientStateWrapper(GLenum array_)
{
  glDisableClientState( array_ );
}

void glEdgeFlagPointerWrapper(GLsizei stride_, const void * pointer_)
{
  glEdgeFlagPointer( stride_, pointer_ );
}

void glEnableClientStateWrapper(GLenum array_)
{
  glEnableClientState( array_ );
}

void glIndexPointerWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  glIndexPointer( type_, stride_, pointer_ );
}

void glInterleavedArraysWrapper(GLenum format_, GLsizei stride_, const void * pointer_)
{
  glInterleavedArrays( format_, stride_, pointer_ );
}

void glNormalPointerWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  glNormalPointer( type_, stride_, pointer_ );
}

void glTexCoordPointerWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  glTexCoordPointer( size_, type_, stride_, pointer_ );
}

void glVertexPointerWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  glVertexPointer( size_, type_, stride_, pointer_ );
}

GLboolean glAreTexturesResidentWrapper(GLsizei n_, const GLuint* textures_, GLboolean* residences_)
{
  return glAreTexturesResident( n_, textures_, residences_ );
}

void glPrioritizeTexturesWrapper(GLsizei n_, const GLuint* textures_, const GLfloat* priorities_)
{
  glPrioritizeTextures( n_, textures_, priorities_ );
}

void glIndexubWrapper(GLubyte c_)
{
  glIndexub( c_ );
}

void glIndexubvWrapper(const GLubyte* c_)
{
  glIndexubv( c_ );
}

void glPopClientAttribWrapper(void)
{
  glPopClientAttrib(  );
}

void glPushClientAttribWrapper(GLbitfield mask_)
{
  glPushClientAttrib( mask_ );
}

void glDrawRangeElementsWrapper(GLenum mode_, GLuint start_, GLuint end_, GLsizei count_, GLenum type_, const void * indices_)
{
  RESOLVE(PFNGLDRAWRANGEELEMENTSPROC, "glDrawRangeElements");
  RESOLVED_PROC(PFNGLDRAWRANGEELEMENTSPROC)( mode_, start_, end_, count_, type_, indices_ );
}

void glTexImage3DWrapper(GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXIMAGE3DPROC, "glTexImage3D");
  RESOLVED_PROC(PFNGLTEXIMAGE3DPROC)( target_, level_, internalformat_, width_, height_, depth_, border_, format_, type_, pixels_ );
}

void glTexSubImage3DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXSUBIMAGE3DPROC, "glTexSubImage3D");
  RESOLVED_PROC(PFNGLTEXSUBIMAGE3DPROC)( target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, pixels_ );
}

void glCopyTexSubImage3DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXSUBIMAGE3DPROC, "glCopyTexSubImage3D");
  RESOLVED_PROC(PFNGLCOPYTEXSUBIMAGE3DPROC)( target_, level_, xoffset_, yoffset_, zoffset_, x_, y_, width_, height_ );
}

void glActiveTextureWrapper(GLenum texture_)
{
  RESOLVE(PFNGLACTIVETEXTUREPROC, "glActiveTexture");
  RESOLVED_PROC(PFNGLACTIVETEXTUREPROC)( texture_ );
}

void glSampleCoverageWrapper(GLfloat value_, GLboolean invert_)
{
  RESOLVE(PFNGLSAMPLECOVERAGEPROC, "glSampleCoverage");
  RESOLVED_PROC(PFNGLSAMPLECOVERAGEPROC)( value_, invert_ );
}

void glCompressedTexImage3DWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE3DPROC, "glCompressedTexImage3D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE3DPROC)( target_, level_, internalformat_, width_, height_, depth_, border_, imageSize_, data_ );
}

void glCompressedTexImage2DWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE2DPROC, "glCompressedTexImage2D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE2DPROC)( target_, level_, internalformat_, width_, height_, border_, imageSize_, data_ );
}

void glCompressedTexImage1DWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE1DPROC, "glCompressedTexImage1D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE1DPROC)( target_, level_, internalformat_, width_, border_, imageSize_, data_ );
}

void glCompressedTexSubImage3DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, "glCompressedTexSubImage3D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)( target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, imageSize_, data_ );
}

void glCompressedTexSubImage2DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, "glCompressedTexSubImage2D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)( target_, level_, xoffset_, yoffset_, width_, height_, format_, imageSize_, data_ );
}

void glCompressedTexSubImage1DWrapper(GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, "glCompressedTexSubImage1D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)( target_, level_, xoffset_, width_, format_, imageSize_, data_ );
}

void glGetCompressedTexImageWrapper(GLenum target_, GLint level_, void * img_)
{
  RESOLVE(PFNGLGETCOMPRESSEDTEXIMAGEPROC, "glGetCompressedTexImage");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDTEXIMAGEPROC)( target_, level_, img_ );
}

void glClientActiveTextureWrapper(GLenum texture_)
{
  RESOLVE(PFNGLCLIENTACTIVETEXTUREPROC, "glClientActiveTexture");
  RESOLVED_PROC(PFNGLCLIENTACTIVETEXTUREPROC)( texture_ );
}

void glMultiTexCoord1dWrapper(GLenum target_, GLdouble s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1DPROC, "glMultiTexCoord1d");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1DPROC)( target_, s_ );
}

void glMultiTexCoord1dvWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1DVPROC, "glMultiTexCoord1dv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1DVPROC)( target_, v_ );
}

void glMultiTexCoord1fWrapper(GLenum target_, GLfloat s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1FPROC, "glMultiTexCoord1f");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1FPROC)( target_, s_ );
}

void glMultiTexCoord1fvWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1FVPROC, "glMultiTexCoord1fv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1FVPROC)( target_, v_ );
}

void glMultiTexCoord1iWrapper(GLenum target_, GLint s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1IPROC, "glMultiTexCoord1i");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1IPROC)( target_, s_ );
}

void glMultiTexCoord1ivWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1IVPROC, "glMultiTexCoord1iv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1IVPROC)( target_, v_ );
}

void glMultiTexCoord1sWrapper(GLenum target_, GLshort s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1SPROC, "glMultiTexCoord1s");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1SPROC)( target_, s_ );
}

void glMultiTexCoord1svWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1SVPROC, "glMultiTexCoord1sv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1SVPROC)( target_, v_ );
}

void glMultiTexCoord2dWrapper(GLenum target_, GLdouble s_, GLdouble t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2DPROC, "glMultiTexCoord2d");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2DPROC)( target_, s_, t_ );
}

void glMultiTexCoord2dvWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2DVPROC, "glMultiTexCoord2dv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2DVPROC)( target_, v_ );
}

void glMultiTexCoord2fWrapper(GLenum target_, GLfloat s_, GLfloat t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2FPROC, "glMultiTexCoord2f");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2FPROC)( target_, s_, t_ );
}

void glMultiTexCoord2fvWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2FVPROC, "glMultiTexCoord2fv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2FVPROC)( target_, v_ );
}

void glMultiTexCoord2iWrapper(GLenum target_, GLint s_, GLint t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2IPROC, "glMultiTexCoord2i");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2IPROC)( target_, s_, t_ );
}

void glMultiTexCoord2ivWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2IVPROC, "glMultiTexCoord2iv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2IVPROC)( target_, v_ );
}

void glMultiTexCoord2sWrapper(GLenum target_, GLshort s_, GLshort t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2SPROC, "glMultiTexCoord2s");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2SPROC)( target_, s_, t_ );
}

void glMultiTexCoord2svWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2SVPROC, "glMultiTexCoord2sv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2SVPROC)( target_, v_ );
}

void glMultiTexCoord3dWrapper(GLenum target_, GLdouble s_, GLdouble t_, GLdouble r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3DPROC, "glMultiTexCoord3d");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3DPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3dvWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3DVPROC, "glMultiTexCoord3dv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3DVPROC)( target_, v_ );
}

void glMultiTexCoord3fWrapper(GLenum target_, GLfloat s_, GLfloat t_, GLfloat r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3FPROC, "glMultiTexCoord3f");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3FPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3fvWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3FVPROC, "glMultiTexCoord3fv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3FVPROC)( target_, v_ );
}

void glMultiTexCoord3iWrapper(GLenum target_, GLint s_, GLint t_, GLint r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3IPROC, "glMultiTexCoord3i");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3IPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3ivWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3IVPROC, "glMultiTexCoord3iv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3IVPROC)( target_, v_ );
}

void glMultiTexCoord3sWrapper(GLenum target_, GLshort s_, GLshort t_, GLshort r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3SPROC, "glMultiTexCoord3s");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3SPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3svWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3SVPROC, "glMultiTexCoord3sv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3SVPROC)( target_, v_ );
}

void glMultiTexCoord4dWrapper(GLenum target_, GLdouble s_, GLdouble t_, GLdouble r_, GLdouble q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4DPROC, "glMultiTexCoord4d");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4DPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4dvWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4DVPROC, "glMultiTexCoord4dv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4DVPROC)( target_, v_ );
}

void glMultiTexCoord4fWrapper(GLenum target_, GLfloat s_, GLfloat t_, GLfloat r_, GLfloat q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4FPROC, "glMultiTexCoord4f");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4FPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4fvWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4FVPROC, "glMultiTexCoord4fv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4FVPROC)( target_, v_ );
}

void glMultiTexCoord4iWrapper(GLenum target_, GLint s_, GLint t_, GLint r_, GLint q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4IPROC, "glMultiTexCoord4i");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4IPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4ivWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4IVPROC, "glMultiTexCoord4iv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4IVPROC)( target_, v_ );
}

void glMultiTexCoord4sWrapper(GLenum target_, GLshort s_, GLshort t_, GLshort r_, GLshort q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4SPROC, "glMultiTexCoord4s");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4SPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4svWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4SVPROC, "glMultiTexCoord4sv");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4SVPROC)( target_, v_ );
}

void glLoadTransposeMatrixfWrapper(const GLfloat* m_)
{
  RESOLVE(PFNGLLOADTRANSPOSEMATRIXFPROC, "glLoadTransposeMatrixf");
  RESOLVED_PROC(PFNGLLOADTRANSPOSEMATRIXFPROC)( m_ );
}

void glLoadTransposeMatrixdWrapper(const GLdouble* m_)
{
  RESOLVE(PFNGLLOADTRANSPOSEMATRIXDPROC, "glLoadTransposeMatrixd");
  RESOLVED_PROC(PFNGLLOADTRANSPOSEMATRIXDPROC)( m_ );
}

void glMultTransposeMatrixfWrapper(const GLfloat* m_)
{
  RESOLVE(PFNGLMULTTRANSPOSEMATRIXFPROC, "glMultTransposeMatrixf");
  RESOLVED_PROC(PFNGLMULTTRANSPOSEMATRIXFPROC)( m_ );
}

void glMultTransposeMatrixdWrapper(const GLdouble* m_)
{
  RESOLVE(PFNGLMULTTRANSPOSEMATRIXDPROC, "glMultTransposeMatrixd");
  RESOLVED_PROC(PFNGLMULTTRANSPOSEMATRIXDPROC)( m_ );
}

void glBlendFuncSeparateWrapper(GLenum sfactorRGB_, GLenum dfactorRGB_, GLenum sfactorAlpha_, GLenum dfactorAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEPROC, "glBlendFuncSeparate");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEPROC)( sfactorRGB_, dfactorRGB_, sfactorAlpha_, dfactorAlpha_ );
}

void glMultiDrawArraysWrapper(GLenum mode_, const GLint* first_, const GLsizei* count_, GLsizei drawcount_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSPROC, "glMultiDrawArrays");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSPROC)( mode_, first_, count_, drawcount_ );
}

void glMultiDrawElementsWrapper(GLenum mode_, const GLsizei* count_, GLenum type_, const void *const* indices_, GLsizei drawcount_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSPROC, "glMultiDrawElements");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSPROC)( mode_, count_, type_, indices_, drawcount_ );
}

void glPointParameterfWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPOINTPARAMETERFPROC, "glPointParameterf");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFPROC)( pname_, param_ );
}

void glPointParameterfvWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERFVPROC, "glPointParameterfv");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFVPROC)( pname_, params_ );
}

void glPointParameteriWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLPOINTPARAMETERIPROC, "glPointParameteri");
  RESOLVED_PROC(PFNGLPOINTPARAMETERIPROC)( pname_, param_ );
}

void glPointParameterivWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERIVPROC, "glPointParameteriv");
  RESOLVED_PROC(PFNGLPOINTPARAMETERIVPROC)( pname_, params_ );
}

void glFogCoordfWrapper(GLfloat coord_)
{
  RESOLVE(PFNGLFOGCOORDFPROC, "glFogCoordf");
  RESOLVED_PROC(PFNGLFOGCOORDFPROC)( coord_ );
}

void glFogCoordfvWrapper(const GLfloat* coord_)
{
  RESOLVE(PFNGLFOGCOORDFVPROC, "glFogCoordfv");
  RESOLVED_PROC(PFNGLFOGCOORDFVPROC)( coord_ );
}

void glFogCoorddWrapper(GLdouble coord_)
{
  RESOLVE(PFNGLFOGCOORDDPROC, "glFogCoordd");
  RESOLVED_PROC(PFNGLFOGCOORDDPROC)( coord_ );
}

void glFogCoorddvWrapper(const GLdouble* coord_)
{
  RESOLVE(PFNGLFOGCOORDDVPROC, "glFogCoorddv");
  RESOLVED_PROC(PFNGLFOGCOORDDVPROC)( coord_ );
}

void glFogCoordPointerWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLFOGCOORDPOINTERPROC, "glFogCoordPointer");
  RESOLVED_PROC(PFNGLFOGCOORDPOINTERPROC)( type_, stride_, pointer_ );
}

void glSecondaryColor3bWrapper(GLbyte red_, GLbyte green_, GLbyte blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3BPROC, "glSecondaryColor3b");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3BPROC)( red_, green_, blue_ );
}

void glSecondaryColor3bvWrapper(const GLbyte* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3BVPROC, "glSecondaryColor3bv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3BVPROC)( v_ );
}

void glSecondaryColor3dWrapper(GLdouble red_, GLdouble green_, GLdouble blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3DPROC, "glSecondaryColor3d");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3DPROC)( red_, green_, blue_ );
}

void glSecondaryColor3dvWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3DVPROC, "glSecondaryColor3dv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3DVPROC)( v_ );
}

void glSecondaryColor3fWrapper(GLfloat red_, GLfloat green_, GLfloat blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3FPROC, "glSecondaryColor3f");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3FPROC)( red_, green_, blue_ );
}

void glSecondaryColor3fvWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3FVPROC, "glSecondaryColor3fv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3FVPROC)( v_ );
}

void glSecondaryColor3iWrapper(GLint red_, GLint green_, GLint blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3IPROC, "glSecondaryColor3i");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3IPROC)( red_, green_, blue_ );
}

void glSecondaryColor3ivWrapper(const GLint* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3IVPROC, "glSecondaryColor3iv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3IVPROC)( v_ );
}

void glSecondaryColor3sWrapper(GLshort red_, GLshort green_, GLshort blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3SPROC, "glSecondaryColor3s");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3SPROC)( red_, green_, blue_ );
}

void glSecondaryColor3svWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3SVPROC, "glSecondaryColor3sv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3SVPROC)( v_ );
}

void glSecondaryColor3ubWrapper(GLubyte red_, GLubyte green_, GLubyte blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UBPROC, "glSecondaryColor3ub");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UBPROC)( red_, green_, blue_ );
}

void glSecondaryColor3ubvWrapper(const GLubyte* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UBVPROC, "glSecondaryColor3ubv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UBVPROC)( v_ );
}

void glSecondaryColor3uiWrapper(GLuint red_, GLuint green_, GLuint blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UIPROC, "glSecondaryColor3ui");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UIPROC)( red_, green_, blue_ );
}

void glSecondaryColor3uivWrapper(const GLuint* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UIVPROC, "glSecondaryColor3uiv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UIVPROC)( v_ );
}

void glSecondaryColor3usWrapper(GLushort red_, GLushort green_, GLushort blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3USPROC, "glSecondaryColor3us");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3USPROC)( red_, green_, blue_ );
}

void glSecondaryColor3usvWrapper(const GLushort* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3USVPROC, "glSecondaryColor3usv");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3USVPROC)( v_ );
}

void glSecondaryColorPointerWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLSECONDARYCOLORPOINTERPROC, "glSecondaryColorPointer");
  RESOLVED_PROC(PFNGLSECONDARYCOLORPOINTERPROC)( size_, type_, stride_, pointer_ );
}

void glWindowPos2dWrapper(GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLWINDOWPOS2DPROC, "glWindowPos2d");
  RESOLVED_PROC(PFNGLWINDOWPOS2DPROC)( x_, y_ );
}

void glWindowPos2dvWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS2DVPROC, "glWindowPos2dv");
  RESOLVED_PROC(PFNGLWINDOWPOS2DVPROC)( v_ );
}

void glWindowPos2fWrapper(GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLWINDOWPOS2FPROC, "glWindowPos2f");
  RESOLVED_PROC(PFNGLWINDOWPOS2FPROC)( x_, y_ );
}

void glWindowPos2fvWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS2FVPROC, "glWindowPos2fv");
  RESOLVED_PROC(PFNGLWINDOWPOS2FVPROC)( v_ );
}

void glWindowPos2iWrapper(GLint x_, GLint y_)
{
  RESOLVE(PFNGLWINDOWPOS2IPROC, "glWindowPos2i");
  RESOLVED_PROC(PFNGLWINDOWPOS2IPROC)( x_, y_ );
}

void glWindowPos2ivWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS2IVPROC, "glWindowPos2iv");
  RESOLVED_PROC(PFNGLWINDOWPOS2IVPROC)( v_ );
}

void glWindowPos2sWrapper(GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLWINDOWPOS2SPROC, "glWindowPos2s");
  RESOLVED_PROC(PFNGLWINDOWPOS2SPROC)( x_, y_ );
}

void glWindowPos2svWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS2SVPROC, "glWindowPos2sv");
  RESOLVED_PROC(PFNGLWINDOWPOS2SVPROC)( v_ );
}

void glWindowPos3dWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLWINDOWPOS3DPROC, "glWindowPos3d");
  RESOLVED_PROC(PFNGLWINDOWPOS3DPROC)( x_, y_, z_ );
}

void glWindowPos3dvWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS3DVPROC, "glWindowPos3dv");
  RESOLVED_PROC(PFNGLWINDOWPOS3DVPROC)( v_ );
}

void glWindowPos3fWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLWINDOWPOS3FPROC, "glWindowPos3f");
  RESOLVED_PROC(PFNGLWINDOWPOS3FPROC)( x_, y_, z_ );
}

void glWindowPos3fvWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS3FVPROC, "glWindowPos3fv");
  RESOLVED_PROC(PFNGLWINDOWPOS3FVPROC)( v_ );
}

void glWindowPos3iWrapper(GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLWINDOWPOS3IPROC, "glWindowPos3i");
  RESOLVED_PROC(PFNGLWINDOWPOS3IPROC)( x_, y_, z_ );
}

void glWindowPos3ivWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS3IVPROC, "glWindowPos3iv");
  RESOLVED_PROC(PFNGLWINDOWPOS3IVPROC)( v_ );
}

void glWindowPos3sWrapper(GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLWINDOWPOS3SPROC, "glWindowPos3s");
  RESOLVED_PROC(PFNGLWINDOWPOS3SPROC)( x_, y_, z_ );
}

void glWindowPos3svWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS3SVPROC, "glWindowPos3sv");
  RESOLVED_PROC(PFNGLWINDOWPOS3SVPROC)( v_ );
}

void glBlendColorWrapper(GLfloat red_, GLfloat green_, GLfloat blue_, GLfloat alpha_)
{
  RESOLVE(PFNGLBLENDCOLORPROC, "glBlendColor");
  RESOLVED_PROC(PFNGLBLENDCOLORPROC)( red_, green_, blue_, alpha_ );
}

void glBlendEquationWrapper(GLenum mode_)
{
  RESOLVE(PFNGLBLENDEQUATIONPROC, "glBlendEquation");
  RESOLVED_PROC(PFNGLBLENDEQUATIONPROC)( mode_ );
}

void glGenQueriesWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLGENQUERIESPROC, "glGenQueries");
  RESOLVED_PROC(PFNGLGENQUERIESPROC)( n_, ids_ );
}

void glDeleteQueriesWrapper(GLsizei n_, const GLuint* ids_)
{
  RESOLVE(PFNGLDELETEQUERIESPROC, "glDeleteQueries");
  RESOLVED_PROC(PFNGLDELETEQUERIESPROC)( n_, ids_ );
}

GLboolean glIsQueryWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISQUERYPROC, "glIsQuery", FALSE);
  return RESOLVED_PROC(PFNGLISQUERYPROC)(id_ );
}

void glBeginQueryWrapper(GLenum target_, GLuint id_)
{
  RESOLVE(PFNGLBEGINQUERYPROC, "glBeginQuery");
  RESOLVED_PROC(PFNGLBEGINQUERYPROC)( target_, id_ );
}

void glEndQueryWrapper(GLenum target_)
{
  RESOLVE(PFNGLENDQUERYPROC, "glEndQuery");
  RESOLVED_PROC(PFNGLENDQUERYPROC)( target_ );
}

void glGetQueryivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETQUERYIVPROC, "glGetQueryiv");
  RESOLVED_PROC(PFNGLGETQUERYIVPROC)( target_, pname_, params_ );
}

void glGetQueryObjectivWrapper(GLuint id_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTIVPROC, "glGetQueryObjectiv");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTIVPROC)( id_, pname_, params_ );
}

void glGetQueryObjectuivWrapper(GLuint id_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTUIVPROC, "glGetQueryObjectuiv");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTUIVPROC)( id_, pname_, params_ );
}

void glBindBufferWrapper(GLenum target_, GLuint buffer_)
{
  RESOLVE(PFNGLBINDBUFFERPROC, "glBindBuffer");
  RESOLVED_PROC(PFNGLBINDBUFFERPROC)( target_, buffer_ );
}

void glDeleteBuffersWrapper(GLsizei n_, const GLuint* buffers_)
{
  RESOLVE(PFNGLDELETEBUFFERSPROC, "glDeleteBuffers");
  RESOLVED_PROC(PFNGLDELETEBUFFERSPROC)( n_, buffers_ );
}

void glGenBuffersWrapper(GLsizei n_, GLuint* buffers_)
{
  RESOLVE(PFNGLGENBUFFERSPROC, "glGenBuffers");
  RESOLVED_PROC(PFNGLGENBUFFERSPROC)( n_, buffers_ );
}

GLboolean glIsBufferWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLISBUFFERPROC, "glIsBuffer", FALSE);
  return RESOLVED_PROC(PFNGLISBUFFERPROC)(buffer_ );
}

void glBufferDataWrapper(GLenum target_, GLsizeiptr size_, const void * data_, GLenum usage_)
{
  RESOLVE(PFNGLBUFFERDATAPROC, "glBufferData");
  RESOLVED_PROC(PFNGLBUFFERDATAPROC)( target_, size_, data_, usage_ );
}

void glBufferSubDataWrapper(GLenum target_, GLintptr offset_, GLsizeiptr size_, const void * data_)
{
  RESOLVE(PFNGLBUFFERSUBDATAPROC, "glBufferSubData");
  RESOLVED_PROC(PFNGLBUFFERSUBDATAPROC)( target_, offset_, size_, data_ );
}

void glGetBufferSubDataWrapper(GLenum target_, GLintptr offset_, GLsizeiptr size_, void * data_)
{
  RESOLVE(PFNGLGETBUFFERSUBDATAPROC, "glGetBufferSubData");
  RESOLVED_PROC(PFNGLGETBUFFERSUBDATAPROC)( target_, offset_, size_, data_ );
}

void * glMapBufferWrapper(GLenum target_, GLenum access_)
{
  RESOLVE_RET(PFNGLMAPBUFFERPROC, "glMapBuffer", FALSE);
  return RESOLVED_PROC(PFNGLMAPBUFFERPROC)(target_, access_ );
}

GLboolean glUnmapBufferWrapper(GLenum target_)
{
  RESOLVE_RET(PFNGLUNMAPBUFFERPROC, "glUnmapBuffer", FALSE);
  return RESOLVED_PROC(PFNGLUNMAPBUFFERPROC)(target_ );
}

void glGetBufferParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETBUFFERPARAMETERIVPROC, "glGetBufferParameteriv");
  RESOLVED_PROC(PFNGLGETBUFFERPARAMETERIVPROC)( target_, pname_, params_ );
}

void glGetBufferPointervWrapper(GLenum target_, GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETBUFFERPOINTERVPROC, "glGetBufferPointerv");
  RESOLVED_PROC(PFNGLGETBUFFERPOINTERVPROC)( target_, pname_, params_ );
}

void glBlendEquationSeparateWrapper(GLenum modeRGB_, GLenum modeAlpha_)
{
  RESOLVE(PFNGLBLENDEQUATIONSEPARATEPROC, "glBlendEquationSeparate");
  RESOLVED_PROC(PFNGLBLENDEQUATIONSEPARATEPROC)( modeRGB_, modeAlpha_ );
}

void glDrawBuffersWrapper(GLsizei n_, const GLenum* bufs_)
{
  RESOLVE(PFNGLDRAWBUFFERSPROC, "glDrawBuffers");
  RESOLVED_PROC(PFNGLDRAWBUFFERSPROC)( n_, bufs_ );
}

void glStencilOpSeparateWrapper(GLenum face_, GLenum sfail_, GLenum dpfail_, GLenum dppass_)
{
  RESOLVE(PFNGLSTENCILOPSEPARATEPROC, "glStencilOpSeparate");
  RESOLVED_PROC(PFNGLSTENCILOPSEPARATEPROC)( face_, sfail_, dpfail_, dppass_ );
}

void glStencilFuncSeparateWrapper(GLenum face_, GLenum func_, GLint ref_, GLuint mask_)
{
  RESOLVE(PFNGLSTENCILFUNCSEPARATEPROC, "glStencilFuncSeparate");
  RESOLVED_PROC(PFNGLSTENCILFUNCSEPARATEPROC)( face_, func_, ref_, mask_ );
}

void glStencilMaskSeparateWrapper(GLenum face_, GLuint mask_)
{
  RESOLVE(PFNGLSTENCILMASKSEPARATEPROC, "glStencilMaskSeparate");
  RESOLVED_PROC(PFNGLSTENCILMASKSEPARATEPROC)( face_, mask_ );
}

void glAttachShaderWrapper(GLuint program_, GLuint shader_)
{
  RESOLVE(PFNGLATTACHSHADERPROC, "glAttachShader");
  RESOLVED_PROC(PFNGLATTACHSHADERPROC)( program_, shader_ );
}

void glBindAttribLocationWrapper(GLuint program_, GLuint index_, const GLchar* name_)
{
  RESOLVE(PFNGLBINDATTRIBLOCATIONPROC, "glBindAttribLocation");
  RESOLVED_PROC(PFNGLBINDATTRIBLOCATIONPROC)( program_, index_, name_ );
}

void glCompileShaderWrapper(GLuint shader_)
{
  RESOLVE(PFNGLCOMPILESHADERPROC, "glCompileShader");
  RESOLVED_PROC(PFNGLCOMPILESHADERPROC)( shader_ );
}

GLuint glCreateProgramWrapper(void)
{
  RESOLVE_RET(PFNGLCREATEPROGRAMPROC, "glCreateProgram", FALSE);
  return RESOLVED_PROC(PFNGLCREATEPROGRAMPROC)( );
}

GLuint glCreateShaderWrapper(GLenum type_)
{
  RESOLVE_RET(PFNGLCREATESHADERPROC, "glCreateShader", FALSE);
  return RESOLVED_PROC(PFNGLCREATESHADERPROC)(type_ );
}

void glDeleteProgramWrapper(GLuint program_)
{
  RESOLVE(PFNGLDELETEPROGRAMPROC, "glDeleteProgram");
  RESOLVED_PROC(PFNGLDELETEPROGRAMPROC)( program_ );
}

void glDeleteShaderWrapper(GLuint shader_)
{
  RESOLVE(PFNGLDELETESHADERPROC, "glDeleteShader");
  RESOLVED_PROC(PFNGLDELETESHADERPROC)( shader_ );
}

void glDetachShaderWrapper(GLuint program_, GLuint shader_)
{
  RESOLVE(PFNGLDETACHSHADERPROC, "glDetachShader");
  RESOLVED_PROC(PFNGLDETACHSHADERPROC)( program_, shader_ );
}

void glDisableVertexAttribArrayWrapper(GLuint index_)
{
  RESOLVE(PFNGLDISABLEVERTEXATTRIBARRAYPROC, "glDisableVertexAttribArray");
  RESOLVED_PROC(PFNGLDISABLEVERTEXATTRIBARRAYPROC)( index_ );
}

void glEnableVertexAttribArrayWrapper(GLuint index_)
{
  RESOLVE(PFNGLENABLEVERTEXATTRIBARRAYPROC, "glEnableVertexAttribArray");
  RESOLVED_PROC(PFNGLENABLEVERTEXATTRIBARRAYPROC)( index_ );
}

void glGetActiveAttribWrapper(GLuint program_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLint* size_, GLenum* type_, GLchar* name_)
{
  RESOLVE(PFNGLGETACTIVEATTRIBPROC, "glGetActiveAttrib");
  RESOLVED_PROC(PFNGLGETACTIVEATTRIBPROC)( program_, index_, bufSize_, length_, size_, type_, name_ );
}

void glGetActiveUniformWrapper(GLuint program_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLint* size_, GLenum* type_, GLchar* name_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMPROC, "glGetActiveUniform");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMPROC)( program_, index_, bufSize_, length_, size_, type_, name_ );
}

void glGetAttachedShadersWrapper(GLuint program_, GLsizei maxCount_, GLsizei* count_, GLuint* shaders_)
{
  RESOLVE(PFNGLGETATTACHEDSHADERSPROC, "glGetAttachedShaders");
  RESOLVED_PROC(PFNGLGETATTACHEDSHADERSPROC)( program_, maxCount_, count_, shaders_ );
}

GLint glGetAttribLocationWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETATTRIBLOCATIONPROC, "glGetAttribLocation", FALSE);
  return RESOLVED_PROC(PFNGLGETATTRIBLOCATIONPROC)(program_, name_ );
}

void glGetProgramivWrapper(GLuint program_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMIVPROC, "glGetProgramiv");
  RESOLVED_PROC(PFNGLGETPROGRAMIVPROC)( program_, pname_, params_ );
}

void glGetProgramInfoLogWrapper(GLuint program_, GLsizei bufSize_, GLsizei* length_, GLchar* infoLog_)
{
  RESOLVE(PFNGLGETPROGRAMINFOLOGPROC, "glGetProgramInfoLog");
  RESOLVED_PROC(PFNGLGETPROGRAMINFOLOGPROC)( program_, bufSize_, length_, infoLog_ );
}

void glGetShaderivWrapper(GLuint shader_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETSHADERIVPROC, "glGetShaderiv");
  RESOLVED_PROC(PFNGLGETSHADERIVPROC)( shader_, pname_, params_ );
}

void glGetShaderInfoLogWrapper(GLuint shader_, GLsizei bufSize_, GLsizei* length_, GLchar* infoLog_)
{
  RESOLVE(PFNGLGETSHADERINFOLOGPROC, "glGetShaderInfoLog");
  RESOLVED_PROC(PFNGLGETSHADERINFOLOGPROC)( shader_, bufSize_, length_, infoLog_ );
}

void glGetShaderSourceWrapper(GLuint shader_, GLsizei bufSize_, GLsizei* length_, GLchar* source_)
{
  RESOLVE(PFNGLGETSHADERSOURCEPROC, "glGetShaderSource");
  RESOLVED_PROC(PFNGLGETSHADERSOURCEPROC)( shader_, bufSize_, length_, source_ );
}

GLint glGetUniformLocationWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETUNIFORMLOCATIONPROC, "glGetUniformLocation", FALSE);
  return RESOLVED_PROC(PFNGLGETUNIFORMLOCATIONPROC)(program_, name_ );
}

void glGetUniformfvWrapper(GLuint program_, GLint location_, GLfloat* params_)
{
  RESOLVE(PFNGLGETUNIFORMFVPROC, "glGetUniformfv");
  RESOLVED_PROC(PFNGLGETUNIFORMFVPROC)( program_, location_, params_ );
}

void glGetUniformivWrapper(GLuint program_, GLint location_, GLint* params_)
{
  RESOLVE(PFNGLGETUNIFORMIVPROC, "glGetUniformiv");
  RESOLVED_PROC(PFNGLGETUNIFORMIVPROC)( program_, location_, params_ );
}

void glGetVertexAttribdvWrapper(GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBDVPROC, "glGetVertexAttribdv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBDVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribfvWrapper(GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBFVPROC, "glGetVertexAttribfv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBFVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribivWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIVPROC, "glGetVertexAttribiv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribPointervWrapper(GLuint index_, GLenum pname_, void ** pointer_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBPOINTERVPROC, "glGetVertexAttribPointerv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBPOINTERVPROC)( index_, pname_, pointer_ );
}

GLboolean glIsProgramWrapper(GLuint program_)
{
  RESOLVE_RET(PFNGLISPROGRAMPROC, "glIsProgram", FALSE);
  return RESOLVED_PROC(PFNGLISPROGRAMPROC)(program_ );
}

GLboolean glIsShaderWrapper(GLuint shader_)
{
  RESOLVE_RET(PFNGLISSHADERPROC, "glIsShader", FALSE);
  return RESOLVED_PROC(PFNGLISSHADERPROC)(shader_ );
}

void glLinkProgramWrapper(GLuint program_)
{
  RESOLVE(PFNGLLINKPROGRAMPROC, "glLinkProgram");
  RESOLVED_PROC(PFNGLLINKPROGRAMPROC)( program_ );
}

void glShaderSourceWrapper(GLuint shader_, GLsizei count_, const GLchar*const* string_, const GLint* length_)
{
  RESOLVE(PFNGLSHADERSOURCEPROC, "glShaderSource");
  RESOLVED_PROC(PFNGLSHADERSOURCEPROC)( shader_, count_, string_, length_ );
}

void glUseProgramWrapper(GLuint program_)
{
  RESOLVE(PFNGLUSEPROGRAMPROC, "glUseProgram");
  RESOLVED_PROC(PFNGLUSEPROGRAMPROC)( program_ );
}

void glUniform1fWrapper(GLint location_, GLfloat v0_)
{
  RESOLVE(PFNGLUNIFORM1FPROC, "glUniform1f");
  RESOLVED_PROC(PFNGLUNIFORM1FPROC)( location_, v0_ );
}

void glUniform2fWrapper(GLint location_, GLfloat v0_, GLfloat v1_)
{
  RESOLVE(PFNGLUNIFORM2FPROC, "glUniform2f");
  RESOLVED_PROC(PFNGLUNIFORM2FPROC)( location_, v0_, v1_ );
}

void glUniform3fWrapper(GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_)
{
  RESOLVE(PFNGLUNIFORM3FPROC, "glUniform3f");
  RESOLVED_PROC(PFNGLUNIFORM3FPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4fWrapper(GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_, GLfloat v3_)
{
  RESOLVE(PFNGLUNIFORM4FPROC, "glUniform4f");
  RESOLVED_PROC(PFNGLUNIFORM4FPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1iWrapper(GLint location_, GLint v0_)
{
  RESOLVE(PFNGLUNIFORM1IPROC, "glUniform1i");
  RESOLVED_PROC(PFNGLUNIFORM1IPROC)( location_, v0_ );
}

void glUniform2iWrapper(GLint location_, GLint v0_, GLint v1_)
{
  RESOLVE(PFNGLUNIFORM2IPROC, "glUniform2i");
  RESOLVED_PROC(PFNGLUNIFORM2IPROC)( location_, v0_, v1_ );
}

void glUniform3iWrapper(GLint location_, GLint v0_, GLint v1_, GLint v2_)
{
  RESOLVE(PFNGLUNIFORM3IPROC, "glUniform3i");
  RESOLVED_PROC(PFNGLUNIFORM3IPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4iWrapper(GLint location_, GLint v0_, GLint v1_, GLint v2_, GLint v3_)
{
  RESOLVE(PFNGLUNIFORM4IPROC, "glUniform4i");
  RESOLVED_PROC(PFNGLUNIFORM4IPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1fvWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM1FVPROC, "glUniform1fv");
  RESOLVED_PROC(PFNGLUNIFORM1FVPROC)( location_, count_, value_ );
}

void glUniform2fvWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM2FVPROC, "glUniform2fv");
  RESOLVED_PROC(PFNGLUNIFORM2FVPROC)( location_, count_, value_ );
}

void glUniform3fvWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM3FVPROC, "glUniform3fv");
  RESOLVED_PROC(PFNGLUNIFORM3FVPROC)( location_, count_, value_ );
}

void glUniform4fvWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM4FVPROC, "glUniform4fv");
  RESOLVED_PROC(PFNGLUNIFORM4FVPROC)( location_, count_, value_ );
}

void glUniform1ivWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM1IVPROC, "glUniform1iv");
  RESOLVED_PROC(PFNGLUNIFORM1IVPROC)( location_, count_, value_ );
}

void glUniform2ivWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM2IVPROC, "glUniform2iv");
  RESOLVED_PROC(PFNGLUNIFORM2IVPROC)( location_, count_, value_ );
}

void glUniform3ivWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM3IVPROC, "glUniform3iv");
  RESOLVED_PROC(PFNGLUNIFORM3IVPROC)( location_, count_, value_ );
}

void glUniform4ivWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM4IVPROC, "glUniform4iv");
  RESOLVED_PROC(PFNGLUNIFORM4IVPROC)( location_, count_, value_ );
}

void glUniformMatrix2fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2FVPROC, "glUniformMatrix2fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3FVPROC, "glUniformMatrix3fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4FVPROC, "glUniformMatrix4fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4FVPROC)( location_, count_, transpose_, value_ );
}

void glValidateProgramWrapper(GLuint program_)
{
  RESOLVE(PFNGLVALIDATEPROGRAMPROC, "glValidateProgram");
  RESOLVED_PROC(PFNGLVALIDATEPROGRAMPROC)( program_ );
}

void glVertexAttrib1dWrapper(GLuint index_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DPROC, "glVertexAttrib1d");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DPROC)( index_, x_ );
}

void glVertexAttrib1dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DVPROC, "glVertexAttrib1dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DVPROC)( index_, v_ );
}

void glVertexAttrib1fWrapper(GLuint index_, GLfloat x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FPROC, "glVertexAttrib1f");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FPROC)( index_, x_ );
}

void glVertexAttrib1fvWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FVPROC, "glVertexAttrib1fv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FVPROC)( index_, v_ );
}

void glVertexAttrib1sWrapper(GLuint index_, GLshort x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SPROC, "glVertexAttrib1s");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SPROC)( index_, x_ );
}

void glVertexAttrib1svWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SVPROC, "glVertexAttrib1sv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SVPROC)( index_, v_ );
}

void glVertexAttrib2dWrapper(GLuint index_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DPROC, "glVertexAttrib2d");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DPROC)( index_, x_, y_ );
}

void glVertexAttrib2dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DVPROC, "glVertexAttrib2dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DVPROC)( index_, v_ );
}

void glVertexAttrib2fWrapper(GLuint index_, GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FPROC, "glVertexAttrib2f");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FPROC)( index_, x_, y_ );
}

void glVertexAttrib2fvWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FVPROC, "glVertexAttrib2fv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FVPROC)( index_, v_ );
}

void glVertexAttrib2sWrapper(GLuint index_, GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SPROC, "glVertexAttrib2s");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SPROC)( index_, x_, y_ );
}

void glVertexAttrib2svWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SVPROC, "glVertexAttrib2sv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SVPROC)( index_, v_ );
}

void glVertexAttrib3dWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DPROC, "glVertexAttrib3d");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DVPROC, "glVertexAttrib3dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DVPROC)( index_, v_ );
}

void glVertexAttrib3fWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FPROC, "glVertexAttrib3f");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3fvWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FVPROC, "glVertexAttrib3fv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FVPROC)( index_, v_ );
}

void glVertexAttrib3sWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SPROC, "glVertexAttrib3s");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3svWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SVPROC, "glVertexAttrib3sv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SVPROC)( index_, v_ );
}

void glVertexAttrib4NbvWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NBVPROC, "glVertexAttrib4Nbv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NBVPROC)( index_, v_ );
}

void glVertexAttrib4NivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NIVPROC, "glVertexAttrib4Niv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NIVPROC)( index_, v_ );
}

void glVertexAttrib4NsvWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NSVPROC, "glVertexAttrib4Nsv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NSVPROC)( index_, v_ );
}

void glVertexAttrib4NubWrapper(GLuint index_, GLubyte x_, GLubyte y_, GLubyte z_, GLubyte w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUBPROC, "glVertexAttrib4Nub");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUBPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4NubvWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUBVPROC, "glVertexAttrib4Nubv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUBVPROC)( index_, v_ );
}

void glVertexAttrib4NuivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUIVPROC, "glVertexAttrib4Nuiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUIVPROC)( index_, v_ );
}

void glVertexAttrib4NusvWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUSVPROC, "glVertexAttrib4Nusv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUSVPROC)( index_, v_ );
}

void glVertexAttrib4bvWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4BVPROC, "glVertexAttrib4bv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4BVPROC)( index_, v_ );
}

void glVertexAttrib4dWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DPROC, "glVertexAttrib4d");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DVPROC, "glVertexAttrib4dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DVPROC)( index_, v_ );
}

void glVertexAttrib4fWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FPROC, "glVertexAttrib4f");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4fvWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FVPROC, "glVertexAttrib4fv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FVPROC)( index_, v_ );
}

void glVertexAttrib4ivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4IVPROC, "glVertexAttrib4iv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4IVPROC)( index_, v_ );
}

void glVertexAttrib4sWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SPROC, "glVertexAttrib4s");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4svWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SVPROC, "glVertexAttrib4sv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SVPROC)( index_, v_ );
}

void glVertexAttrib4ubvWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UBVPROC, "glVertexAttrib4ubv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UBVPROC)( index_, v_ );
}

void glVertexAttrib4uivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UIVPROC, "glVertexAttrib4uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UIVPROC)( index_, v_ );
}

void glVertexAttrib4usvWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4USVPROC, "glVertexAttrib4usv");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4USVPROC)( index_, v_ );
}

void glVertexAttribPointerWrapper(GLuint index_, GLint size_, GLenum type_, GLboolean normalized_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBPOINTERPROC, "glVertexAttribPointer");
  RESOLVED_PROC(PFNGLVERTEXATTRIBPOINTERPROC)( index_, size_, type_, normalized_, stride_, pointer_ );
}

void glUniformMatrix2x3fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2X3FVPROC, "glUniformMatrix2x3fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2X3FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3x2fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3X2FVPROC, "glUniformMatrix3x2fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3X2FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix2x4fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2X4FVPROC, "glUniformMatrix2x4fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2X4FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4x2fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4X2FVPROC, "glUniformMatrix4x2fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4X2FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3x4fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3X4FVPROC, "glUniformMatrix3x4fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3X4FVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4x3fvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4X3FVPROC, "glUniformMatrix4x3fv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4X3FVPROC)( location_, count_, transpose_, value_ );
}

void glColorMaskiWrapper(GLuint index_, GLboolean r_, GLboolean g_, GLboolean b_, GLboolean a_)
{
  RESOLVE(PFNGLCOLORMASKIPROC, "glColorMaski");
  RESOLVED_PROC(PFNGLCOLORMASKIPROC)( index_, r_, g_, b_, a_ );
}

void glGetBooleani_vWrapper(GLenum target_, GLuint index_, GLboolean* data_)
{
  RESOLVE(PFNGLGETBOOLEANI_VPROC, "glGetBooleani_v");
  RESOLVED_PROC(PFNGLGETBOOLEANI_VPROC)( target_, index_, data_ );
}

void glGetIntegeri_vWrapper(GLenum target_, GLuint index_, GLint* data_)
{
  RESOLVE(PFNGLGETINTEGERI_VPROC, "glGetIntegeri_v");
  RESOLVED_PROC(PFNGLGETINTEGERI_VPROC)( target_, index_, data_ );
}

void glEnableiWrapper(GLenum target_, GLuint index_)
{
  RESOLVE(PFNGLENABLEIPROC, "glEnablei");
  RESOLVED_PROC(PFNGLENABLEIPROC)( target_, index_ );
}

void glDisableiWrapper(GLenum target_, GLuint index_)
{
  RESOLVE(PFNGLDISABLEIPROC, "glDisablei");
  RESOLVED_PROC(PFNGLDISABLEIPROC)( target_, index_ );
}

GLboolean glIsEnablediWrapper(GLenum target_, GLuint index_)
{
  RESOLVE_RET(PFNGLISENABLEDIPROC, "glIsEnabledi", FALSE);
  return RESOLVED_PROC(PFNGLISENABLEDIPROC)(target_, index_ );
}

void glBeginTransformFeedbackWrapper(GLenum primitiveMode_)
{
  RESOLVE(PFNGLBEGINTRANSFORMFEEDBACKPROC, "glBeginTransformFeedback");
  RESOLVED_PROC(PFNGLBEGINTRANSFORMFEEDBACKPROC)( primitiveMode_ );
}

void glEndTransformFeedbackWrapper(void)
{
  RESOLVE(PFNGLENDTRANSFORMFEEDBACKPROC, "glEndTransformFeedback");
  RESOLVED_PROC(PFNGLENDTRANSFORMFEEDBACKPROC)(  );
}

void glBindBufferRangeWrapper(GLenum target_, GLuint index_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLBINDBUFFERRANGEPROC, "glBindBufferRange");
  RESOLVED_PROC(PFNGLBINDBUFFERRANGEPROC)( target_, index_, buffer_, offset_, size_ );
}

void glBindBufferBaseWrapper(GLenum target_, GLuint index_, GLuint buffer_)
{
  RESOLVE(PFNGLBINDBUFFERBASEPROC, "glBindBufferBase");
  RESOLVED_PROC(PFNGLBINDBUFFERBASEPROC)( target_, index_, buffer_ );
}

void glTransformFeedbackVaryingsWrapper(GLuint program_, GLsizei count_, const GLchar*const* varyings_, GLenum bufferMode_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKVARYINGSPROC, "glTransformFeedbackVaryings");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKVARYINGSPROC)( program_, count_, varyings_, bufferMode_ );
}

void glGetTransformFeedbackVaryingWrapper(GLuint program_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLsizei* size_, GLenum* type_, GLchar* name_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKVARYINGPROC, "glGetTransformFeedbackVarying");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)( program_, index_, bufSize_, length_, size_, type_, name_ );
}

void glClampColorWrapper(GLenum target_, GLenum clamp_)
{
  RESOLVE(PFNGLCLAMPCOLORPROC, "glClampColor");
  RESOLVED_PROC(PFNGLCLAMPCOLORPROC)( target_, clamp_ );
}

void glBeginConditionalRenderWrapper(GLuint id_, GLenum mode_)
{
  RESOLVE(PFNGLBEGINCONDITIONALRENDERPROC, "glBeginConditionalRender");
  RESOLVED_PROC(PFNGLBEGINCONDITIONALRENDERPROC)( id_, mode_ );
}

void glEndConditionalRenderWrapper(void)
{
  RESOLVE(PFNGLENDCONDITIONALRENDERPROC, "glEndConditionalRender");
  RESOLVED_PROC(PFNGLENDCONDITIONALRENDERPROC)(  );
}

void glVertexAttribIPointerWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBIPOINTERPROC, "glVertexAttribIPointer");
  RESOLVED_PROC(PFNGLVERTEXATTRIBIPOINTERPROC)( index_, size_, type_, stride_, pointer_ );
}

void glGetVertexAttribIivWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIIVPROC, "glGetVertexAttribIiv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIIVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribIuivWrapper(GLuint index_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIUIVPROC, "glGetVertexAttribIuiv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIUIVPROC)( index_, pname_, params_ );
}

void glVertexAttribI1iWrapper(GLuint index_, GLint x_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1IPROC, "glVertexAttribI1i");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1IPROC)( index_, x_ );
}

void glVertexAttribI2iWrapper(GLuint index_, GLint x_, GLint y_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2IPROC, "glVertexAttribI2i");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2IPROC)( index_, x_, y_ );
}

void glVertexAttribI3iWrapper(GLuint index_, GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3IPROC, "glVertexAttribI3i");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3IPROC)( index_, x_, y_, z_ );
}

void glVertexAttribI4iWrapper(GLuint index_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4IPROC, "glVertexAttribI4i");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4IPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribI1uiWrapper(GLuint index_, GLuint x_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1UIPROC, "glVertexAttribI1ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1UIPROC)( index_, x_ );
}

void glVertexAttribI2uiWrapper(GLuint index_, GLuint x_, GLuint y_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2UIPROC, "glVertexAttribI2ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2UIPROC)( index_, x_, y_ );
}

void glVertexAttribI3uiWrapper(GLuint index_, GLuint x_, GLuint y_, GLuint z_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3UIPROC, "glVertexAttribI3ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3UIPROC)( index_, x_, y_, z_ );
}

void glVertexAttribI4uiWrapper(GLuint index_, GLuint x_, GLuint y_, GLuint z_, GLuint w_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UIPROC, "glVertexAttribI4ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UIPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribI1ivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1IVPROC, "glVertexAttribI1iv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1IVPROC)( index_, v_ );
}

void glVertexAttribI2ivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2IVPROC, "glVertexAttribI2iv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2IVPROC)( index_, v_ );
}

void glVertexAttribI3ivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3IVPROC, "glVertexAttribI3iv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3IVPROC)( index_, v_ );
}

void glVertexAttribI4ivWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4IVPROC, "glVertexAttribI4iv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4IVPROC)( index_, v_ );
}

void glVertexAttribI1uivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1UIVPROC, "glVertexAttribI1uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1UIVPROC)( index_, v_ );
}

void glVertexAttribI2uivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2UIVPROC, "glVertexAttribI2uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2UIVPROC)( index_, v_ );
}

void glVertexAttribI3uivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3UIVPROC, "glVertexAttribI3uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3UIVPROC)( index_, v_ );
}

void glVertexAttribI4uivWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UIVPROC, "glVertexAttribI4uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UIVPROC)( index_, v_ );
}

void glVertexAttribI4bvWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4BVPROC, "glVertexAttribI4bv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4BVPROC)( index_, v_ );
}

void glVertexAttribI4svWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4SVPROC, "glVertexAttribI4sv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4SVPROC)( index_, v_ );
}

void glVertexAttribI4ubvWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UBVPROC, "glVertexAttribI4ubv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UBVPROC)( index_, v_ );
}

void glVertexAttribI4usvWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4USVPROC, "glVertexAttribI4usv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4USVPROC)( index_, v_ );
}

void glGetUniformuivWrapper(GLuint program_, GLint location_, GLuint* params_)
{
  RESOLVE(PFNGLGETUNIFORMUIVPROC, "glGetUniformuiv");
  RESOLVED_PROC(PFNGLGETUNIFORMUIVPROC)( program_, location_, params_ );
}

void glBindFragDataLocationWrapper(GLuint program_, GLuint color_, const GLchar* name_)
{
  RESOLVE(PFNGLBINDFRAGDATALOCATIONPROC, "glBindFragDataLocation");
  RESOLVED_PROC(PFNGLBINDFRAGDATALOCATIONPROC)( program_, color_, name_ );
}

GLint glGetFragDataLocationWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETFRAGDATALOCATIONPROC, "glGetFragDataLocation", FALSE);
  return RESOLVED_PROC(PFNGLGETFRAGDATALOCATIONPROC)(program_, name_ );
}

void glUniform1uiWrapper(GLint location_, GLuint v0_)
{
  RESOLVE(PFNGLUNIFORM1UIPROC, "glUniform1ui");
  RESOLVED_PROC(PFNGLUNIFORM1UIPROC)( location_, v0_ );
}

void glUniform2uiWrapper(GLint location_, GLuint v0_, GLuint v1_)
{
  RESOLVE(PFNGLUNIFORM2UIPROC, "glUniform2ui");
  RESOLVED_PROC(PFNGLUNIFORM2UIPROC)( location_, v0_, v1_ );
}

void glUniform3uiWrapper(GLint location_, GLuint v0_, GLuint v1_, GLuint v2_)
{
  RESOLVE(PFNGLUNIFORM3UIPROC, "glUniform3ui");
  RESOLVED_PROC(PFNGLUNIFORM3UIPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4uiWrapper(GLint location_, GLuint v0_, GLuint v1_, GLuint v2_, GLuint v3_)
{
  RESOLVE(PFNGLUNIFORM4UIPROC, "glUniform4ui");
  RESOLVED_PROC(PFNGLUNIFORM4UIPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1uivWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM1UIVPROC, "glUniform1uiv");
  RESOLVED_PROC(PFNGLUNIFORM1UIVPROC)( location_, count_, value_ );
}

void glUniform2uivWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM2UIVPROC, "glUniform2uiv");
  RESOLVED_PROC(PFNGLUNIFORM2UIVPROC)( location_, count_, value_ );
}

void glUniform3uivWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM3UIVPROC, "glUniform3uiv");
  RESOLVED_PROC(PFNGLUNIFORM3UIVPROC)( location_, count_, value_ );
}

void glUniform4uivWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM4UIVPROC, "glUniform4uiv");
  RESOLVED_PROC(PFNGLUNIFORM4UIVPROC)( location_, count_, value_ );
}

void glTexParameterIivWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLTEXPARAMETERIIVPROC, "glTexParameterIiv");
  RESOLVED_PROC(PFNGLTEXPARAMETERIIVPROC)( target_, pname_, params_ );
}

void glTexParameterIuivWrapper(GLenum target_, GLenum pname_, const GLuint* params_)
{
  RESOLVE(PFNGLTEXPARAMETERIUIVPROC, "glTexParameterIuiv");
  RESOLVED_PROC(PFNGLTEXPARAMETERIUIVPROC)( target_, pname_, params_ );
}

void glGetTexParameterIivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERIIVPROC, "glGetTexParameterIiv");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERIIVPROC)( target_, pname_, params_ );
}

void glGetTexParameterIuivWrapper(GLenum target_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERIUIVPROC, "glGetTexParameterIuiv");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERIUIVPROC)( target_, pname_, params_ );
}

void glClearBufferivWrapper(GLenum buffer_, GLint drawbuffer_, const GLint* value_)
{
  RESOLVE(PFNGLCLEARBUFFERIVPROC, "glClearBufferiv");
  RESOLVED_PROC(PFNGLCLEARBUFFERIVPROC)( buffer_, drawbuffer_, value_ );
}

void glClearBufferuivWrapper(GLenum buffer_, GLint drawbuffer_, const GLuint* value_)
{
  RESOLVE(PFNGLCLEARBUFFERUIVPROC, "glClearBufferuiv");
  RESOLVED_PROC(PFNGLCLEARBUFFERUIVPROC)( buffer_, drawbuffer_, value_ );
}

void glClearBufferfvWrapper(GLenum buffer_, GLint drawbuffer_, const GLfloat* value_)
{
  RESOLVE(PFNGLCLEARBUFFERFVPROC, "glClearBufferfv");
  RESOLVED_PROC(PFNGLCLEARBUFFERFVPROC)( buffer_, drawbuffer_, value_ );
}

void glClearBufferfiWrapper(GLenum buffer_, GLint drawbuffer_, GLfloat depth_, GLint stencil_)
{
  RESOLVE(PFNGLCLEARBUFFERFIPROC, "glClearBufferfi");
  RESOLVED_PROC(PFNGLCLEARBUFFERFIPROC)( buffer_, drawbuffer_, depth_, stencil_ );
}

const GLubyte * glGetStringiWrapper(GLenum name_, GLuint index_)
{
  RESOLVE_RET(PFNGLGETSTRINGIPROC, "glGetStringi", FALSE);
  return RESOLVED_PROC(PFNGLGETSTRINGIPROC)(name_, index_ );
}

GLboolean glIsRenderbufferWrapper(GLuint renderbuffer_)
{
  RESOLVE_RET(PFNGLISRENDERBUFFERPROC, "glIsRenderbuffer", FALSE);
  return RESOLVED_PROC(PFNGLISRENDERBUFFERPROC)(renderbuffer_ );
}

void glBindRenderbufferWrapper(GLenum target_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLBINDRENDERBUFFERPROC, "glBindRenderbuffer");
  RESOLVED_PROC(PFNGLBINDRENDERBUFFERPROC)( target_, renderbuffer_ );
}

void glDeleteRenderbuffersWrapper(GLsizei n_, const GLuint* renderbuffers_)
{
  RESOLVE(PFNGLDELETERENDERBUFFERSPROC, "glDeleteRenderbuffers");
  RESOLVED_PROC(PFNGLDELETERENDERBUFFERSPROC)( n_, renderbuffers_ );
}

void glGenRenderbuffersWrapper(GLsizei n_, GLuint* renderbuffers_)
{
  RESOLVE(PFNGLGENRENDERBUFFERSPROC, "glGenRenderbuffers");
  RESOLVED_PROC(PFNGLGENRENDERBUFFERSPROC)( n_, renderbuffers_ );
}

void glRenderbufferStorageWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLRENDERBUFFERSTORAGEPROC, "glRenderbufferStorage");
  RESOLVED_PROC(PFNGLRENDERBUFFERSTORAGEPROC)( target_, internalformat_, width_, height_ );
}

void glGetRenderbufferParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETRENDERBUFFERPARAMETERIVPROC, "glGetRenderbufferParameteriv");
  RESOLVED_PROC(PFNGLGETRENDERBUFFERPARAMETERIVPROC)( target_, pname_, params_ );
}

GLboolean glIsFramebufferWrapper(GLuint framebuffer_)
{
  RESOLVE_RET(PFNGLISFRAMEBUFFERPROC, "glIsFramebuffer", FALSE);
  return RESOLVED_PROC(PFNGLISFRAMEBUFFERPROC)(framebuffer_ );
}

void glBindFramebufferWrapper(GLenum target_, GLuint framebuffer_)
{
  RESOLVE(PFNGLBINDFRAMEBUFFERPROC, "glBindFramebuffer");
  RESOLVED_PROC(PFNGLBINDFRAMEBUFFERPROC)( target_, framebuffer_ );
}

void glDeleteFramebuffersWrapper(GLsizei n_, const GLuint* framebuffers_)
{
  RESOLVE(PFNGLDELETEFRAMEBUFFERSPROC, "glDeleteFramebuffers");
  RESOLVED_PROC(PFNGLDELETEFRAMEBUFFERSPROC)( n_, framebuffers_ );
}

void glGenFramebuffersWrapper(GLsizei n_, GLuint* framebuffers_)
{
  RESOLVE(PFNGLGENFRAMEBUFFERSPROC, "glGenFramebuffers");
  RESOLVED_PROC(PFNGLGENFRAMEBUFFERSPROC)( n_, framebuffers_ );
}

GLenum glCheckFramebufferStatusWrapper(GLenum target_)
{
  RESOLVE_RET(PFNGLCHECKFRAMEBUFFERSTATUSPROC, "glCheckFramebufferStatus", FALSE);
  return RESOLVED_PROC(PFNGLCHECKFRAMEBUFFERSTATUSPROC)(target_ );
}

void glFramebufferTexture1DWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE1DPROC, "glFramebufferTexture1D");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE1DPROC)( target_, attachment_, textarget_, texture_, level_ );
}

void glFramebufferTexture2DWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE2DPROC, "glFramebufferTexture2D");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE2DPROC)( target_, attachment_, textarget_, texture_, level_ );
}

void glFramebufferTexture3DWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_, GLint zoffset_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE3DPROC, "glFramebufferTexture3D");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE3DPROC)( target_, attachment_, textarget_, texture_, level_, zoffset_ );
}

void glFramebufferRenderbufferWrapper(GLenum target_, GLenum attachment_, GLenum renderbuffertarget_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLFRAMEBUFFERRENDERBUFFERPROC, "glFramebufferRenderbuffer");
  RESOLVED_PROC(PFNGLFRAMEBUFFERRENDERBUFFERPROC)( target_, attachment_, renderbuffertarget_, renderbuffer_ );
}

void glGetFramebufferAttachmentParameterivWrapper(GLenum target_, GLenum attachment_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC, "glGetFramebufferAttachmentParameteriv");
  RESOLVED_PROC(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)( target_, attachment_, pname_, params_ );
}

void glGenerateMipmapWrapper(GLenum target_)
{
  RESOLVE(PFNGLGENERATEMIPMAPPROC, "glGenerateMipmap");
  RESOLVED_PROC(PFNGLGENERATEMIPMAPPROC)( target_ );
}

void glBlitFramebufferWrapper(GLint srcX0_, GLint srcY0_, GLint srcX1_, GLint srcY1_, GLint dstX0_, GLint dstY0_, GLint dstX1_, GLint dstY1_, GLbitfield mask_, GLenum filter_)
{
  RESOLVE(PFNGLBLITFRAMEBUFFERPROC, "glBlitFramebuffer");
  RESOLVED_PROC(PFNGLBLITFRAMEBUFFERPROC)( srcX0_, srcY0_, srcX1_, srcY1_, dstX0_, dstY0_, dstX1_, dstY1_, mask_, filter_ );
}

void glRenderbufferStorageMultisampleWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC, "glRenderbufferStorageMultisample");
  RESOLVED_PROC(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)( target_, samples_, internalformat_, width_, height_ );
}

void glFramebufferTextureLayerWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLint layer_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURELAYERPROC, "glFramebufferTextureLayer");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURELAYERPROC)( target_, attachment_, texture_, level_, layer_ );
}

void * glMapBufferRangeWrapper(GLenum target_, GLintptr offset_, GLsizeiptr length_, GLbitfield access_)
{
  RESOLVE_RET(PFNGLMAPBUFFERRANGEPROC, "glMapBufferRange", FALSE);
  return RESOLVED_PROC(PFNGLMAPBUFFERRANGEPROC)(target_, offset_, length_, access_ );
}

void glFlushMappedBufferRangeWrapper(GLenum target_, GLintptr offset_, GLsizeiptr length_)
{
  RESOLVE(PFNGLFLUSHMAPPEDBUFFERRANGEPROC, "glFlushMappedBufferRange");
  RESOLVED_PROC(PFNGLFLUSHMAPPEDBUFFERRANGEPROC)( target_, offset_, length_ );
}

void glBindVertexArrayWrapper(GLuint array_)
{
  RESOLVE(PFNGLBINDVERTEXARRAYPROC, "glBindVertexArray");
  RESOLVED_PROC(PFNGLBINDVERTEXARRAYPROC)( array_ );
}

void glDeleteVertexArraysWrapper(GLsizei n_, const GLuint* arrays_)
{
  RESOLVE(PFNGLDELETEVERTEXARRAYSPROC, "glDeleteVertexArrays");
  RESOLVED_PROC(PFNGLDELETEVERTEXARRAYSPROC)( n_, arrays_ );
}

void glGenVertexArraysWrapper(GLsizei n_, GLuint* arrays_)
{
  RESOLVE(PFNGLGENVERTEXARRAYSPROC, "glGenVertexArrays");
  RESOLVED_PROC(PFNGLGENVERTEXARRAYSPROC)( n_, arrays_ );
}

GLboolean glIsVertexArrayWrapper(GLuint array_)
{
  RESOLVE_RET(PFNGLISVERTEXARRAYPROC, "glIsVertexArray", FALSE);
  return RESOLVED_PROC(PFNGLISVERTEXARRAYPROC)(array_ );
}

void glDrawArraysInstancedWrapper(GLenum mode_, GLint first_, GLsizei count_, GLsizei instancecount_)
{
  RESOLVE(PFNGLDRAWARRAYSINSTANCEDPROC, "glDrawArraysInstanced");
  RESOLVED_PROC(PFNGLDRAWARRAYSINSTANCEDPROC)( mode_, first_, count_, instancecount_ );
}

void glDrawElementsInstancedWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei instancecount_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDPROC, "glDrawElementsInstanced");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDPROC)( mode_, count_, type_, indices_, instancecount_ );
}

void glTexBufferWrapper(GLenum target_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLTEXBUFFERPROC, "glTexBuffer");
  RESOLVED_PROC(PFNGLTEXBUFFERPROC)( target_, internalformat_, buffer_ );
}

void glPrimitiveRestartIndexWrapper(GLuint index_)
{
  RESOLVE(PFNGLPRIMITIVERESTARTINDEXPROC, "glPrimitiveRestartIndex");
  RESOLVED_PROC(PFNGLPRIMITIVERESTARTINDEXPROC)( index_ );
}

void glCopyBufferSubDataWrapper(GLenum readTarget_, GLenum writeTarget_, GLintptr readOffset_, GLintptr writeOffset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLCOPYBUFFERSUBDATAPROC, "glCopyBufferSubData");
  RESOLVED_PROC(PFNGLCOPYBUFFERSUBDATAPROC)( readTarget_, writeTarget_, readOffset_, writeOffset_, size_ );
}

void glGetUniformIndicesWrapper(GLuint program_, GLsizei uniformCount_, const GLchar*const* uniformNames_, GLuint* uniformIndices_)
{
  RESOLVE(PFNGLGETUNIFORMINDICESPROC, "glGetUniformIndices");
  RESOLVED_PROC(PFNGLGETUNIFORMINDICESPROC)( program_, uniformCount_, uniformNames_, uniformIndices_ );
}

void glGetActiveUniformsivWrapper(GLuint program_, GLsizei uniformCount_, const GLuint* uniformIndices_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMSIVPROC, "glGetActiveUniformsiv");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMSIVPROC)( program_, uniformCount_, uniformIndices_, pname_, params_ );
}

void glGetActiveUniformNameWrapper(GLuint program_, GLuint uniformIndex_, GLsizei bufSize_, GLsizei* length_, GLchar* uniformName_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMNAMEPROC, "glGetActiveUniformName");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMNAMEPROC)( program_, uniformIndex_, bufSize_, length_, uniformName_ );
}

GLuint glGetUniformBlockIndexWrapper(GLuint program_, const GLchar* uniformBlockName_)
{
  RESOLVE_RET(PFNGLGETUNIFORMBLOCKINDEXPROC, "glGetUniformBlockIndex", FALSE);
  return RESOLVED_PROC(PFNGLGETUNIFORMBLOCKINDEXPROC)(program_, uniformBlockName_ );
}

void glGetActiveUniformBlockivWrapper(GLuint program_, GLuint uniformBlockIndex_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMBLOCKIVPROC, "glGetActiveUniformBlockiv");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMBLOCKIVPROC)( program_, uniformBlockIndex_, pname_, params_ );
}

void glGetActiveUniformBlockNameWrapper(GLuint program_, GLuint uniformBlockIndex_, GLsizei bufSize_, GLsizei* length_, GLchar* uniformBlockName_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC, "glGetActiveUniformBlockName");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)( program_, uniformBlockIndex_, bufSize_, length_, uniformBlockName_ );
}

void glUniformBlockBindingWrapper(GLuint program_, GLuint uniformBlockIndex_, GLuint uniformBlockBinding_)
{
  RESOLVE(PFNGLUNIFORMBLOCKBINDINGPROC, "glUniformBlockBinding");
  RESOLVED_PROC(PFNGLUNIFORMBLOCKBINDINGPROC)( program_, uniformBlockIndex_, uniformBlockBinding_ );
}

void glDrawElementsBaseVertexWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLint basevertex_)
{
  RESOLVE(PFNGLDRAWELEMENTSBASEVERTEXPROC, "glDrawElementsBaseVertex");
  RESOLVED_PROC(PFNGLDRAWELEMENTSBASEVERTEXPROC)( mode_, count_, type_, indices_, basevertex_ );
}

void glDrawRangeElementsBaseVertexWrapper(GLenum mode_, GLuint start_, GLuint end_, GLsizei count_, GLenum type_, const void * indices_, GLint basevertex_)
{
  RESOLVE(PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC, "glDrawRangeElementsBaseVertex");
  RESOLVED_PROC(PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)( mode_, start_, end_, count_, type_, indices_, basevertex_ );
}

void glDrawElementsInstancedBaseVertexWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei instancecount_, GLint basevertex_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC, "glDrawElementsInstancedBaseVertex");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)( mode_, count_, type_, indices_, instancecount_, basevertex_ );
}

void glMultiDrawElementsBaseVertexWrapper(GLenum mode_, const GLsizei* count_, GLenum type_, const void *const* indices_, GLsizei drawcount_, const GLint* basevertex_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC, "glMultiDrawElementsBaseVertex");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)( mode_, count_, type_, indices_, drawcount_, basevertex_ );
}

void glProvokingVertexWrapper(GLenum mode_)
{
  RESOLVE(PFNGLPROVOKINGVERTEXPROC, "glProvokingVertex");
  RESOLVED_PROC(PFNGLPROVOKINGVERTEXPROC)( mode_ );
}

GLsync glFenceSyncWrapper(GLenum condition_, GLbitfield flags_)
{
  RESOLVE_RET(PFNGLFENCESYNCPROC, "glFenceSync", FALSE);
  return RESOLVED_PROC(PFNGLFENCESYNCPROC)(condition_, flags_ );
}

GLboolean glIsSyncWrapper(GLsync sync_)
{
  RESOLVE_RET(PFNGLISSYNCPROC, "glIsSync", FALSE);
  return RESOLVED_PROC(PFNGLISSYNCPROC)(sync_ );
}

void glDeleteSyncWrapper(GLsync sync_)
{
  RESOLVE(PFNGLDELETESYNCPROC, "glDeleteSync");
  RESOLVED_PROC(PFNGLDELETESYNCPROC)( sync_ );
}

GLenum glClientWaitSyncWrapper(GLsync sync_, GLbitfield flags_, GLuint64 timeout_)
{
  RESOLVE_RET(PFNGLCLIENTWAITSYNCPROC, "glClientWaitSync", FALSE);
  return RESOLVED_PROC(PFNGLCLIENTWAITSYNCPROC)(sync_, flags_, timeout_ );
}

void glWaitSyncWrapper(GLsync sync_, GLbitfield flags_, GLuint64 timeout_)
{
  RESOLVE(PFNGLWAITSYNCPROC, "glWaitSync");
  RESOLVED_PROC(PFNGLWAITSYNCPROC)( sync_, flags_, timeout_ );
}

void glGetInteger64vWrapper(GLenum pname_, GLint64* data_)
{
  RESOLVE(PFNGLGETINTEGER64VPROC, "glGetInteger64v");
  RESOLVED_PROC(PFNGLGETINTEGER64VPROC)( pname_, data_ );
}

void glGetSyncivWrapper(GLsync sync_, GLenum pname_, GLsizei bufSize_, GLsizei* length_, GLint* values_)
{
  RESOLVE(PFNGLGETSYNCIVPROC, "glGetSynciv");
  RESOLVED_PROC(PFNGLGETSYNCIVPROC)( sync_, pname_, bufSize_, length_, values_ );
}

void glGetInteger64i_vWrapper(GLenum target_, GLuint index_, GLint64* data_)
{
  RESOLVE(PFNGLGETINTEGER64I_VPROC, "glGetInteger64i_v");
  RESOLVED_PROC(PFNGLGETINTEGER64I_VPROC)( target_, index_, data_ );
}

void glGetBufferParameteri64vWrapper(GLenum target_, GLenum pname_, GLint64* params_)
{
  RESOLVE(PFNGLGETBUFFERPARAMETERI64VPROC, "glGetBufferParameteri64v");
  RESOLVED_PROC(PFNGLGETBUFFERPARAMETERI64VPROC)( target_, pname_, params_ );
}

void glFramebufferTextureWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREPROC, "glFramebufferTexture");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREPROC)( target_, attachment_, texture_, level_ );
}

void glTexImage2DMultisampleWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXIMAGE2DMULTISAMPLEPROC, "glTexImage2DMultisample");
  RESOLVED_PROC(PFNGLTEXIMAGE2DMULTISAMPLEPROC)( target_, samples_, internalformat_, width_, height_, fixedsamplelocations_ );
}

void glTexImage3DMultisampleWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXIMAGE3DMULTISAMPLEPROC, "glTexImage3DMultisample");
  RESOLVED_PROC(PFNGLTEXIMAGE3DMULTISAMPLEPROC)( target_, samples_, internalformat_, width_, height_, depth_, fixedsamplelocations_ );
}

void glGetMultisamplefvWrapper(GLenum pname_, GLuint index_, GLfloat* val_)
{
  RESOLVE(PFNGLGETMULTISAMPLEFVPROC, "glGetMultisamplefv");
  RESOLVED_PROC(PFNGLGETMULTISAMPLEFVPROC)( pname_, index_, val_ );
}

void glSampleMaskiWrapper(GLuint maskNumber_, GLbitfield mask_)
{
  RESOLVE(PFNGLSAMPLEMASKIPROC, "glSampleMaski");
  RESOLVED_PROC(PFNGLSAMPLEMASKIPROC)( maskNumber_, mask_ );
}

void glBindFragDataLocationIndexedWrapper(GLuint program_, GLuint colorNumber_, GLuint index_, const GLchar* name_)
{
  RESOLVE(PFNGLBINDFRAGDATALOCATIONINDEXEDPROC, "glBindFragDataLocationIndexed");
  RESOLVED_PROC(PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)( program_, colorNumber_, index_, name_ );
}

GLint glGetFragDataIndexWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETFRAGDATAINDEXPROC, "glGetFragDataIndex", FALSE);
  return RESOLVED_PROC(PFNGLGETFRAGDATAINDEXPROC)(program_, name_ );
}

void glGenSamplersWrapper(GLsizei count_, GLuint* samplers_)
{
  RESOLVE(PFNGLGENSAMPLERSPROC, "glGenSamplers");
  RESOLVED_PROC(PFNGLGENSAMPLERSPROC)( count_, samplers_ );
}

void glDeleteSamplersWrapper(GLsizei count_, const GLuint* samplers_)
{
  RESOLVE(PFNGLDELETESAMPLERSPROC, "glDeleteSamplers");
  RESOLVED_PROC(PFNGLDELETESAMPLERSPROC)( count_, samplers_ );
}

GLboolean glIsSamplerWrapper(GLuint sampler_)
{
  RESOLVE_RET(PFNGLISSAMPLERPROC, "glIsSampler", FALSE);
  return RESOLVED_PROC(PFNGLISSAMPLERPROC)(sampler_ );
}

void glBindSamplerWrapper(GLuint unit_, GLuint sampler_)
{
  RESOLVE(PFNGLBINDSAMPLERPROC, "glBindSampler");
  RESOLVED_PROC(PFNGLBINDSAMPLERPROC)( unit_, sampler_ );
}

void glSamplerParameteriWrapper(GLuint sampler_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERIPROC, "glSamplerParameteri");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERIPROC)( sampler_, pname_, param_ );
}

void glSamplerParameterivWrapper(GLuint sampler_, GLenum pname_, const GLint* param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERIVPROC, "glSamplerParameteriv");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERIVPROC)( sampler_, pname_, param_ );
}

void glSamplerParameterfWrapper(GLuint sampler_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERFPROC, "glSamplerParameterf");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERFPROC)( sampler_, pname_, param_ );
}

void glSamplerParameterfvWrapper(GLuint sampler_, GLenum pname_, const GLfloat* param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERFVPROC, "glSamplerParameterfv");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERFVPROC)( sampler_, pname_, param_ );
}

void glSamplerParameterIivWrapper(GLuint sampler_, GLenum pname_, const GLint* param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERIIVPROC, "glSamplerParameterIiv");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERIIVPROC)( sampler_, pname_, param_ );
}

void glSamplerParameterIuivWrapper(GLuint sampler_, GLenum pname_, const GLuint* param_)
{
  RESOLVE(PFNGLSAMPLERPARAMETERIUIVPROC, "glSamplerParameterIuiv");
  RESOLVED_PROC(PFNGLSAMPLERPARAMETERIUIVPROC)( sampler_, pname_, param_ );
}

void glGetSamplerParameterivWrapper(GLuint sampler_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETSAMPLERPARAMETERIVPROC, "glGetSamplerParameteriv");
  RESOLVED_PROC(PFNGLGETSAMPLERPARAMETERIVPROC)( sampler_, pname_, params_ );
}

void glGetSamplerParameterIivWrapper(GLuint sampler_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETSAMPLERPARAMETERIIVPROC, "glGetSamplerParameterIiv");
  RESOLVED_PROC(PFNGLGETSAMPLERPARAMETERIIVPROC)( sampler_, pname_, params_ );
}

void glGetSamplerParameterfvWrapper(GLuint sampler_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETSAMPLERPARAMETERFVPROC, "glGetSamplerParameterfv");
  RESOLVED_PROC(PFNGLGETSAMPLERPARAMETERFVPROC)( sampler_, pname_, params_ );
}

void glGetSamplerParameterIuivWrapper(GLuint sampler_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETSAMPLERPARAMETERIUIVPROC, "glGetSamplerParameterIuiv");
  RESOLVED_PROC(PFNGLGETSAMPLERPARAMETERIUIVPROC)( sampler_, pname_, params_ );
}

void glQueryCounterWrapper(GLuint id_, GLenum target_)
{
  RESOLVE(PFNGLQUERYCOUNTERPROC, "glQueryCounter");
  RESOLVED_PROC(PFNGLQUERYCOUNTERPROC)( id_, target_ );
}

void glGetQueryObjecti64vWrapper(GLuint id_, GLenum pname_, GLint64* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTI64VPROC, "glGetQueryObjecti64v");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTI64VPROC)( id_, pname_, params_ );
}

void glGetQueryObjectui64vWrapper(GLuint id_, GLenum pname_, GLuint64* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTUI64VPROC, "glGetQueryObjectui64v");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTUI64VPROC)( id_, pname_, params_ );
}

void glVertexAttribDivisorWrapper(GLuint index_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXATTRIBDIVISORPROC, "glVertexAttribDivisor");
  RESOLVED_PROC(PFNGLVERTEXATTRIBDIVISORPROC)( index_, divisor_ );
}

void glVertexAttribP1uiWrapper(GLuint index_, GLenum type_, GLboolean normalized_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP1UIPROC, "glVertexAttribP1ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP1UIPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP1uivWrapper(GLuint index_, GLenum type_, GLboolean normalized_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP1UIVPROC, "glVertexAttribP1uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP1UIVPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP2uiWrapper(GLuint index_, GLenum type_, GLboolean normalized_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP2UIPROC, "glVertexAttribP2ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP2UIPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP2uivWrapper(GLuint index_, GLenum type_, GLboolean normalized_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP2UIVPROC, "glVertexAttribP2uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP2UIVPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP3uiWrapper(GLuint index_, GLenum type_, GLboolean normalized_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP3UIPROC, "glVertexAttribP3ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP3UIPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP3uivWrapper(GLuint index_, GLenum type_, GLboolean normalized_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP3UIVPROC, "glVertexAttribP3uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP3UIVPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP4uiWrapper(GLuint index_, GLenum type_, GLboolean normalized_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP4UIPROC, "glVertexAttribP4ui");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP4UIPROC)( index_, type_, normalized_, value_ );
}

void glVertexAttribP4uivWrapper(GLuint index_, GLenum type_, GLboolean normalized_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXATTRIBP4UIVPROC, "glVertexAttribP4uiv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBP4UIVPROC)( index_, type_, normalized_, value_ );
}

void glVertexP2uiWrapper(GLenum type_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXP2UIPROC, "glVertexP2ui");
  RESOLVED_PROC(PFNGLVERTEXP2UIPROC)( type_, value_ );
}

void glVertexP2uivWrapper(GLenum type_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXP2UIVPROC, "glVertexP2uiv");
  RESOLVED_PROC(PFNGLVERTEXP2UIVPROC)( type_, value_ );
}

void glVertexP3uiWrapper(GLenum type_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXP3UIPROC, "glVertexP3ui");
  RESOLVED_PROC(PFNGLVERTEXP3UIPROC)( type_, value_ );
}

void glVertexP3uivWrapper(GLenum type_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXP3UIVPROC, "glVertexP3uiv");
  RESOLVED_PROC(PFNGLVERTEXP3UIVPROC)( type_, value_ );
}

void glVertexP4uiWrapper(GLenum type_, GLuint value_)
{
  RESOLVE(PFNGLVERTEXP4UIPROC, "glVertexP4ui");
  RESOLVED_PROC(PFNGLVERTEXP4UIPROC)( type_, value_ );
}

void glVertexP4uivWrapper(GLenum type_, const GLuint* value_)
{
  RESOLVE(PFNGLVERTEXP4UIVPROC, "glVertexP4uiv");
  RESOLVED_PROC(PFNGLVERTEXP4UIVPROC)( type_, value_ );
}

void glTexCoordP1uiWrapper(GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLTEXCOORDP1UIPROC, "glTexCoordP1ui");
  RESOLVED_PROC(PFNGLTEXCOORDP1UIPROC)( type_, coords_ );
}

void glTexCoordP1uivWrapper(GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLTEXCOORDP1UIVPROC, "glTexCoordP1uiv");
  RESOLVED_PROC(PFNGLTEXCOORDP1UIVPROC)( type_, coords_ );
}

void glTexCoordP2uiWrapper(GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLTEXCOORDP2UIPROC, "glTexCoordP2ui");
  RESOLVED_PROC(PFNGLTEXCOORDP2UIPROC)( type_, coords_ );
}

void glTexCoordP2uivWrapper(GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLTEXCOORDP2UIVPROC, "glTexCoordP2uiv");
  RESOLVED_PROC(PFNGLTEXCOORDP2UIVPROC)( type_, coords_ );
}

void glTexCoordP3uiWrapper(GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLTEXCOORDP3UIPROC, "glTexCoordP3ui");
  RESOLVED_PROC(PFNGLTEXCOORDP3UIPROC)( type_, coords_ );
}

void glTexCoordP3uivWrapper(GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLTEXCOORDP3UIVPROC, "glTexCoordP3uiv");
  RESOLVED_PROC(PFNGLTEXCOORDP3UIVPROC)( type_, coords_ );
}

void glTexCoordP4uiWrapper(GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLTEXCOORDP4UIPROC, "glTexCoordP4ui");
  RESOLVED_PROC(PFNGLTEXCOORDP4UIPROC)( type_, coords_ );
}

void glTexCoordP4uivWrapper(GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLTEXCOORDP4UIVPROC, "glTexCoordP4uiv");
  RESOLVED_PROC(PFNGLTEXCOORDP4UIVPROC)( type_, coords_ );
}

void glMultiTexCoordP1uiWrapper(GLenum texture_, GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP1UIPROC, "glMultiTexCoordP1ui");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP1UIPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP1uivWrapper(GLenum texture_, GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP1UIVPROC, "glMultiTexCoordP1uiv");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP1UIVPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP2uiWrapper(GLenum texture_, GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP2UIPROC, "glMultiTexCoordP2ui");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP2UIPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP2uivWrapper(GLenum texture_, GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP2UIVPROC, "glMultiTexCoordP2uiv");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP2UIVPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP3uiWrapper(GLenum texture_, GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP3UIPROC, "glMultiTexCoordP3ui");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP3UIPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP3uivWrapper(GLenum texture_, GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP3UIVPROC, "glMultiTexCoordP3uiv");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP3UIVPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP4uiWrapper(GLenum texture_, GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP4UIPROC, "glMultiTexCoordP4ui");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP4UIPROC)( texture_, type_, coords_ );
}

void glMultiTexCoordP4uivWrapper(GLenum texture_, GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORDP4UIVPROC, "glMultiTexCoordP4uiv");
  RESOLVED_PROC(PFNGLMULTITEXCOORDP4UIVPROC)( texture_, type_, coords_ );
}

void glNormalP3uiWrapper(GLenum type_, GLuint coords_)
{
  RESOLVE(PFNGLNORMALP3UIPROC, "glNormalP3ui");
  RESOLVED_PROC(PFNGLNORMALP3UIPROC)( type_, coords_ );
}

void glNormalP3uivWrapper(GLenum type_, const GLuint* coords_)
{
  RESOLVE(PFNGLNORMALP3UIVPROC, "glNormalP3uiv");
  RESOLVED_PROC(PFNGLNORMALP3UIVPROC)( type_, coords_ );
}

void glColorP3uiWrapper(GLenum type_, GLuint color_)
{
  RESOLVE(PFNGLCOLORP3UIPROC, "glColorP3ui");
  RESOLVED_PROC(PFNGLCOLORP3UIPROC)( type_, color_ );
}

void glColorP3uivWrapper(GLenum type_, const GLuint* color_)
{
  RESOLVE(PFNGLCOLORP3UIVPROC, "glColorP3uiv");
  RESOLVED_PROC(PFNGLCOLORP3UIVPROC)( type_, color_ );
}

void glColorP4uiWrapper(GLenum type_, GLuint color_)
{
  RESOLVE(PFNGLCOLORP4UIPROC, "glColorP4ui");
  RESOLVED_PROC(PFNGLCOLORP4UIPROC)( type_, color_ );
}

void glColorP4uivWrapper(GLenum type_, const GLuint* color_)
{
  RESOLVE(PFNGLCOLORP4UIVPROC, "glColorP4uiv");
  RESOLVED_PROC(PFNGLCOLORP4UIVPROC)( type_, color_ );
}

void glSecondaryColorP3uiWrapper(GLenum type_, GLuint color_)
{
  RESOLVE(PFNGLSECONDARYCOLORP3UIPROC, "glSecondaryColorP3ui");
  RESOLVED_PROC(PFNGLSECONDARYCOLORP3UIPROC)( type_, color_ );
}

void glSecondaryColorP3uivWrapper(GLenum type_, const GLuint* color_)
{
  RESOLVE(PFNGLSECONDARYCOLORP3UIVPROC, "glSecondaryColorP3uiv");
  RESOLVED_PROC(PFNGLSECONDARYCOLORP3UIVPROC)( type_, color_ );
}

void glMinSampleShadingWrapper(GLfloat value_)
{
  RESOLVE(PFNGLMINSAMPLESHADINGPROC, "glMinSampleShading");
  RESOLVED_PROC(PFNGLMINSAMPLESHADINGPROC)( value_ );
}

void glBlendEquationiWrapper(GLuint buf_, GLenum mode_)
{
  RESOLVE(PFNGLBLENDEQUATIONIPROC, "glBlendEquationi");
  RESOLVED_PROC(PFNGLBLENDEQUATIONIPROC)( buf_, mode_ );
}

void glBlendEquationSeparateiWrapper(GLuint buf_, GLenum modeRGB_, GLenum modeAlpha_)
{
  RESOLVE(PFNGLBLENDEQUATIONSEPARATEIPROC, "glBlendEquationSeparatei");
  RESOLVED_PROC(PFNGLBLENDEQUATIONSEPARATEIPROC)( buf_, modeRGB_, modeAlpha_ );
}

void glBlendFunciWrapper(GLuint buf_, GLenum src_, GLenum dst_)
{
  RESOLVE(PFNGLBLENDFUNCIPROC, "glBlendFunci");
  RESOLVED_PROC(PFNGLBLENDFUNCIPROC)( buf_, src_, dst_ );
}

void glBlendFuncSeparateiWrapper(GLuint buf_, GLenum srcRGB_, GLenum dstRGB_, GLenum srcAlpha_, GLenum dstAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEIPROC, "glBlendFuncSeparatei");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEIPROC)( buf_, srcRGB_, dstRGB_, srcAlpha_, dstAlpha_ );
}

void glDrawArraysIndirectWrapper(GLenum mode_, const void * indirect_)
{
  RESOLVE(PFNGLDRAWARRAYSINDIRECTPROC, "glDrawArraysIndirect");
  RESOLVED_PROC(PFNGLDRAWARRAYSINDIRECTPROC)( mode_, indirect_ );
}

void glDrawElementsIndirectWrapper(GLenum mode_, GLenum type_, const void * indirect_)
{
  RESOLVE(PFNGLDRAWELEMENTSINDIRECTPROC, "glDrawElementsIndirect");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINDIRECTPROC)( mode_, type_, indirect_ );
}

void glUniform1dWrapper(GLint location_, GLdouble x_)
{
  RESOLVE(PFNGLUNIFORM1DPROC, "glUniform1d");
  RESOLVED_PROC(PFNGLUNIFORM1DPROC)( location_, x_ );
}

void glUniform2dWrapper(GLint location_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLUNIFORM2DPROC, "glUniform2d");
  RESOLVED_PROC(PFNGLUNIFORM2DPROC)( location_, x_, y_ );
}

void glUniform3dWrapper(GLint location_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLUNIFORM3DPROC, "glUniform3d");
  RESOLVED_PROC(PFNGLUNIFORM3DPROC)( location_, x_, y_, z_ );
}

void glUniform4dWrapper(GLint location_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLUNIFORM4DPROC, "glUniform4d");
  RESOLVED_PROC(PFNGLUNIFORM4DPROC)( location_, x_, y_, z_, w_ );
}

void glUniform1dvWrapper(GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORM1DVPROC, "glUniform1dv");
  RESOLVED_PROC(PFNGLUNIFORM1DVPROC)( location_, count_, value_ );
}

void glUniform2dvWrapper(GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORM2DVPROC, "glUniform2dv");
  RESOLVED_PROC(PFNGLUNIFORM2DVPROC)( location_, count_, value_ );
}

void glUniform3dvWrapper(GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORM3DVPROC, "glUniform3dv");
  RESOLVED_PROC(PFNGLUNIFORM3DVPROC)( location_, count_, value_ );
}

void glUniform4dvWrapper(GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORM4DVPROC, "glUniform4dv");
  RESOLVED_PROC(PFNGLUNIFORM4DVPROC)( location_, count_, value_ );
}

void glUniformMatrix2dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2DVPROC, "glUniformMatrix2dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3DVPROC, "glUniformMatrix3dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4DVPROC, "glUniformMatrix4dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix2x3dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2X3DVPROC, "glUniformMatrix2x3dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2X3DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix2x4dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2X4DVPROC, "glUniformMatrix2x4dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2X4DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3x2dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3X2DVPROC, "glUniformMatrix3x2dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3X2DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3x4dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3X4DVPROC, "glUniformMatrix3x4dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3X4DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4x2dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4X2DVPROC, "glUniformMatrix4x2dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4X2DVPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4x3dvWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4X3DVPROC, "glUniformMatrix4x3dv");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4X3DVPROC)( location_, count_, transpose_, value_ );
}

void glGetUniformdvWrapper(GLuint program_, GLint location_, GLdouble* params_)
{
  RESOLVE(PFNGLGETUNIFORMDVPROC, "glGetUniformdv");
  RESOLVED_PROC(PFNGLGETUNIFORMDVPROC)( program_, location_, params_ );
}

GLint glGetSubroutineUniformLocationWrapper(GLuint program_, GLenum shadertype_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC, "glGetSubroutineUniformLocation", FALSE);
  return RESOLVED_PROC(PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)(program_, shadertype_, name_ );
}

GLuint glGetSubroutineIndexWrapper(GLuint program_, GLenum shadertype_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETSUBROUTINEINDEXPROC, "glGetSubroutineIndex", FALSE);
  return RESOLVED_PROC(PFNGLGETSUBROUTINEINDEXPROC)(program_, shadertype_, name_ );
}

void glGetActiveSubroutineUniformivWrapper(GLuint program_, GLenum shadertype_, GLuint index_, GLenum pname_, GLint* values_)
{
  RESOLVE(PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC, "glGetActiveSubroutineUniformiv");
  RESOLVED_PROC(PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)( program_, shadertype_, index_, pname_, values_ );
}

void glGetActiveSubroutineUniformNameWrapper(GLuint program_, GLenum shadertype_, GLuint index_, GLsizei bufsize_, GLsizei* length_, GLchar* name_)
{
  RESOLVE(PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC, "glGetActiveSubroutineUniformName");
  RESOLVED_PROC(PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)( program_, shadertype_, index_, bufsize_, length_, name_ );
}

void glGetActiveSubroutineNameWrapper(GLuint program_, GLenum shadertype_, GLuint index_, GLsizei bufsize_, GLsizei* length_, GLchar* name_)
{
  RESOLVE(PFNGLGETACTIVESUBROUTINENAMEPROC, "glGetActiveSubroutineName");
  RESOLVED_PROC(PFNGLGETACTIVESUBROUTINENAMEPROC)( program_, shadertype_, index_, bufsize_, length_, name_ );
}

void glUniformSubroutinesuivWrapper(GLenum shadertype_, GLsizei count_, const GLuint* indices_)
{
  RESOLVE(PFNGLUNIFORMSUBROUTINESUIVPROC, "glUniformSubroutinesuiv");
  RESOLVED_PROC(PFNGLUNIFORMSUBROUTINESUIVPROC)( shadertype_, count_, indices_ );
}

void glGetUniformSubroutineuivWrapper(GLenum shadertype_, GLint location_, GLuint* params_)
{
  RESOLVE(PFNGLGETUNIFORMSUBROUTINEUIVPROC, "glGetUniformSubroutineuiv");
  RESOLVED_PROC(PFNGLGETUNIFORMSUBROUTINEUIVPROC)( shadertype_, location_, params_ );
}

void glGetProgramStageivWrapper(GLuint program_, GLenum shadertype_, GLenum pname_, GLint* values_)
{
  RESOLVE(PFNGLGETPROGRAMSTAGEIVPROC, "glGetProgramStageiv");
  RESOLVED_PROC(PFNGLGETPROGRAMSTAGEIVPROC)( program_, shadertype_, pname_, values_ );
}

void glPatchParameteriWrapper(GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLPATCHPARAMETERIPROC, "glPatchParameteri");
  RESOLVED_PROC(PFNGLPATCHPARAMETERIPROC)( pname_, value_ );
}

void glPatchParameterfvWrapper(GLenum pname_, const GLfloat* values_)
{
  RESOLVE(PFNGLPATCHPARAMETERFVPROC, "glPatchParameterfv");
  RESOLVED_PROC(PFNGLPATCHPARAMETERFVPROC)( pname_, values_ );
}

void glBindTransformFeedbackWrapper(GLenum target_, GLuint id_)
{
  RESOLVE(PFNGLBINDTRANSFORMFEEDBACKPROC, "glBindTransformFeedback");
  RESOLVED_PROC(PFNGLBINDTRANSFORMFEEDBACKPROC)( target_, id_ );
}

void glDeleteTransformFeedbacksWrapper(GLsizei n_, const GLuint* ids_)
{
  RESOLVE(PFNGLDELETETRANSFORMFEEDBACKSPROC, "glDeleteTransformFeedbacks");
  RESOLVED_PROC(PFNGLDELETETRANSFORMFEEDBACKSPROC)( n_, ids_ );
}

void glGenTransformFeedbacksWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLGENTRANSFORMFEEDBACKSPROC, "glGenTransformFeedbacks");
  RESOLVED_PROC(PFNGLGENTRANSFORMFEEDBACKSPROC)( n_, ids_ );
}

GLboolean glIsTransformFeedbackWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISTRANSFORMFEEDBACKPROC, "glIsTransformFeedback", FALSE);
  return RESOLVED_PROC(PFNGLISTRANSFORMFEEDBACKPROC)(id_ );
}

void glPauseTransformFeedbackWrapper(void)
{
  RESOLVE(PFNGLPAUSETRANSFORMFEEDBACKPROC, "glPauseTransformFeedback");
  RESOLVED_PROC(PFNGLPAUSETRANSFORMFEEDBACKPROC)(  );
}

void glResumeTransformFeedbackWrapper(void)
{
  RESOLVE(PFNGLRESUMETRANSFORMFEEDBACKPROC, "glResumeTransformFeedback");
  RESOLVED_PROC(PFNGLRESUMETRANSFORMFEEDBACKPROC)(  );
}

void glDrawTransformFeedbackWrapper(GLenum mode_, GLuint id_)
{
  RESOLVE(PFNGLDRAWTRANSFORMFEEDBACKPROC, "glDrawTransformFeedback");
  RESOLVED_PROC(PFNGLDRAWTRANSFORMFEEDBACKPROC)( mode_, id_ );
}

void glDrawTransformFeedbackStreamWrapper(GLenum mode_, GLuint id_, GLuint stream_)
{
  RESOLVE(PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC, "glDrawTransformFeedbackStream");
  RESOLVED_PROC(PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)( mode_, id_, stream_ );
}

void glBeginQueryIndexedWrapper(GLenum target_, GLuint index_, GLuint id_)
{
  RESOLVE(PFNGLBEGINQUERYINDEXEDPROC, "glBeginQueryIndexed");
  RESOLVED_PROC(PFNGLBEGINQUERYINDEXEDPROC)( target_, index_, id_ );
}

void glEndQueryIndexedWrapper(GLenum target_, GLuint index_)
{
  RESOLVE(PFNGLENDQUERYINDEXEDPROC, "glEndQueryIndexed");
  RESOLVED_PROC(PFNGLENDQUERYINDEXEDPROC)( target_, index_ );
}

void glGetQueryIndexedivWrapper(GLenum target_, GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETQUERYINDEXEDIVPROC, "glGetQueryIndexediv");
  RESOLVED_PROC(PFNGLGETQUERYINDEXEDIVPROC)( target_, index_, pname_, params_ );
}

void glReleaseShaderCompilerWrapper(void)
{
  RESOLVE(PFNGLRELEASESHADERCOMPILERPROC, "glReleaseShaderCompiler");
  RESOLVED_PROC(PFNGLRELEASESHADERCOMPILERPROC)(  );
}

void glShaderBinaryWrapper(GLsizei count_, const GLuint* shaders_, GLenum binaryformat_, const void * binary_, GLsizei length_)
{
  RESOLVE(PFNGLSHADERBINARYPROC, "glShaderBinary");
  RESOLVED_PROC(PFNGLSHADERBINARYPROC)( count_, shaders_, binaryformat_, binary_, length_ );
}

void glGetShaderPrecisionFormatWrapper(GLenum shadertype_, GLenum precisiontype_, GLint* range_, GLint* precision_)
{
  RESOLVE(PFNGLGETSHADERPRECISIONFORMATPROC, "glGetShaderPrecisionFormat");
  RESOLVED_PROC(PFNGLGETSHADERPRECISIONFORMATPROC)( shadertype_, precisiontype_, range_, precision_ );
}

void glDepthRangefWrapper(GLfloat n_, GLfloat f_)
{
  RESOLVE(PFNGLDEPTHRANGEFPROC, "glDepthRangef");
  RESOLVED_PROC(PFNGLDEPTHRANGEFPROC)( n_, f_ );
}

void glClearDepthfWrapper(GLfloat d_)
{
  RESOLVE(PFNGLCLEARDEPTHFPROC, "glClearDepthf");
  RESOLVED_PROC(PFNGLCLEARDEPTHFPROC)( d_ );
}

void glGetProgramBinaryWrapper(GLuint program_, GLsizei bufSize_, GLsizei* length_, GLenum* binaryFormat_, void * binary_)
{
  RESOLVE(PFNGLGETPROGRAMBINARYPROC, "glGetProgramBinary");
  RESOLVED_PROC(PFNGLGETPROGRAMBINARYPROC)( program_, bufSize_, length_, binaryFormat_, binary_ );
}

void glProgramBinaryWrapper(GLuint program_, GLenum binaryFormat_, const void * binary_, GLsizei length_)
{
  RESOLVE(PFNGLPROGRAMBINARYPROC, "glProgramBinary");
  RESOLVED_PROC(PFNGLPROGRAMBINARYPROC)( program_, binaryFormat_, binary_, length_ );
}

void glProgramParameteriWrapper(GLuint program_, GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLPROGRAMPARAMETERIPROC, "glProgramParameteri");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETERIPROC)( program_, pname_, value_ );
}

void glUseProgramStagesWrapper(GLuint pipeline_, GLbitfield stages_, GLuint program_)
{
  RESOLVE(PFNGLUSEPROGRAMSTAGESPROC, "glUseProgramStages");
  RESOLVED_PROC(PFNGLUSEPROGRAMSTAGESPROC)( pipeline_, stages_, program_ );
}

void glActiveShaderProgramWrapper(GLuint pipeline_, GLuint program_)
{
  RESOLVE(PFNGLACTIVESHADERPROGRAMPROC, "glActiveShaderProgram");
  RESOLVED_PROC(PFNGLACTIVESHADERPROGRAMPROC)( pipeline_, program_ );
}

GLuint glCreateShaderProgramvWrapper(GLenum type_, GLsizei count_, const GLchar*const* strings_)
{
  RESOLVE_RET(PFNGLCREATESHADERPROGRAMVPROC, "glCreateShaderProgramv", FALSE);
  return RESOLVED_PROC(PFNGLCREATESHADERPROGRAMVPROC)(type_, count_, strings_ );
}

void glBindProgramPipelineWrapper(GLuint pipeline_)
{
  RESOLVE(PFNGLBINDPROGRAMPIPELINEPROC, "glBindProgramPipeline");
  RESOLVED_PROC(PFNGLBINDPROGRAMPIPELINEPROC)( pipeline_ );
}

void glDeleteProgramPipelinesWrapper(GLsizei n_, const GLuint* pipelines_)
{
  RESOLVE(PFNGLDELETEPROGRAMPIPELINESPROC, "glDeleteProgramPipelines");
  RESOLVED_PROC(PFNGLDELETEPROGRAMPIPELINESPROC)( n_, pipelines_ );
}

void glGenProgramPipelinesWrapper(GLsizei n_, GLuint* pipelines_)
{
  RESOLVE(PFNGLGENPROGRAMPIPELINESPROC, "glGenProgramPipelines");
  RESOLVED_PROC(PFNGLGENPROGRAMPIPELINESPROC)( n_, pipelines_ );
}

GLboolean glIsProgramPipelineWrapper(GLuint pipeline_)
{
  RESOLVE_RET(PFNGLISPROGRAMPIPELINEPROC, "glIsProgramPipeline", FALSE);
  return RESOLVED_PROC(PFNGLISPROGRAMPIPELINEPROC)(pipeline_ );
}

void glGetProgramPipelineivWrapper(GLuint pipeline_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMPIPELINEIVPROC, "glGetProgramPipelineiv");
  RESOLVED_PROC(PFNGLGETPROGRAMPIPELINEIVPROC)( pipeline_, pname_, params_ );
}

void glProgramUniform1iWrapper(GLuint program_, GLint location_, GLint v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1IPROC, "glProgramUniform1i");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1IPROC)( program_, location_, v0_ );
}

void glProgramUniform1ivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1IVPROC, "glProgramUniform1iv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1IVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1fWrapper(GLuint program_, GLint location_, GLfloat v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1FPROC, "glProgramUniform1f");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1FPROC)( program_, location_, v0_ );
}

void glProgramUniform1fvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1FVPROC, "glProgramUniform1fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1FVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1dWrapper(GLuint program_, GLint location_, GLdouble v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1DPROC, "glProgramUniform1d");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1DPROC)( program_, location_, v0_ );
}

void glProgramUniform1dvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1DVPROC, "glProgramUniform1dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1DVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1uiWrapper(GLuint program_, GLint location_, GLuint v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UIPROC, "glProgramUniform1ui");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UIPROC)( program_, location_, v0_ );
}

void glProgramUniform1uivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UIVPROC, "glProgramUniform1uiv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UIVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2iWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2IPROC, "glProgramUniform2i");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2IPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform2ivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2IVPROC, "glProgramUniform2iv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2IVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2fWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2FPROC, "glProgramUniform2f");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2FPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform2fvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2FVPROC, "glProgramUniform2fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2FVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2dWrapper(GLuint program_, GLint location_, GLdouble v0_, GLdouble v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2DPROC, "glProgramUniform2d");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2DPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform2dvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2DVPROC, "glProgramUniform2dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2DVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2uiWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UIPROC, "glProgramUniform2ui");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UIPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform2uivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UIVPROC, "glProgramUniform2uiv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UIVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3iWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_, GLint v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3IPROC, "glProgramUniform3i");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3IPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform3ivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3IVPROC, "glProgramUniform3iv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3IVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3fWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3FPROC, "glProgramUniform3f");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3FPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform3fvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3FVPROC, "glProgramUniform3fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3FVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3dWrapper(GLuint program_, GLint location_, GLdouble v0_, GLdouble v1_, GLdouble v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3DPROC, "glProgramUniform3d");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3DPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform3dvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3DVPROC, "glProgramUniform3dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3DVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3uiWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_, GLuint v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UIPROC, "glProgramUniform3ui");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UIPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform3uivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UIVPROC, "glProgramUniform3uiv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UIVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4iWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_, GLint v2_, GLint v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4IPROC, "glProgramUniform4i");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4IPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform4ivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4IVPROC, "glProgramUniform4iv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4IVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4fWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_, GLfloat v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4FPROC, "glProgramUniform4f");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4FPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform4fvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4FVPROC, "glProgramUniform4fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4FVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4dWrapper(GLuint program_, GLint location_, GLdouble v0_, GLdouble v1_, GLdouble v2_, GLdouble v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4DPROC, "glProgramUniform4d");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4DPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform4dvWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4DVPROC, "glProgramUniform4dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4DVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4uiWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_, GLuint v2_, GLuint v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UIPROC, "glProgramUniform4ui");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UIPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform4uivWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UIVPROC, "glProgramUniform4uiv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UIVPROC)( program_, location_, count_, value_ );
}

void glProgramUniformMatrix2fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2FVPROC, "glProgramUniformMatrix2fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3FVPROC, "glProgramUniformMatrix3fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4FVPROC, "glProgramUniformMatrix4fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2DVPROC, "glProgramUniformMatrix2dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3DVPROC, "glProgramUniformMatrix3dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4DVPROC, "glProgramUniformMatrix4dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x3fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC, "glProgramUniformMatrix2x3fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x2fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC, "glProgramUniformMatrix3x2fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x4fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC, "glProgramUniformMatrix2x4fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x2fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC, "glProgramUniformMatrix4x2fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x4fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC, "glProgramUniformMatrix3x4fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x3fvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC, "glProgramUniformMatrix4x3fv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x3dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC, "glProgramUniformMatrix2x3dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x2dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC, "glProgramUniformMatrix3x2dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x4dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC, "glProgramUniformMatrix2x4dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x2dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC, "glProgramUniformMatrix4x2dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x4dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC, "glProgramUniformMatrix3x4dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x3dvWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC, "glProgramUniformMatrix4x3dv");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)( program_, location_, count_, transpose_, value_ );
}

void glValidateProgramPipelineWrapper(GLuint pipeline_)
{
  RESOLVE(PFNGLVALIDATEPROGRAMPIPELINEPROC, "glValidateProgramPipeline");
  RESOLVED_PROC(PFNGLVALIDATEPROGRAMPIPELINEPROC)( pipeline_ );
}

void glGetProgramPipelineInfoLogWrapper(GLuint pipeline_, GLsizei bufSize_, GLsizei* length_, GLchar* infoLog_)
{
  RESOLVE(PFNGLGETPROGRAMPIPELINEINFOLOGPROC, "glGetProgramPipelineInfoLog");
  RESOLVED_PROC(PFNGLGETPROGRAMPIPELINEINFOLOGPROC)( pipeline_, bufSize_, length_, infoLog_ );
}

void glVertexAttribL1dWrapper(GLuint index_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1DPROC, "glVertexAttribL1d");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1DPROC)( index_, x_ );
}

void glVertexAttribL2dWrapper(GLuint index_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2DPROC, "glVertexAttribL2d");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2DPROC)( index_, x_, y_ );
}

void glVertexAttribL3dWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3DPROC, "glVertexAttribL3d");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3DPROC)( index_, x_, y_, z_ );
}

void glVertexAttribL4dWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4DPROC, "glVertexAttribL4d");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4DPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribL1dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1DVPROC, "glVertexAttribL1dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1DVPROC)( index_, v_ );
}

void glVertexAttribL2dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2DVPROC, "glVertexAttribL2dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2DVPROC)( index_, v_ );
}

void glVertexAttribL3dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3DVPROC, "glVertexAttribL3dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3DVPROC)( index_, v_ );
}

void glVertexAttribL4dvWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4DVPROC, "glVertexAttribL4dv");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4DVPROC)( index_, v_ );
}

void glVertexAttribLPointerWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBLPOINTERPROC, "glVertexAttribLPointer");
  RESOLVED_PROC(PFNGLVERTEXATTRIBLPOINTERPROC)( index_, size_, type_, stride_, pointer_ );
}

void glGetVertexAttribLdvWrapper(GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBLDVPROC, "glGetVertexAttribLdv");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBLDVPROC)( index_, pname_, params_ );
}

void glViewportArrayvWrapper(GLuint first_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLVIEWPORTARRAYVPROC, "glViewportArrayv");
  RESOLVED_PROC(PFNGLVIEWPORTARRAYVPROC)( first_, count_, v_ );
}

void glViewportIndexedfWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat w_, GLfloat h_)
{
  RESOLVE(PFNGLVIEWPORTINDEXEDFPROC, "glViewportIndexedf");
  RESOLVED_PROC(PFNGLVIEWPORTINDEXEDFPROC)( index_, x_, y_, w_, h_ );
}

void glViewportIndexedfvWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVIEWPORTINDEXEDFVPROC, "glViewportIndexedfv");
  RESOLVED_PROC(PFNGLVIEWPORTINDEXEDFVPROC)( index_, v_ );
}

void glScissorArrayvWrapper(GLuint first_, GLsizei count_, const GLint* v_)
{
  RESOLVE(PFNGLSCISSORARRAYVPROC, "glScissorArrayv");
  RESOLVED_PROC(PFNGLSCISSORARRAYVPROC)( first_, count_, v_ );
}

void glScissorIndexedWrapper(GLuint index_, GLint left_, GLint bottom_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLSCISSORINDEXEDPROC, "glScissorIndexed");
  RESOLVED_PROC(PFNGLSCISSORINDEXEDPROC)( index_, left_, bottom_, width_, height_ );
}

void glScissorIndexedvWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLSCISSORINDEXEDVPROC, "glScissorIndexedv");
  RESOLVED_PROC(PFNGLSCISSORINDEXEDVPROC)( index_, v_ );
}

void glDepthRangeArrayvWrapper(GLuint first_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLDEPTHRANGEARRAYVPROC, "glDepthRangeArrayv");
  RESOLVED_PROC(PFNGLDEPTHRANGEARRAYVPROC)( first_, count_, v_ );
}

void glDepthRangeIndexedWrapper(GLuint index_, GLdouble n_, GLdouble f_)
{
  RESOLVE(PFNGLDEPTHRANGEINDEXEDPROC, "glDepthRangeIndexed");
  RESOLVED_PROC(PFNGLDEPTHRANGEINDEXEDPROC)( index_, n_, f_ );
}

void glGetFloati_vWrapper(GLenum target_, GLuint index_, GLfloat* data_)
{
  RESOLVE(PFNGLGETFLOATI_VPROC, "glGetFloati_v");
  RESOLVED_PROC(PFNGLGETFLOATI_VPROC)( target_, index_, data_ );
}

void glGetDoublei_vWrapper(GLenum target_, GLuint index_, GLdouble* data_)
{
  RESOLVE(PFNGLGETDOUBLEI_VPROC, "glGetDoublei_v");
  RESOLVED_PROC(PFNGLGETDOUBLEI_VPROC)( target_, index_, data_ );
}

void glDrawArraysInstancedBaseInstanceWrapper(GLenum mode_, GLint first_, GLsizei count_, GLsizei instancecount_, GLuint baseinstance_)
{
  RESOLVE(PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC, "glDrawArraysInstancedBaseInstance");
  RESOLVED_PROC(PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)( mode_, first_, count_, instancecount_, baseinstance_ );
}

void glDrawElementsInstancedBaseInstanceWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei instancecount_, GLuint baseinstance_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC, "glDrawElementsInstancedBaseInstance");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)( mode_, count_, type_, indices_, instancecount_, baseinstance_ );
}

void glDrawElementsInstancedBaseVertexBaseInstanceWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei instancecount_, GLint basevertex_, GLuint baseinstance_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC, "glDrawElementsInstancedBaseVertexBaseInstance");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)( mode_, count_, type_, indices_, instancecount_, basevertex_, baseinstance_ );
}

void glGetInternalformativWrapper(GLenum target_, GLenum internalformat_, GLenum pname_, GLsizei bufSize_, GLint* params_)
{
  RESOLVE(PFNGLGETINTERNALFORMATIVPROC, "glGetInternalformativ");
  RESOLVED_PROC(PFNGLGETINTERNALFORMATIVPROC)( target_, internalformat_, pname_, bufSize_, params_ );
}

void glGetActiveAtomicCounterBufferivWrapper(GLuint program_, GLuint bufferIndex_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC, "glGetActiveAtomicCounterBufferiv");
  RESOLVED_PROC(PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)( program_, bufferIndex_, pname_, params_ );
}

void glBindImageTextureWrapper(GLuint unit_, GLuint texture_, GLint level_, GLboolean layered_, GLint layer_, GLenum access_, GLenum format_)
{
  RESOLVE(PFNGLBINDIMAGETEXTUREPROC, "glBindImageTexture");
  RESOLVED_PROC(PFNGLBINDIMAGETEXTUREPROC)( unit_, texture_, level_, layered_, layer_, access_, format_ );
}

void glMemoryBarrierWrapper(GLbitfield barriers_)
{
  RESOLVE(PFNGLMEMORYBARRIERPROC, "glMemoryBarrier");
  RESOLVED_PROC(PFNGLMEMORYBARRIERPROC)( barriers_ );
}

void glTexStorage1DWrapper(GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_)
{
  RESOLVE(PFNGLTEXSTORAGE1DPROC, "glTexStorage1D");
  RESOLVED_PROC(PFNGLTEXSTORAGE1DPROC)( target_, levels_, internalformat_, width_ );
}

void glTexStorage2DWrapper(GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLTEXSTORAGE2DPROC, "glTexStorage2D");
  RESOLVED_PROC(PFNGLTEXSTORAGE2DPROC)( target_, levels_, internalformat_, width_, height_ );
}

void glTexStorage3DWrapper(GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_)
{
  RESOLVE(PFNGLTEXSTORAGE3DPROC, "glTexStorage3D");
  RESOLVED_PROC(PFNGLTEXSTORAGE3DPROC)( target_, levels_, internalformat_, width_, height_, depth_ );
}

void glDrawTransformFeedbackInstancedWrapper(GLenum mode_, GLuint id_, GLsizei instancecount_)
{
  RESOLVE(PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC, "glDrawTransformFeedbackInstanced");
  RESOLVED_PROC(PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)( mode_, id_, instancecount_ );
}

void glDrawTransformFeedbackStreamInstancedWrapper(GLenum mode_, GLuint id_, GLuint stream_, GLsizei instancecount_)
{
  RESOLVE(PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC, "glDrawTransformFeedbackStreamInstanced");
  RESOLVED_PROC(PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)( mode_, id_, stream_, instancecount_ );
}

void glClearBufferDataWrapper(GLenum target_, GLenum internalformat_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARBUFFERDATAPROC, "glClearBufferData");
  RESOLVED_PROC(PFNGLCLEARBUFFERDATAPROC)( target_, internalformat_, format_, type_, data_ );
}

void glClearBufferSubDataWrapper(GLenum target_, GLenum internalformat_, GLintptr offset_, GLsizeiptr size_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARBUFFERSUBDATAPROC, "glClearBufferSubData");
  RESOLVED_PROC(PFNGLCLEARBUFFERSUBDATAPROC)( target_, internalformat_, offset_, size_, format_, type_, data_ );
}

void glDispatchComputeWrapper(GLuint num_groups_x_, GLuint num_groups_y_, GLuint num_groups_z_)
{
  RESOLVE(PFNGLDISPATCHCOMPUTEPROC, "glDispatchCompute");
  RESOLVED_PROC(PFNGLDISPATCHCOMPUTEPROC)( num_groups_x_, num_groups_y_, num_groups_z_ );
}

void glDispatchComputeIndirectWrapper(GLintptr indirect_)
{
  RESOLVE(PFNGLDISPATCHCOMPUTEINDIRECTPROC, "glDispatchComputeIndirect");
  RESOLVED_PROC(PFNGLDISPATCHCOMPUTEINDIRECTPROC)( indirect_ );
}

void glCopyImageSubDataWrapper(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_)
{
  RESOLVE(PFNGLCOPYIMAGESUBDATAPROC, "glCopyImageSubData");
  RESOLVED_PROC(PFNGLCOPYIMAGESUBDATAPROC)( srcName_, srcTarget_, srcLevel_, srcX_, srcY_, srcZ_, dstName_, dstTarget_, dstLevel_, dstX_, dstY_, dstZ_, srcWidth_, srcHeight_, srcDepth_ );
}

void glFramebufferParameteriWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLFRAMEBUFFERPARAMETERIPROC, "glFramebufferParameteri");
  RESOLVED_PROC(PFNGLFRAMEBUFFERPARAMETERIPROC)( target_, pname_, param_ );
}

void glGetFramebufferParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAMEBUFFERPARAMETERIVPROC, "glGetFramebufferParameteriv");
  RESOLVED_PROC(PFNGLGETFRAMEBUFFERPARAMETERIVPROC)( target_, pname_, params_ );
}

void glGetInternalformati64vWrapper(GLenum target_, GLenum internalformat_, GLenum pname_, GLsizei bufSize_, GLint64* params_)
{
  RESOLVE(PFNGLGETINTERNALFORMATI64VPROC, "glGetInternalformati64v");
  RESOLVED_PROC(PFNGLGETINTERNALFORMATI64VPROC)( target_, internalformat_, pname_, bufSize_, params_ );
}

void glInvalidateTexSubImageWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_)
{
  RESOLVE(PFNGLINVALIDATETEXSUBIMAGEPROC, "glInvalidateTexSubImage");
  RESOLVED_PROC(PFNGLINVALIDATETEXSUBIMAGEPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_ );
}

void glInvalidateTexImageWrapper(GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLINVALIDATETEXIMAGEPROC, "glInvalidateTexImage");
  RESOLVED_PROC(PFNGLINVALIDATETEXIMAGEPROC)( texture_, level_ );
}

void glInvalidateBufferSubDataWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr length_)
{
  RESOLVE(PFNGLINVALIDATEBUFFERSUBDATAPROC, "glInvalidateBufferSubData");
  RESOLVED_PROC(PFNGLINVALIDATEBUFFERSUBDATAPROC)( buffer_, offset_, length_ );
}

void glInvalidateBufferDataWrapper(GLuint buffer_)
{
  RESOLVE(PFNGLINVALIDATEBUFFERDATAPROC, "glInvalidateBufferData");
  RESOLVED_PROC(PFNGLINVALIDATEBUFFERDATAPROC)( buffer_ );
}

void glInvalidateFramebufferWrapper(GLenum target_, GLsizei numAttachments_, const GLenum* attachments_)
{
  RESOLVE(PFNGLINVALIDATEFRAMEBUFFERPROC, "glInvalidateFramebuffer");
  RESOLVED_PROC(PFNGLINVALIDATEFRAMEBUFFERPROC)( target_, numAttachments_, attachments_ );
}

void glInvalidateSubFramebufferWrapper(GLenum target_, GLsizei numAttachments_, const GLenum* attachments_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLINVALIDATESUBFRAMEBUFFERPROC, "glInvalidateSubFramebuffer");
  RESOLVED_PROC(PFNGLINVALIDATESUBFRAMEBUFFERPROC)( target_, numAttachments_, attachments_, x_, y_, width_, height_ );
}

void glMultiDrawArraysIndirectWrapper(GLenum mode_, const void * indirect_, GLsizei drawcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSINDIRECTPROC, "glMultiDrawArraysIndirect");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSINDIRECTPROC)( mode_, indirect_, drawcount_, stride_ );
}

void glMultiDrawElementsIndirectWrapper(GLenum mode_, GLenum type_, const void * indirect_, GLsizei drawcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSINDIRECTPROC, "glMultiDrawElementsIndirect");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSINDIRECTPROC)( mode_, type_, indirect_, drawcount_, stride_ );
}

void glGetProgramInterfaceivWrapper(GLuint program_, GLenum programInterface_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMINTERFACEIVPROC, "glGetProgramInterfaceiv");
  RESOLVED_PROC(PFNGLGETPROGRAMINTERFACEIVPROC)( program_, programInterface_, pname_, params_ );
}

GLuint glGetProgramResourceIndexWrapper(GLuint program_, GLenum programInterface_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETPROGRAMRESOURCEINDEXPROC, "glGetProgramResourceIndex", FALSE);
  return RESOLVED_PROC(PFNGLGETPROGRAMRESOURCEINDEXPROC)(program_, programInterface_, name_ );
}

void glGetProgramResourceNameWrapper(GLuint program_, GLenum programInterface_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLchar* name_)
{
  RESOLVE(PFNGLGETPROGRAMRESOURCENAMEPROC, "glGetProgramResourceName");
  RESOLVED_PROC(PFNGLGETPROGRAMRESOURCENAMEPROC)( program_, programInterface_, index_, bufSize_, length_, name_ );
}

void glGetProgramResourceivWrapper(GLuint program_, GLenum programInterface_, GLuint index_, GLsizei propCount_, const GLenum* props_, GLsizei bufSize_, GLsizei* length_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMRESOURCEIVPROC, "glGetProgramResourceiv");
  RESOLVED_PROC(PFNGLGETPROGRAMRESOURCEIVPROC)( program_, programInterface_, index_, propCount_, props_, bufSize_, length_, params_ );
}

GLint glGetProgramResourceLocationWrapper(GLuint program_, GLenum programInterface_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETPROGRAMRESOURCELOCATIONPROC, "glGetProgramResourceLocation", FALSE);
  return RESOLVED_PROC(PFNGLGETPROGRAMRESOURCELOCATIONPROC)(program_, programInterface_, name_ );
}

GLint glGetProgramResourceLocationIndexWrapper(GLuint program_, GLenum programInterface_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC, "glGetProgramResourceLocationIndex", FALSE);
  return RESOLVED_PROC(PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)(program_, programInterface_, name_ );
}

void glShaderStorageBlockBindingWrapper(GLuint program_, GLuint storageBlockIndex_, GLuint storageBlockBinding_)
{
  RESOLVE(PFNGLSHADERSTORAGEBLOCKBINDINGPROC, "glShaderStorageBlockBinding");
  RESOLVED_PROC(PFNGLSHADERSTORAGEBLOCKBINDINGPROC)( program_, storageBlockIndex_, storageBlockBinding_ );
}

void glTexBufferRangeWrapper(GLenum target_, GLenum internalformat_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLTEXBUFFERRANGEPROC, "glTexBufferRange");
  RESOLVED_PROC(PFNGLTEXBUFFERRANGEPROC)( target_, internalformat_, buffer_, offset_, size_ );
}

void glTexStorage2DMultisampleWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXSTORAGE2DMULTISAMPLEPROC, "glTexStorage2DMultisample");
  RESOLVED_PROC(PFNGLTEXSTORAGE2DMULTISAMPLEPROC)( target_, samples_, internalformat_, width_, height_, fixedsamplelocations_ );
}

void glTexStorage3DMultisampleWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXSTORAGE3DMULTISAMPLEPROC, "glTexStorage3DMultisample");
  RESOLVED_PROC(PFNGLTEXSTORAGE3DMULTISAMPLEPROC)( target_, samples_, internalformat_, width_, height_, depth_, fixedsamplelocations_ );
}

void glTextureViewWrapper(GLuint texture_, GLenum target_, GLuint origtexture_, GLenum internalformat_, GLuint minlevel_, GLuint numlevels_, GLuint minlayer_, GLuint numlayers_)
{
  RESOLVE(PFNGLTEXTUREVIEWPROC, "glTextureView");
  RESOLVED_PROC(PFNGLTEXTUREVIEWPROC)( texture_, target_, origtexture_, internalformat_, minlevel_, numlevels_, minlayer_, numlayers_ );
}

void glBindVertexBufferWrapper(GLuint bindingindex_, GLuint buffer_, GLintptr offset_, GLsizei stride_)
{
  RESOLVE(PFNGLBINDVERTEXBUFFERPROC, "glBindVertexBuffer");
  RESOLVED_PROC(PFNGLBINDVERTEXBUFFERPROC)( bindingindex_, buffer_, offset_, stride_ );
}

void glVertexAttribFormatWrapper(GLuint attribindex_, GLint size_, GLenum type_, GLboolean normalized_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXATTRIBFORMATPROC, "glVertexAttribFormat");
  RESOLVED_PROC(PFNGLVERTEXATTRIBFORMATPROC)( attribindex_, size_, type_, normalized_, relativeoffset_ );
}

void glVertexAttribIFormatWrapper(GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXATTRIBIFORMATPROC, "glVertexAttribIFormat");
  RESOLVED_PROC(PFNGLVERTEXATTRIBIFORMATPROC)( attribindex_, size_, type_, relativeoffset_ );
}

void glVertexAttribLFormatWrapper(GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXATTRIBLFORMATPROC, "glVertexAttribLFormat");
  RESOLVED_PROC(PFNGLVERTEXATTRIBLFORMATPROC)( attribindex_, size_, type_, relativeoffset_ );
}

void glVertexAttribBindingWrapper(GLuint attribindex_, GLuint bindingindex_)
{
  RESOLVE(PFNGLVERTEXATTRIBBINDINGPROC, "glVertexAttribBinding");
  RESOLVED_PROC(PFNGLVERTEXATTRIBBINDINGPROC)( attribindex_, bindingindex_ );
}

void glVertexBindingDivisorWrapper(GLuint bindingindex_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXBINDINGDIVISORPROC, "glVertexBindingDivisor");
  RESOLVED_PROC(PFNGLVERTEXBINDINGDIVISORPROC)( bindingindex_, divisor_ );
}

void glDebugMessageControlWrapper(GLenum source_, GLenum type_, GLenum severity_, GLsizei count_, const GLuint* ids_, GLboolean enabled_)
{
  RESOLVE(PFNGLDEBUGMESSAGECONTROLPROC, "glDebugMessageControl");
  RESOLVED_PROC(PFNGLDEBUGMESSAGECONTROLPROC)( source_, type_, severity_, count_, ids_, enabled_ );
}

void glDebugMessageInsertWrapper(GLenum source_, GLenum type_, GLuint id_, GLenum severity_, GLsizei length_, const GLchar* buf_)
{
  RESOLVE(PFNGLDEBUGMESSAGEINSERTPROC, "glDebugMessageInsert");
  RESOLVED_PROC(PFNGLDEBUGMESSAGEINSERTPROC)( source_, type_, id_, severity_, length_, buf_ );
}

void glDebugMessageCallbackWrapper(GLDEBUGPROC callback_, const void * userParam_)
{
  RESOLVE(PFNGLDEBUGMESSAGECALLBACKPROC, "glDebugMessageCallback");
  RESOLVED_PROC(PFNGLDEBUGMESSAGECALLBACKPROC)( callback_, userParam_ );
}

GLuint glGetDebugMessageLogWrapper(GLuint count_, GLsizei bufSize_, GLenum* sources_, GLenum* types_, GLuint* ids_, GLenum* severities_, GLsizei* lengths_, GLchar* messageLog_)
{
  RESOLVE_RET(PFNGLGETDEBUGMESSAGELOGPROC, "glGetDebugMessageLog", FALSE);
  return RESOLVED_PROC(PFNGLGETDEBUGMESSAGELOGPROC)(count_, bufSize_, sources_, types_, ids_, severities_, lengths_, messageLog_ );
}

void glPushDebugGroupWrapper(GLenum source_, GLuint id_, GLsizei length_, const GLchar* message_)
{
  RESOLVE(PFNGLPUSHDEBUGGROUPPROC, "glPushDebugGroup");
  RESOLVED_PROC(PFNGLPUSHDEBUGGROUPPROC)( source_, id_, length_, message_ );
}

void glPopDebugGroupWrapper(void)
{
  RESOLVE(PFNGLPOPDEBUGGROUPPROC, "glPopDebugGroup");
  RESOLVED_PROC(PFNGLPOPDEBUGGROUPPROC)(  );
}

void glObjectLabelWrapper(GLenum identifier_, GLuint name_, GLsizei length_, const GLchar* label_)
{
  RESOLVE(PFNGLOBJECTLABELPROC, "glObjectLabel");
  RESOLVED_PROC(PFNGLOBJECTLABELPROC)( identifier_, name_, length_, label_ );
}

void glGetObjectLabelWrapper(GLenum identifier_, GLuint name_, GLsizei bufSize_, GLsizei* length_, GLchar* label_)
{
  RESOLVE(PFNGLGETOBJECTLABELPROC, "glGetObjectLabel");
  RESOLVED_PROC(PFNGLGETOBJECTLABELPROC)( identifier_, name_, bufSize_, length_, label_ );
}

void glObjectPtrLabelWrapper(const void * ptr_, GLsizei length_, const GLchar* label_)
{
  RESOLVE(PFNGLOBJECTPTRLABELPROC, "glObjectPtrLabel");
  RESOLVED_PROC(PFNGLOBJECTPTRLABELPROC)( ptr_, length_, label_ );
}

void glGetObjectPtrLabelWrapper(const void * ptr_, GLsizei bufSize_, GLsizei* length_, GLchar* label_)
{
  RESOLVE(PFNGLGETOBJECTPTRLABELPROC, "glGetObjectPtrLabel");
  RESOLVED_PROC(PFNGLGETOBJECTPTRLABELPROC)( ptr_, bufSize_, length_, label_ );
}

void glBufferStorageWrapper(GLenum target_, GLsizeiptr size_, const void * data_, GLbitfield flags_)
{
  RESOLVE(PFNGLBUFFERSTORAGEPROC, "glBufferStorage");
  RESOLVED_PROC(PFNGLBUFFERSTORAGEPROC)( target_, size_, data_, flags_ );
}

void glClearTexImageWrapper(GLuint texture_, GLint level_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARTEXIMAGEPROC, "glClearTexImage");
  RESOLVED_PROC(PFNGLCLEARTEXIMAGEPROC)( texture_, level_, format_, type_, data_ );
}

void glClearTexSubImageWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARTEXSUBIMAGEPROC, "glClearTexSubImage");
  RESOLVED_PROC(PFNGLCLEARTEXSUBIMAGEPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, data_ );
}

void glBindBuffersBaseWrapper(GLenum target_, GLuint first_, GLsizei count_, const GLuint* buffers_)
{
  RESOLVE(PFNGLBINDBUFFERSBASEPROC, "glBindBuffersBase");
  RESOLVED_PROC(PFNGLBINDBUFFERSBASEPROC)( target_, first_, count_, buffers_ );
}

void glBindBuffersRangeWrapper(GLenum target_, GLuint first_, GLsizei count_, const GLuint* buffers_, const GLintptr* offsets_, const GLsizeiptr* sizes_)
{
  RESOLVE(PFNGLBINDBUFFERSRANGEPROC, "glBindBuffersRange");
  RESOLVED_PROC(PFNGLBINDBUFFERSRANGEPROC)( target_, first_, count_, buffers_, offsets_, sizes_ );
}

void glBindTexturesWrapper(GLuint first_, GLsizei count_, const GLuint* textures_)
{
  RESOLVE(PFNGLBINDTEXTURESPROC, "glBindTextures");
  RESOLVED_PROC(PFNGLBINDTEXTURESPROC)( first_, count_, textures_ );
}

void glBindSamplersWrapper(GLuint first_, GLsizei count_, const GLuint* samplers_)
{
  RESOLVE(PFNGLBINDSAMPLERSPROC, "glBindSamplers");
  RESOLVED_PROC(PFNGLBINDSAMPLERSPROC)( first_, count_, samplers_ );
}

void glBindImageTexturesWrapper(GLuint first_, GLsizei count_, const GLuint* textures_)
{
  RESOLVE(PFNGLBINDIMAGETEXTURESPROC, "glBindImageTextures");
  RESOLVED_PROC(PFNGLBINDIMAGETEXTURESPROC)( first_, count_, textures_ );
}

void glBindVertexBuffersWrapper(GLuint first_, GLsizei count_, const GLuint* buffers_, const GLintptr* offsets_, const GLsizei* strides_)
{
  RESOLVE(PFNGLBINDVERTEXBUFFERSPROC, "glBindVertexBuffers");
  RESOLVED_PROC(PFNGLBINDVERTEXBUFFERSPROC)( first_, count_, buffers_, offsets_, strides_ );
}

void glClipControlWrapper(GLenum origin_, GLenum depth_)
{
  RESOLVE(PFNGLCLIPCONTROLPROC, "glClipControl");
  RESOLVED_PROC(PFNGLCLIPCONTROLPROC)( origin_, depth_ );
}

void glCreateTransformFeedbacksWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLCREATETRANSFORMFEEDBACKSPROC, "glCreateTransformFeedbacks");
  RESOLVED_PROC(PFNGLCREATETRANSFORMFEEDBACKSPROC)( n_, ids_ );
}

void glTransformFeedbackBufferBaseWrapper(GLuint xfb_, GLuint index_, GLuint buffer_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC, "glTransformFeedbackBufferBase");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)( xfb_, index_, buffer_ );
}

void glTransformFeedbackBufferRangeWrapper(GLuint xfb_, GLuint index_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC, "glTransformFeedbackBufferRange");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)( xfb_, index_, buffer_, offset_, size_ );
}

void glGetTransformFeedbackivWrapper(GLuint xfb_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKIVPROC, "glGetTransformFeedbackiv");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKIVPROC)( xfb_, pname_, param_ );
}

void glGetTransformFeedbacki_vWrapper(GLuint xfb_, GLenum pname_, GLuint index_, GLint* param_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKI_VPROC, "glGetTransformFeedbacki_v");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKI_VPROC)( xfb_, pname_, index_, param_ );
}

void glGetTransformFeedbacki64_vWrapper(GLuint xfb_, GLenum pname_, GLuint index_, GLint64* param_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKI64_VPROC, "glGetTransformFeedbacki64_v");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKI64_VPROC)( xfb_, pname_, index_, param_ );
}

void glCreateBuffersWrapper(GLsizei n_, GLuint* buffers_)
{
  RESOLVE(PFNGLCREATEBUFFERSPROC, "glCreateBuffers");
  RESOLVED_PROC(PFNGLCREATEBUFFERSPROC)( n_, buffers_ );
}

void glNamedBufferStorageWrapper(GLuint buffer_, GLsizeiptr size_, const void * data_, GLbitfield flags_)
{
  RESOLVE(PFNGLNAMEDBUFFERSTORAGEPROC, "glNamedBufferStorage");
  RESOLVED_PROC(PFNGLNAMEDBUFFERSTORAGEPROC)( buffer_, size_, data_, flags_ );
}

void glNamedBufferDataWrapper(GLuint buffer_, GLsizeiptr size_, const void * data_, GLenum usage_)
{
  RESOLVE(PFNGLNAMEDBUFFERDATAPROC, "glNamedBufferData");
  RESOLVED_PROC(PFNGLNAMEDBUFFERDATAPROC)( buffer_, size_, data_, usage_ );
}

void glNamedBufferSubDataWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, const void * data_)
{
  RESOLVE(PFNGLNAMEDBUFFERSUBDATAPROC, "glNamedBufferSubData");
  RESOLVED_PROC(PFNGLNAMEDBUFFERSUBDATAPROC)( buffer_, offset_, size_, data_ );
}

void glCopyNamedBufferSubDataWrapper(GLuint readBuffer_, GLuint writeBuffer_, GLintptr readOffset_, GLintptr writeOffset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLCOPYNAMEDBUFFERSUBDATAPROC, "glCopyNamedBufferSubData");
  RESOLVED_PROC(PFNGLCOPYNAMEDBUFFERSUBDATAPROC)( readBuffer_, writeBuffer_, readOffset_, writeOffset_, size_ );
}

void glClearNamedBufferDataWrapper(GLuint buffer_, GLenum internalformat_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARNAMEDBUFFERDATAPROC, "glClearNamedBufferData");
  RESOLVED_PROC(PFNGLCLEARNAMEDBUFFERDATAPROC)( buffer_, internalformat_, format_, type_, data_ );
}

void glClearNamedBufferSubDataWrapper(GLuint buffer_, GLenum internalformat_, GLintptr offset_, GLsizeiptr size_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARNAMEDBUFFERSUBDATAPROC, "glClearNamedBufferSubData");
  RESOLVED_PROC(PFNGLCLEARNAMEDBUFFERSUBDATAPROC)( buffer_, internalformat_, offset_, size_, format_, type_, data_ );
}

void * glMapNamedBufferWrapper(GLuint buffer_, GLenum access_)
{
  RESOLVE_RET(PFNGLMAPNAMEDBUFFERPROC, "glMapNamedBuffer", FALSE);
  return RESOLVED_PROC(PFNGLMAPNAMEDBUFFERPROC)(buffer_, access_ );
}

void * glMapNamedBufferRangeWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr length_, GLbitfield access_)
{
  RESOLVE_RET(PFNGLMAPNAMEDBUFFERRANGEPROC, "glMapNamedBufferRange", FALSE);
  return RESOLVED_PROC(PFNGLMAPNAMEDBUFFERRANGEPROC)(buffer_, offset_, length_, access_ );
}

GLboolean glUnmapNamedBufferWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLUNMAPNAMEDBUFFERPROC, "glUnmapNamedBuffer", FALSE);
  return RESOLVED_PROC(PFNGLUNMAPNAMEDBUFFERPROC)(buffer_ );
}

void glFlushMappedNamedBufferRangeWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr length_)
{
  RESOLVE(PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC, "glFlushMappedNamedBufferRange");
  RESOLVED_PROC(PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)( buffer_, offset_, length_ );
}

void glGetNamedBufferParameterivWrapper(GLuint buffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPARAMETERIVPROC, "glGetNamedBufferParameteriv");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPARAMETERIVPROC)( buffer_, pname_, params_ );
}

void glGetNamedBufferParameteri64vWrapper(GLuint buffer_, GLenum pname_, GLint64* params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPARAMETERI64VPROC, "glGetNamedBufferParameteri64v");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)( buffer_, pname_, params_ );
}

void glGetNamedBufferPointervWrapper(GLuint buffer_, GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPOINTERVPROC, "glGetNamedBufferPointerv");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPOINTERVPROC)( buffer_, pname_, params_ );
}

void glGetNamedBufferSubDataWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, void * data_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERSUBDATAPROC, "glGetNamedBufferSubData");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERSUBDATAPROC)( buffer_, offset_, size_, data_ );
}

void glCreateFramebuffersWrapper(GLsizei n_, GLuint* framebuffers_)
{
  RESOLVE(PFNGLCREATEFRAMEBUFFERSPROC, "glCreateFramebuffers");
  RESOLVED_PROC(PFNGLCREATEFRAMEBUFFERSPROC)( n_, framebuffers_ );
}

void glNamedFramebufferRenderbufferWrapper(GLuint framebuffer_, GLenum attachment_, GLenum renderbuffertarget_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC, "glNamedFramebufferRenderbuffer");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)( framebuffer_, attachment_, renderbuffertarget_, renderbuffer_ );
}

void glNamedFramebufferParameteriWrapper(GLuint framebuffer_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC, "glNamedFramebufferParameteri");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)( framebuffer_, pname_, param_ );
}

void glNamedFramebufferTextureWrapper(GLuint framebuffer_, GLenum attachment_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTUREPROC, "glNamedFramebufferTexture");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)( framebuffer_, attachment_, texture_, level_ );
}

void glNamedFramebufferTextureLayerWrapper(GLuint framebuffer_, GLenum attachment_, GLuint texture_, GLint level_, GLint layer_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC, "glNamedFramebufferTextureLayer");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)( framebuffer_, attachment_, texture_, level_, layer_ );
}

void glNamedFramebufferDrawBufferWrapper(GLuint framebuffer_, GLenum buf_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC, "glNamedFramebufferDrawBuffer");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)( framebuffer_, buf_ );
}

void glNamedFramebufferDrawBuffersWrapper(GLuint framebuffer_, GLsizei n_, const GLenum* bufs_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC, "glNamedFramebufferDrawBuffers");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)( framebuffer_, n_, bufs_ );
}

void glNamedFramebufferReadBufferWrapper(GLuint framebuffer_, GLenum src_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC, "glNamedFramebufferReadBuffer");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)( framebuffer_, src_ );
}

void glInvalidateNamedFramebufferDataWrapper(GLuint framebuffer_, GLsizei numAttachments_, const GLenum* attachments_)
{
  RESOLVE(PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC, "glInvalidateNamedFramebufferData");
  RESOLVED_PROC(PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)( framebuffer_, numAttachments_, attachments_ );
}

void glInvalidateNamedFramebufferSubDataWrapper(GLuint framebuffer_, GLsizei numAttachments_, const GLenum* attachments_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC, "glInvalidateNamedFramebufferSubData");
  RESOLVED_PROC(PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)( framebuffer_, numAttachments_, attachments_, x_, y_, width_, height_ );
}

void glClearNamedFramebufferivWrapper(GLuint framebuffer_, GLenum buffer_, GLint drawbuffer_, const GLint* value_)
{
  RESOLVE(PFNGLCLEARNAMEDFRAMEBUFFERIVPROC, "glClearNamedFramebufferiv");
  RESOLVED_PROC(PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)( framebuffer_, buffer_, drawbuffer_, value_ );
}

void glClearNamedFramebufferuivWrapper(GLuint framebuffer_, GLenum buffer_, GLint drawbuffer_, const GLuint* value_)
{
  RESOLVE(PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC, "glClearNamedFramebufferuiv");
  RESOLVED_PROC(PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)( framebuffer_, buffer_, drawbuffer_, value_ );
}

void glClearNamedFramebufferfvWrapper(GLuint framebuffer_, GLenum buffer_, GLint drawbuffer_, const GLfloat* value_)
{
  RESOLVE(PFNGLCLEARNAMEDFRAMEBUFFERFVPROC, "glClearNamedFramebufferfv");
  RESOLVED_PROC(PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)( framebuffer_, buffer_, drawbuffer_, value_ );
}

void glClearNamedFramebufferfiWrapper(GLuint framebuffer_, GLenum buffer_, const GLfloat depth_, GLint stencil_)
{
  RESOLVE(PFNGLCLEARNAMEDFRAMEBUFFERFIPROC, "glClearNamedFramebufferfi");
  RESOLVED_PROC(PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)( framebuffer_, buffer_, depth_, stencil_ );
}

void glBlitNamedFramebufferWrapper(GLuint readFramebuffer_, GLuint drawFramebuffer_, GLint srcX0_, GLint srcY0_, GLint srcX1_, GLint srcY1_, GLint dstX0_, GLint dstY0_, GLint dstX1_, GLint dstY1_, GLbitfield mask_, GLenum filter_)
{
  RESOLVE(PFNGLBLITNAMEDFRAMEBUFFERPROC, "glBlitNamedFramebuffer");
  RESOLVED_PROC(PFNGLBLITNAMEDFRAMEBUFFERPROC)( readFramebuffer_, drawFramebuffer_, srcX0_, srcY0_, srcX1_, srcY1_, dstX0_, dstY0_, dstX1_, dstY1_, mask_, filter_ );
}

GLenum glCheckNamedFramebufferStatusWrapper(GLuint framebuffer_, GLenum target_)
{
  RESOLVE_RET(PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC, "glCheckNamedFramebufferStatus", FALSE);
  return RESOLVED_PROC(PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)(framebuffer_, target_ );
}

void glGetNamedFramebufferParameterivWrapper(GLuint framebuffer_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC, "glGetNamedFramebufferParameteriv");
  RESOLVED_PROC(PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)( framebuffer_, pname_, param_ );
}

void glGetNamedFramebufferAttachmentParameterivWrapper(GLuint framebuffer_, GLenum attachment_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC, "glGetNamedFramebufferAttachmentParameteriv");
  RESOLVED_PROC(PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)( framebuffer_, attachment_, pname_, params_ );
}

void glCreateRenderbuffersWrapper(GLsizei n_, GLuint* renderbuffers_)
{
  RESOLVE(PFNGLCREATERENDERBUFFERSPROC, "glCreateRenderbuffers");
  RESOLVED_PROC(PFNGLCREATERENDERBUFFERSPROC)( n_, renderbuffers_ );
}

void glNamedRenderbufferStorageWrapper(GLuint renderbuffer_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLNAMEDRENDERBUFFERSTORAGEPROC, "glNamedRenderbufferStorage");
  RESOLVED_PROC(PFNGLNAMEDRENDERBUFFERSTORAGEPROC)( renderbuffer_, internalformat_, width_, height_ );
}

void glNamedRenderbufferStorageMultisampleWrapper(GLuint renderbuffer_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC, "glNamedRenderbufferStorageMultisample");
  RESOLVED_PROC(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)( renderbuffer_, samples_, internalformat_, width_, height_ );
}

void glGetNamedRenderbufferParameterivWrapper(GLuint renderbuffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC, "glGetNamedRenderbufferParameteriv");
  RESOLVED_PROC(PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)( renderbuffer_, pname_, params_ );
}

void glCreateTexturesWrapper(GLenum target_, GLsizei n_, GLuint* textures_)
{
  RESOLVE(PFNGLCREATETEXTURESPROC, "glCreateTextures");
  RESOLVED_PROC(PFNGLCREATETEXTURESPROC)( target_, n_, textures_ );
}

void glTextureBufferWrapper(GLuint texture_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLTEXTUREBUFFERPROC, "glTextureBuffer");
  RESOLVED_PROC(PFNGLTEXTUREBUFFERPROC)( texture_, internalformat_, buffer_ );
}

void glTextureBufferRangeWrapper(GLuint texture_, GLenum internalformat_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLTEXTUREBUFFERRANGEPROC, "glTextureBufferRange");
  RESOLVED_PROC(PFNGLTEXTUREBUFFERRANGEPROC)( texture_, internalformat_, buffer_, offset_, size_ );
}

void glTextureStorage1DWrapper(GLuint texture_, GLsizei levels_, GLenum internalformat_, GLsizei width_)
{
  RESOLVE(PFNGLTEXTURESTORAGE1DPROC, "glTextureStorage1D");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE1DPROC)( texture_, levels_, internalformat_, width_ );
}

void glTextureStorage2DWrapper(GLuint texture_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLTEXTURESTORAGE2DPROC, "glTextureStorage2D");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE2DPROC)( texture_, levels_, internalformat_, width_, height_ );
}

void glTextureStorage3DWrapper(GLuint texture_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_)
{
  RESOLVE(PFNGLTEXTURESTORAGE3DPROC, "glTextureStorage3D");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE3DPROC)( texture_, levels_, internalformat_, width_, height_, depth_ );
}

void glTextureStorage2DMultisampleWrapper(GLuint texture_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC, "glTextureStorage2DMultisample");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)( texture_, samples_, internalformat_, width_, height_, fixedsamplelocations_ );
}

void glTextureStorage3DMultisampleWrapper(GLuint texture_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC, "glTextureStorage3DMultisample");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)( texture_, samples_, internalformat_, width_, height_, depth_, fixedsamplelocations_ );
}

void glTextureSubImage1DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE1DPROC, "glTextureSubImage1D");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE1DPROC)( texture_, level_, xoffset_, width_, format_, type_, pixels_ );
}

void glTextureSubImage2DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE2DPROC, "glTextureSubImage2D");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE2DPROC)( texture_, level_, xoffset_, yoffset_, width_, height_, format_, type_, pixels_ );
}

void glTextureSubImage3DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE3DPROC, "glTextureSubImage3D");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE3DPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, pixels_ );
}

void glCompressedTextureSubImage1DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC, "glCompressedTextureSubImage1D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)( texture_, level_, xoffset_, width_, format_, imageSize_, data_ );
}

void glCompressedTextureSubImage2DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC, "glCompressedTextureSubImage2D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)( texture_, level_, xoffset_, yoffset_, width_, height_, format_, imageSize_, data_ );
}

void glCompressedTextureSubImage3DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC, "glCompressedTextureSubImage3D");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, imageSize_, data_ );
}

void glCopyTextureSubImage1DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE1DPROC, "glCopyTextureSubImage1D");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE1DPROC)( texture_, level_, xoffset_, x_, y_, width_ );
}

void glCopyTextureSubImage2DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE2DPROC, "glCopyTextureSubImage2D");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE2DPROC)( texture_, level_, xoffset_, yoffset_, x_, y_, width_, height_ );
}

void glCopyTextureSubImage3DWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE3DPROC, "glCopyTextureSubImage3D");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE3DPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, x_, y_, width_, height_ );
}

void glTextureParameterfWrapper(GLuint texture_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERFPROC, "glTextureParameterf");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERFPROC)( texture_, pname_, param_ );
}

void glTextureParameterfvWrapper(GLuint texture_, GLenum pname_, const GLfloat* param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERFVPROC, "glTextureParameterfv");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERFVPROC)( texture_, pname_, param_ );
}

void glTextureParameteriWrapper(GLuint texture_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIPROC, "glTextureParameteri");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIPROC)( texture_, pname_, param_ );
}

void glTextureParameterIivWrapper(GLuint texture_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIIVPROC, "glTextureParameterIiv");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIIVPROC)( texture_, pname_, params_ );
}

void glTextureParameterIuivWrapper(GLuint texture_, GLenum pname_, const GLuint* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIUIVPROC, "glTextureParameterIuiv");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIUIVPROC)( texture_, pname_, params_ );
}

void glTextureParameterivWrapper(GLuint texture_, GLenum pname_, const GLint* param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIVPROC, "glTextureParameteriv");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIVPROC)( texture_, pname_, param_ );
}

void glGenerateTextureMipmapWrapper(GLuint texture_)
{
  RESOLVE(PFNGLGENERATETEXTUREMIPMAPPROC, "glGenerateTextureMipmap");
  RESOLVED_PROC(PFNGLGENERATETEXTUREMIPMAPPROC)( texture_ );
}

void glBindTextureUnitWrapper(GLuint unit_, GLuint texture_)
{
  RESOLVE(PFNGLBINDTEXTUREUNITPROC, "glBindTextureUnit");
  RESOLVED_PROC(PFNGLBINDTEXTUREUNITPROC)( unit_, texture_ );
}

void glGetTextureImageWrapper(GLuint texture_, GLint level_, GLenum format_, GLenum type_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETTEXTUREIMAGEPROC, "glGetTextureImage");
  RESOLVED_PROC(PFNGLGETTEXTUREIMAGEPROC)( texture_, level_, format_, type_, bufSize_, pixels_ );
}

void glGetCompressedTextureImageWrapper(GLuint texture_, GLint level_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC, "glGetCompressedTextureImage");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)( texture_, level_, bufSize_, pixels_ );
}

void glGetTextureLevelParameterfvWrapper(GLuint texture_, GLint level_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETTEXTURELEVELPARAMETERFVPROC, "glGetTextureLevelParameterfv");
  RESOLVED_PROC(PFNGLGETTEXTURELEVELPARAMETERFVPROC)( texture_, level_, pname_, params_ );
}

void glGetTextureLevelParameterivWrapper(GLuint texture_, GLint level_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTURELEVELPARAMETERIVPROC, "glGetTextureLevelParameteriv");
  RESOLVED_PROC(PFNGLGETTEXTURELEVELPARAMETERIVPROC)( texture_, level_, pname_, params_ );
}

void glGetTextureParameterfvWrapper(GLuint texture_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERFVPROC, "glGetTextureParameterfv");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERFVPROC)( texture_, pname_, params_ );
}

void glGetTextureParameterIivWrapper(GLuint texture_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIIVPROC, "glGetTextureParameterIiv");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIIVPROC)( texture_, pname_, params_ );
}

void glGetTextureParameterIuivWrapper(GLuint texture_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIUIVPROC, "glGetTextureParameterIuiv");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIUIVPROC)( texture_, pname_, params_ );
}

void glGetTextureParameterivWrapper(GLuint texture_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIVPROC, "glGetTextureParameteriv");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIVPROC)( texture_, pname_, params_ );
}

void glCreateVertexArraysWrapper(GLsizei n_, GLuint* arrays_)
{
  RESOLVE(PFNGLCREATEVERTEXARRAYSPROC, "glCreateVertexArrays");
  RESOLVED_PROC(PFNGLCREATEVERTEXARRAYSPROC)( n_, arrays_ );
}

void glDisableVertexArrayAttribWrapper(GLuint vaobj_, GLuint index_)
{
  RESOLVE(PFNGLDISABLEVERTEXARRAYATTRIBPROC, "glDisableVertexArrayAttrib");
  RESOLVED_PROC(PFNGLDISABLEVERTEXARRAYATTRIBPROC)( vaobj_, index_ );
}

void glEnableVertexArrayAttribWrapper(GLuint vaobj_, GLuint index_)
{
  RESOLVE(PFNGLENABLEVERTEXARRAYATTRIBPROC, "glEnableVertexArrayAttrib");
  RESOLVED_PROC(PFNGLENABLEVERTEXARRAYATTRIBPROC)( vaobj_, index_ );
}

void glVertexArrayElementBufferWrapper(GLuint vaobj_, GLuint buffer_)
{
  RESOLVE(PFNGLVERTEXARRAYELEMENTBUFFERPROC, "glVertexArrayElementBuffer");
  RESOLVED_PROC(PFNGLVERTEXARRAYELEMENTBUFFERPROC)( vaobj_, buffer_ );
}

void glVertexArrayVertexBufferWrapper(GLuint vaobj_, GLuint bindingindex_, GLuint buffer_, GLintptr offset_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXBUFFERPROC, "glVertexArrayVertexBuffer");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXBUFFERPROC)( vaobj_, bindingindex_, buffer_, offset_, stride_ );
}

void glVertexArrayVertexBuffersWrapper(GLuint vaobj_, GLuint first_, GLsizei count_, const GLuint* buffers_, const GLintptr* offsets_, const GLsizei* strides_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXBUFFERSPROC, "glVertexArrayVertexBuffers");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXBUFFERSPROC)( vaobj_, first_, count_, buffers_, offsets_, strides_ );
}

void glVertexArrayAttribBindingWrapper(GLuint vaobj_, GLuint attribindex_, GLuint bindingindex_)
{
  RESOLVE(PFNGLVERTEXARRAYATTRIBBINDINGPROC, "glVertexArrayAttribBinding");
  RESOLVED_PROC(PFNGLVERTEXARRAYATTRIBBINDINGPROC)( vaobj_, attribindex_, bindingindex_ );
}

void glVertexArrayAttribFormatWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLboolean normalized_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYATTRIBFORMATPROC, "glVertexArrayAttribFormat");
  RESOLVED_PROC(PFNGLVERTEXARRAYATTRIBFORMATPROC)( vaobj_, attribindex_, size_, type_, normalized_, relativeoffset_ );
}

void glVertexArrayAttribIFormatWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYATTRIBIFORMATPROC, "glVertexArrayAttribIFormat");
  RESOLVED_PROC(PFNGLVERTEXARRAYATTRIBIFORMATPROC)( vaobj_, attribindex_, size_, type_, relativeoffset_ );
}

void glVertexArrayAttribLFormatWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYATTRIBLFORMATPROC, "glVertexArrayAttribLFormat");
  RESOLVED_PROC(PFNGLVERTEXARRAYATTRIBLFORMATPROC)( vaobj_, attribindex_, size_, type_, relativeoffset_ );
}

void glVertexArrayBindingDivisorWrapper(GLuint vaobj_, GLuint bindingindex_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXARRAYBINDINGDIVISORPROC, "glVertexArrayBindingDivisor");
  RESOLVED_PROC(PFNGLVERTEXARRAYBINDINGDIVISORPROC)( vaobj_, bindingindex_, divisor_ );
}

void glGetVertexArrayivWrapper(GLuint vaobj_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYIVPROC, "glGetVertexArrayiv");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYIVPROC)( vaobj_, pname_, param_ );
}

void glGetVertexArrayIndexedivWrapper(GLuint vaobj_, GLuint index_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYINDEXEDIVPROC, "glGetVertexArrayIndexediv");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYINDEXEDIVPROC)( vaobj_, index_, pname_, param_ );
}

void glGetVertexArrayIndexed64ivWrapper(GLuint vaobj_, GLuint index_, GLenum pname_, GLint64* param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYINDEXED64IVPROC, "glGetVertexArrayIndexed64iv");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYINDEXED64IVPROC)( vaobj_, index_, pname_, param_ );
}

void glCreateSamplersWrapper(GLsizei n_, GLuint* samplers_)
{
  RESOLVE(PFNGLCREATESAMPLERSPROC, "glCreateSamplers");
  RESOLVED_PROC(PFNGLCREATESAMPLERSPROC)( n_, samplers_ );
}

void glCreateProgramPipelinesWrapper(GLsizei n_, GLuint* pipelines_)
{
  RESOLVE(PFNGLCREATEPROGRAMPIPELINESPROC, "glCreateProgramPipelines");
  RESOLVED_PROC(PFNGLCREATEPROGRAMPIPELINESPROC)( n_, pipelines_ );
}

void glCreateQueriesWrapper(GLenum target_, GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLCREATEQUERIESPROC, "glCreateQueries");
  RESOLVED_PROC(PFNGLCREATEQUERIESPROC)( target_, n_, ids_ );
}

void glGetQueryBufferObjecti64vWrapper(GLuint id_, GLuint buffer_, GLenum pname_, GLintptr offset_)
{
  RESOLVE(PFNGLGETQUERYBUFFEROBJECTI64VPROC, "glGetQueryBufferObjecti64v");
  RESOLVED_PROC(PFNGLGETQUERYBUFFEROBJECTI64VPROC)( id_, buffer_, pname_, offset_ );
}

void glGetQueryBufferObjectivWrapper(GLuint id_, GLuint buffer_, GLenum pname_, GLintptr offset_)
{
  RESOLVE(PFNGLGETQUERYBUFFEROBJECTIVPROC, "glGetQueryBufferObjectiv");
  RESOLVED_PROC(PFNGLGETQUERYBUFFEROBJECTIVPROC)( id_, buffer_, pname_, offset_ );
}

void glGetQueryBufferObjectui64vWrapper(GLuint id_, GLuint buffer_, GLenum pname_, GLintptr offset_)
{
  RESOLVE(PFNGLGETQUERYBUFFEROBJECTUI64VPROC, "glGetQueryBufferObjectui64v");
  RESOLVED_PROC(PFNGLGETQUERYBUFFEROBJECTUI64VPROC)( id_, buffer_, pname_, offset_ );
}

void glGetQueryBufferObjectuivWrapper(GLuint id_, GLuint buffer_, GLenum pname_, GLintptr offset_)
{
  RESOLVE(PFNGLGETQUERYBUFFEROBJECTUIVPROC, "glGetQueryBufferObjectuiv");
  RESOLVED_PROC(PFNGLGETQUERYBUFFEROBJECTUIVPROC)( id_, buffer_, pname_, offset_ );
}

void glMemoryBarrierByRegionWrapper(GLbitfield barriers_)
{
  RESOLVE(PFNGLMEMORYBARRIERBYREGIONPROC, "glMemoryBarrierByRegion");
  RESOLVED_PROC(PFNGLMEMORYBARRIERBYREGIONPROC)( barriers_ );
}

void glGetTextureSubImageWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETTEXTURESUBIMAGEPROC, "glGetTextureSubImage");
  RESOLVED_PROC(PFNGLGETTEXTURESUBIMAGEPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, bufSize_, pixels_ );
}

void glGetCompressedTextureSubImageWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC, "glGetCompressedTextureSubImage");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, bufSize_, pixels_ );
}

GLenum glGetGraphicsResetStatusWrapper(void)
{
  RESOLVE_RET(PFNGLGETGRAPHICSRESETSTATUSPROC, "glGetGraphicsResetStatus", FALSE);
  return RESOLVED_PROC(PFNGLGETGRAPHICSRESETSTATUSPROC)( );
}

void glGetnCompressedTexImageWrapper(GLenum target_, GLint lod_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETNCOMPRESSEDTEXIMAGEPROC, "glGetnCompressedTexImage");
  RESOLVED_PROC(PFNGLGETNCOMPRESSEDTEXIMAGEPROC)( target_, lod_, bufSize_, pixels_ );
}

void glGetnTexImageWrapper(GLenum target_, GLint level_, GLenum format_, GLenum type_, GLsizei bufSize_, void * pixels_)
{
  RESOLVE(PFNGLGETNTEXIMAGEPROC, "glGetnTexImage");
  RESOLVED_PROC(PFNGLGETNTEXIMAGEPROC)( target_, level_, format_, type_, bufSize_, pixels_ );
}

void glGetnUniformdvWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLdouble* params_)
{
  RESOLVE(PFNGLGETNUNIFORMDVPROC, "glGetnUniformdv");
  RESOLVED_PROC(PFNGLGETNUNIFORMDVPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformfvWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLfloat* params_)
{
  RESOLVE(PFNGLGETNUNIFORMFVPROC, "glGetnUniformfv");
  RESOLVED_PROC(PFNGLGETNUNIFORMFVPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformivWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLint* params_)
{
  RESOLVE(PFNGLGETNUNIFORMIVPROC, "glGetnUniformiv");
  RESOLVED_PROC(PFNGLGETNUNIFORMIVPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformuivWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLuint* params_)
{
  RESOLVE(PFNGLGETNUNIFORMUIVPROC, "glGetnUniformuiv");
  RESOLVED_PROC(PFNGLGETNUNIFORMUIVPROC)( program_, location_, bufSize_, params_ );
}

void glReadnPixelsWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, GLsizei bufSize_, void * data_)
{
  RESOLVE(PFNGLREADNPIXELSPROC, "glReadnPixels");
  RESOLVED_PROC(PFNGLREADNPIXELSPROC)( x_, y_, width_, height_, format_, type_, bufSize_, data_ );
}

void glGetnMapdvWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLdouble* v_)
{
  RESOLVE(PFNGLGETNMAPDVPROC, "glGetnMapdv");
  RESOLVED_PROC(PFNGLGETNMAPDVPROC)( target_, query_, bufSize_, v_ );
}

void glGetnMapfvWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLfloat* v_)
{
  RESOLVE(PFNGLGETNMAPFVPROC, "glGetnMapfv");
  RESOLVED_PROC(PFNGLGETNMAPFVPROC)( target_, query_, bufSize_, v_ );
}

void glGetnMapivWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLint* v_)
{
  RESOLVE(PFNGLGETNMAPIVPROC, "glGetnMapiv");
  RESOLVED_PROC(PFNGLGETNMAPIVPROC)( target_, query_, bufSize_, v_ );
}

void glGetnPixelMapfvWrapper(GLenum map_, GLsizei bufSize_, GLfloat* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPFVPROC, "glGetnPixelMapfv");
  RESOLVED_PROC(PFNGLGETNPIXELMAPFVPROC)( map_, bufSize_, values_ );
}

void glGetnPixelMapuivWrapper(GLenum map_, GLsizei bufSize_, GLuint* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPUIVPROC, "glGetnPixelMapuiv");
  RESOLVED_PROC(PFNGLGETNPIXELMAPUIVPROC)( map_, bufSize_, values_ );
}

void glGetnPixelMapusvWrapper(GLenum map_, GLsizei bufSize_, GLushort* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPUSVPROC, "glGetnPixelMapusv");
  RESOLVED_PROC(PFNGLGETNPIXELMAPUSVPROC)( map_, bufSize_, values_ );
}

void glGetnPolygonStippleWrapper(GLsizei bufSize_, GLubyte* pattern_)
{
  RESOLVE(PFNGLGETNPOLYGONSTIPPLEPROC, "glGetnPolygonStipple");
  RESOLVED_PROC(PFNGLGETNPOLYGONSTIPPLEPROC)( bufSize_, pattern_ );
}

void glGetnColorTableWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei bufSize_, void * table_)
{
  RESOLVE(PFNGLGETNCOLORTABLEPROC, "glGetnColorTable");
  RESOLVED_PROC(PFNGLGETNCOLORTABLEPROC)( target_, format_, type_, bufSize_, table_ );
}

void glGetnConvolutionFilterWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei bufSize_, void * image_)
{
  RESOLVE(PFNGLGETNCONVOLUTIONFILTERPROC, "glGetnConvolutionFilter");
  RESOLVED_PROC(PFNGLGETNCONVOLUTIONFILTERPROC)( target_, format_, type_, bufSize_, image_ );
}

void glGetnSeparableFilterWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei rowBufSize_, void * row_, GLsizei columnBufSize_, void * column_, void * span_)
{
  RESOLVE(PFNGLGETNSEPARABLEFILTERPROC, "glGetnSeparableFilter");
  RESOLVED_PROC(PFNGLGETNSEPARABLEFILTERPROC)( target_, format_, type_, rowBufSize_, row_, columnBufSize_, column_, span_ );
}

void glGetnHistogramWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, GLsizei bufSize_, void * values_)
{
  RESOLVE(PFNGLGETNHISTOGRAMPROC, "glGetnHistogram");
  RESOLVED_PROC(PFNGLGETNHISTOGRAMPROC)( target_, reset_, format_, type_, bufSize_, values_ );
}

void glGetnMinmaxWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, GLsizei bufSize_, void * values_)
{
  RESOLVE(PFNGLGETNMINMAXPROC, "glGetnMinmax");
  RESOLVED_PROC(PFNGLGETNMINMAXPROC)( target_, reset_, format_, type_, bufSize_, values_ );
}

void glTextureBarrierWrapper(void)
{
  RESOLVE(PFNGLTEXTUREBARRIERPROC, "glTextureBarrier");
  RESOLVED_PROC(PFNGLTEXTUREBARRIERPROC)(  );
}

void glPrimitiveBoundingBoxARBWrapper(GLfloat minX_, GLfloat minY_, GLfloat minZ_, GLfloat minW_, GLfloat maxX_, GLfloat maxY_, GLfloat maxZ_, GLfloat maxW_)
{
  RESOLVE(PFNGLPRIMITIVEBOUNDINGBOXARBPROC, "glPrimitiveBoundingBoxARB");
  RESOLVED_PROC(PFNGLPRIMITIVEBOUNDINGBOXARBPROC)( minX_, minY_, minZ_, minW_, maxX_, maxY_, maxZ_, maxW_ );
}

GLuint64 glGetTextureHandleARBWrapper(GLuint texture_)
{
  RESOLVE_RET(PFNGLGETTEXTUREHANDLEARBPROC, "glGetTextureHandleARB", FALSE);
  return RESOLVED_PROC(PFNGLGETTEXTUREHANDLEARBPROC)(texture_ );
}

GLuint64 glGetTextureSamplerHandleARBWrapper(GLuint texture_, GLuint sampler_)
{
  RESOLVE_RET(PFNGLGETTEXTURESAMPLERHANDLEARBPROC, "glGetTextureSamplerHandleARB", FALSE);
  return RESOLVED_PROC(PFNGLGETTEXTURESAMPLERHANDLEARBPROC)(texture_, sampler_ );
}

void glMakeTextureHandleResidentARBWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKETEXTUREHANDLERESIDENTARBPROC, "glMakeTextureHandleResidentARB");
  RESOLVED_PROC(PFNGLMAKETEXTUREHANDLERESIDENTARBPROC)( handle_ );
}

void glMakeTextureHandleNonResidentARBWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC, "glMakeTextureHandleNonResidentARB");
  RESOLVED_PROC(PFNGLMAKETEXTUREHANDLENONRESIDENTARBPROC)( handle_ );
}

GLuint64 glGetImageHandleARBWrapper(GLuint texture_, GLint level_, GLboolean layered_, GLint layer_, GLenum format_)
{
  RESOLVE_RET(PFNGLGETIMAGEHANDLEARBPROC, "glGetImageHandleARB", FALSE);
  return RESOLVED_PROC(PFNGLGETIMAGEHANDLEARBPROC)(texture_, level_, layered_, layer_, format_ );
}

void glMakeImageHandleResidentARBWrapper(GLuint64 handle_, GLenum access_)
{
  RESOLVE(PFNGLMAKEIMAGEHANDLERESIDENTARBPROC, "glMakeImageHandleResidentARB");
  RESOLVED_PROC(PFNGLMAKEIMAGEHANDLERESIDENTARBPROC)( handle_, access_ );
}

void glMakeImageHandleNonResidentARBWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC, "glMakeImageHandleNonResidentARB");
  RESOLVED_PROC(PFNGLMAKEIMAGEHANDLENONRESIDENTARBPROC)( handle_ );
}

void glUniformHandleui64ARBWrapper(GLint location_, GLuint64 value_)
{
  RESOLVE(PFNGLUNIFORMHANDLEUI64ARBPROC, "glUniformHandleui64ARB");
  RESOLVED_PROC(PFNGLUNIFORMHANDLEUI64ARBPROC)( location_, value_ );
}

void glUniformHandleui64vARBWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORMHANDLEUI64VARBPROC, "glUniformHandleui64vARB");
  RESOLVED_PROC(PFNGLUNIFORMHANDLEUI64VARBPROC)( location_, count_, value_ );
}

void glProgramUniformHandleui64ARBWrapper(GLuint program_, GLint location_, GLuint64 value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC, "glProgramUniformHandleui64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMHANDLEUI64ARBPROC)( program_, location_, value_ );
}

void glProgramUniformHandleui64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* values_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC, "glProgramUniformHandleui64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMHANDLEUI64VARBPROC)( program_, location_, count_, values_ );
}

GLboolean glIsTextureHandleResidentARBWrapper(GLuint64 handle_)
{
  RESOLVE_RET(PFNGLISTEXTUREHANDLERESIDENTARBPROC, "glIsTextureHandleResidentARB", FALSE);
  return RESOLVED_PROC(PFNGLISTEXTUREHANDLERESIDENTARBPROC)(handle_ );
}

GLboolean glIsImageHandleResidentARBWrapper(GLuint64 handle_)
{
  RESOLVE_RET(PFNGLISIMAGEHANDLERESIDENTARBPROC, "glIsImageHandleResidentARB", FALSE);
  return RESOLVED_PROC(PFNGLISIMAGEHANDLERESIDENTARBPROC)(handle_ );
}

void glVertexAttribL1ui64ARBWrapper(GLuint index_, GLuint64EXT x_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1UI64ARBPROC, "glVertexAttribL1ui64ARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1UI64ARBPROC)( index_, x_ );
}

void glVertexAttribL1ui64vARBWrapper(GLuint index_, const GLuint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1UI64VARBPROC, "glVertexAttribL1ui64vARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1UI64VARBPROC)( index_, v_ );
}

void glGetVertexAttribLui64vARBWrapper(GLuint index_, GLenum pname_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBLUI64VARBPROC, "glGetVertexAttribLui64vARB");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBLUI64VARBPROC)( index_, pname_, params_ );
}

GLsync glCreateSyncFromCLeventARBWrapper(struct _cl_context* context_, struct _cl_event* event_, GLbitfield flags_)
{
  RESOLVE_RET(PFNGLCREATESYNCFROMCLEVENTARBPROC, "glCreateSyncFromCLeventARB", FALSE);
  return RESOLVED_PROC(PFNGLCREATESYNCFROMCLEVENTARBPROC)(context_, event_, flags_ );
}

void glClampColorARBWrapper(GLenum target_, GLenum clamp_)
{
  RESOLVE(PFNGLCLAMPCOLORARBPROC, "glClampColorARB");
  RESOLVED_PROC(PFNGLCLAMPCOLORARBPROC)( target_, clamp_ );
}

void glDispatchComputeGroupSizeARBWrapper(GLuint num_groups_x_, GLuint num_groups_y_, GLuint num_groups_z_, GLuint group_size_x_, GLuint group_size_y_, GLuint group_size_z_)
{
  RESOLVE(PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC, "glDispatchComputeGroupSizeARB");
  RESOLVED_PROC(PFNGLDISPATCHCOMPUTEGROUPSIZEARBPROC)( num_groups_x_, num_groups_y_, num_groups_z_, group_size_x_, group_size_y_, group_size_z_ );
}

void glDebugMessageControlARBWrapper(GLenum source_, GLenum type_, GLenum severity_, GLsizei count_, const GLuint* ids_, GLboolean enabled_)
{
  RESOLVE(PFNGLDEBUGMESSAGECONTROLARBPROC, "glDebugMessageControlARB");
  RESOLVED_PROC(PFNGLDEBUGMESSAGECONTROLARBPROC)( source_, type_, severity_, count_, ids_, enabled_ );
}

void glDebugMessageInsertARBWrapper(GLenum source_, GLenum type_, GLuint id_, GLenum severity_, GLsizei length_, const GLchar* buf_)
{
  RESOLVE(PFNGLDEBUGMESSAGEINSERTARBPROC, "glDebugMessageInsertARB");
  RESOLVED_PROC(PFNGLDEBUGMESSAGEINSERTARBPROC)( source_, type_, id_, severity_, length_, buf_ );
}

void glDebugMessageCallbackARBWrapper(GLDEBUGPROCARB callback_, const void * userParam_)
{
  RESOLVE(PFNGLDEBUGMESSAGECALLBACKARBPROC, "glDebugMessageCallbackARB");
  RESOLVED_PROC(PFNGLDEBUGMESSAGECALLBACKARBPROC)( callback_, userParam_ );
}

GLuint glGetDebugMessageLogARBWrapper(GLuint count_, GLsizei bufSize_, GLenum* sources_, GLenum* types_, GLuint* ids_, GLenum* severities_, GLsizei* lengths_, GLchar* messageLog_)
{
  RESOLVE_RET(PFNGLGETDEBUGMESSAGELOGARBPROC, "glGetDebugMessageLogARB", FALSE);
  return RESOLVED_PROC(PFNGLGETDEBUGMESSAGELOGARBPROC)(count_, bufSize_, sources_, types_, ids_, severities_, lengths_, messageLog_ );
}

void glDrawBuffersARBWrapper(GLsizei n_, const GLenum* bufs_)
{
  RESOLVE(PFNGLDRAWBUFFERSARBPROC, "glDrawBuffersARB");
  RESOLVED_PROC(PFNGLDRAWBUFFERSARBPROC)( n_, bufs_ );
}

void glBlendEquationiARBWrapper(GLuint buf_, GLenum mode_)
{
  RESOLVE(PFNGLBLENDEQUATIONIARBPROC, "glBlendEquationiARB");
  RESOLVED_PROC(PFNGLBLENDEQUATIONIARBPROC)( buf_, mode_ );
}

void glBlendEquationSeparateiARBWrapper(GLuint buf_, GLenum modeRGB_, GLenum modeAlpha_)
{
  RESOLVE(PFNGLBLENDEQUATIONSEPARATEIARBPROC, "glBlendEquationSeparateiARB");
  RESOLVED_PROC(PFNGLBLENDEQUATIONSEPARATEIARBPROC)( buf_, modeRGB_, modeAlpha_ );
}

void glBlendFunciARBWrapper(GLuint buf_, GLenum src_, GLenum dst_)
{
  RESOLVE(PFNGLBLENDFUNCIARBPROC, "glBlendFunciARB");
  RESOLVED_PROC(PFNGLBLENDFUNCIARBPROC)( buf_, src_, dst_ );
}

void glBlendFuncSeparateiARBWrapper(GLuint buf_, GLenum srcRGB_, GLenum dstRGB_, GLenum srcAlpha_, GLenum dstAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEIARBPROC, "glBlendFuncSeparateiARB");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEIARBPROC)( buf_, srcRGB_, dstRGB_, srcAlpha_, dstAlpha_ );
}

void glDrawArraysInstancedARBWrapper(GLenum mode_, GLint first_, GLsizei count_, GLsizei primcount_)
{
  RESOLVE(PFNGLDRAWARRAYSINSTANCEDARBPROC, "glDrawArraysInstancedARB");
  RESOLVED_PROC(PFNGLDRAWARRAYSINSTANCEDARBPROC)( mode_, first_, count_, primcount_ );
}

void glDrawElementsInstancedARBWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei primcount_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDARBPROC, "glDrawElementsInstancedARB");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDARBPROC)( mode_, count_, type_, indices_, primcount_ );
}

void glProgramStringARBWrapper(GLenum target_, GLenum format_, GLsizei len_, const void * string_)
{
  RESOLVE(PFNGLPROGRAMSTRINGARBPROC, "glProgramStringARB");
  RESOLVED_PROC(PFNGLPROGRAMSTRINGARBPROC)( target_, format_, len_, string_ );
}

void glBindProgramARBWrapper(GLenum target_, GLuint program_)
{
  RESOLVE(PFNGLBINDPROGRAMARBPROC, "glBindProgramARB");
  RESOLVED_PROC(PFNGLBINDPROGRAMARBPROC)( target_, program_ );
}

void glDeleteProgramsARBWrapper(GLsizei n_, const GLuint* programs_)
{
  RESOLVE(PFNGLDELETEPROGRAMSARBPROC, "glDeleteProgramsARB");
  RESOLVED_PROC(PFNGLDELETEPROGRAMSARBPROC)( n_, programs_ );
}

void glGenProgramsARBWrapper(GLsizei n_, GLuint* programs_)
{
  RESOLVE(PFNGLGENPROGRAMSARBPROC, "glGenProgramsARB");
  RESOLVED_PROC(PFNGLGENPROGRAMSARBPROC)( n_, programs_ );
}

void glProgramEnvParameter4dARBWrapper(GLenum target_, GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETER4DARBPROC, "glProgramEnvParameter4dARB");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETER4DARBPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramEnvParameter4dvARBWrapper(GLenum target_, GLuint index_, const GLdouble* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETER4DVARBPROC, "glProgramEnvParameter4dvARB");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETER4DVARBPROC)( target_, index_, params_ );
}

void glProgramEnvParameter4fARBWrapper(GLenum target_, GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETER4FARBPROC, "glProgramEnvParameter4fARB");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETER4FARBPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramEnvParameter4fvARBWrapper(GLenum target_, GLuint index_, const GLfloat* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETER4FVARBPROC, "glProgramEnvParameter4fvARB");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETER4FVARBPROC)( target_, index_, params_ );
}

void glProgramLocalParameter4dARBWrapper(GLenum target_, GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETER4DARBPROC, "glProgramLocalParameter4dARB");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETER4DARBPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramLocalParameter4dvARBWrapper(GLenum target_, GLuint index_, const GLdouble* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETER4DVARBPROC, "glProgramLocalParameter4dvARB");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)( target_, index_, params_ );
}

void glProgramLocalParameter4fARBWrapper(GLenum target_, GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETER4FARBPROC, "glProgramLocalParameter4fARB");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETER4FARBPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramLocalParameter4fvARBWrapper(GLenum target_, GLuint index_, const GLfloat* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETER4FVARBPROC, "glProgramLocalParameter4fvARB");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)( target_, index_, params_ );
}

void glGetProgramEnvParameterdvARBWrapper(GLenum target_, GLuint index_, GLdouble* params_)
{
  RESOLVE(PFNGLGETPROGRAMENVPARAMETERDVARBPROC, "glGetProgramEnvParameterdvARB");
  RESOLVED_PROC(PFNGLGETPROGRAMENVPARAMETERDVARBPROC)( target_, index_, params_ );
}

void glGetProgramEnvParameterfvARBWrapper(GLenum target_, GLuint index_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPROGRAMENVPARAMETERFVARBPROC, "glGetProgramEnvParameterfvARB");
  RESOLVED_PROC(PFNGLGETPROGRAMENVPARAMETERFVARBPROC)( target_, index_, params_ );
}

void glGetProgramLocalParameterdvARBWrapper(GLenum target_, GLuint index_, GLdouble* params_)
{
  RESOLVE(PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC, "glGetProgramLocalParameterdvARB");
  RESOLVED_PROC(PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)( target_, index_, params_ );
}

void glGetProgramLocalParameterfvARBWrapper(GLenum target_, GLuint index_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC, "glGetProgramLocalParameterfvARB");
  RESOLVED_PROC(PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)( target_, index_, params_ );
}

void glGetProgramivARBWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMIVARBPROC, "glGetProgramivARB");
  RESOLVED_PROC(PFNGLGETPROGRAMIVARBPROC)( target_, pname_, params_ );
}

void glGetProgramStringARBWrapper(GLenum target_, GLenum pname_, void * string_)
{
  RESOLVE(PFNGLGETPROGRAMSTRINGARBPROC, "glGetProgramStringARB");
  RESOLVED_PROC(PFNGLGETPROGRAMSTRINGARBPROC)( target_, pname_, string_ );
}

GLboolean glIsProgramARBWrapper(GLuint program_)
{
  RESOLVE_RET(PFNGLISPROGRAMARBPROC, "glIsProgramARB", FALSE);
  return RESOLVED_PROC(PFNGLISPROGRAMARBPROC)(program_ );
}

void glProgramParameteriARBWrapper(GLuint program_, GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLPROGRAMPARAMETERIARBPROC, "glProgramParameteriARB");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETERIARBPROC)( program_, pname_, value_ );
}

void glFramebufferTextureARBWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREARBPROC, "glFramebufferTextureARB");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREARBPROC)( target_, attachment_, texture_, level_ );
}

void glFramebufferTextureLayerARBWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLint layer_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURELAYERARBPROC, "glFramebufferTextureLayerARB");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)( target_, attachment_, texture_, level_, layer_ );
}

void glFramebufferTextureFaceARBWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLenum face_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREFACEARBPROC, "glFramebufferTextureFaceARB");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)( target_, attachment_, texture_, level_, face_ );
}

void glUniform1i64ARBWrapper(GLint location_, GLint64 x_)
{
  RESOLVE(PFNGLUNIFORM1I64ARBPROC, "glUniform1i64ARB");
  RESOLVED_PROC(PFNGLUNIFORM1I64ARBPROC)( location_, x_ );
}

void glUniform2i64ARBWrapper(GLint location_, GLint64 x_, GLint64 y_)
{
  RESOLVE(PFNGLUNIFORM2I64ARBPROC, "glUniform2i64ARB");
  RESOLVED_PROC(PFNGLUNIFORM2I64ARBPROC)( location_, x_, y_ );
}

void glUniform3i64ARBWrapper(GLint location_, GLint64 x_, GLint64 y_, GLint64 z_)
{
  RESOLVE(PFNGLUNIFORM3I64ARBPROC, "glUniform3i64ARB");
  RESOLVED_PROC(PFNGLUNIFORM3I64ARBPROC)( location_, x_, y_, z_ );
}

void glUniform4i64ARBWrapper(GLint location_, GLint64 x_, GLint64 y_, GLint64 z_, GLint64 w_)
{
  RESOLVE(PFNGLUNIFORM4I64ARBPROC, "glUniform4i64ARB");
  RESOLVED_PROC(PFNGLUNIFORM4I64ARBPROC)( location_, x_, y_, z_, w_ );
}

void glUniform1i64vARBWrapper(GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLUNIFORM1I64VARBPROC, "glUniform1i64vARB");
  RESOLVED_PROC(PFNGLUNIFORM1I64VARBPROC)( location_, count_, value_ );
}

void glUniform2i64vARBWrapper(GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLUNIFORM2I64VARBPROC, "glUniform2i64vARB");
  RESOLVED_PROC(PFNGLUNIFORM2I64VARBPROC)( location_, count_, value_ );
}

void glUniform3i64vARBWrapper(GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLUNIFORM3I64VARBPROC, "glUniform3i64vARB");
  RESOLVED_PROC(PFNGLUNIFORM3I64VARBPROC)( location_, count_, value_ );
}

void glUniform4i64vARBWrapper(GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLUNIFORM4I64VARBPROC, "glUniform4i64vARB");
  RESOLVED_PROC(PFNGLUNIFORM4I64VARBPROC)( location_, count_, value_ );
}

void glUniform1ui64ARBWrapper(GLint location_, GLuint64 x_)
{
  RESOLVE(PFNGLUNIFORM1UI64ARBPROC, "glUniform1ui64ARB");
  RESOLVED_PROC(PFNGLUNIFORM1UI64ARBPROC)( location_, x_ );
}

void glUniform2ui64ARBWrapper(GLint location_, GLuint64 x_, GLuint64 y_)
{
  RESOLVE(PFNGLUNIFORM2UI64ARBPROC, "glUniform2ui64ARB");
  RESOLVED_PROC(PFNGLUNIFORM2UI64ARBPROC)( location_, x_, y_ );
}

void glUniform3ui64ARBWrapper(GLint location_, GLuint64 x_, GLuint64 y_, GLuint64 z_)
{
  RESOLVE(PFNGLUNIFORM3UI64ARBPROC, "glUniform3ui64ARB");
  RESOLVED_PROC(PFNGLUNIFORM3UI64ARBPROC)( location_, x_, y_, z_ );
}

void glUniform4ui64ARBWrapper(GLint location_, GLuint64 x_, GLuint64 y_, GLuint64 z_, GLuint64 w_)
{
  RESOLVE(PFNGLUNIFORM4UI64ARBPROC, "glUniform4ui64ARB");
  RESOLVED_PROC(PFNGLUNIFORM4UI64ARBPROC)( location_, x_, y_, z_, w_ );
}

void glUniform1ui64vARBWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORM1UI64VARBPROC, "glUniform1ui64vARB");
  RESOLVED_PROC(PFNGLUNIFORM1UI64VARBPROC)( location_, count_, value_ );
}

void glUniform2ui64vARBWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORM2UI64VARBPROC, "glUniform2ui64vARB");
  RESOLVED_PROC(PFNGLUNIFORM2UI64VARBPROC)( location_, count_, value_ );
}

void glUniform3ui64vARBWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORM3UI64VARBPROC, "glUniform3ui64vARB");
  RESOLVED_PROC(PFNGLUNIFORM3UI64VARBPROC)( location_, count_, value_ );
}

void glUniform4ui64vARBWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORM4UI64VARBPROC, "glUniform4ui64vARB");
  RESOLVED_PROC(PFNGLUNIFORM4UI64VARBPROC)( location_, count_, value_ );
}

void glGetUniformi64vARBWrapper(GLuint program_, GLint location_, GLint64* params_)
{
  RESOLVE(PFNGLGETUNIFORMI64VARBPROC, "glGetUniformi64vARB");
  RESOLVED_PROC(PFNGLGETUNIFORMI64VARBPROC)( program_, location_, params_ );
}

void glGetUniformui64vARBWrapper(GLuint program_, GLint location_, GLuint64* params_)
{
  RESOLVE(PFNGLGETUNIFORMUI64VARBPROC, "glGetUniformui64vARB");
  RESOLVED_PROC(PFNGLGETUNIFORMUI64VARBPROC)( program_, location_, params_ );
}

void glGetnUniformi64vARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLint64* params_)
{
  RESOLVE(PFNGLGETNUNIFORMI64VARBPROC, "glGetnUniformi64vARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMI64VARBPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformui64vARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLuint64* params_)
{
  RESOLVE(PFNGLGETNUNIFORMUI64VARBPROC, "glGetnUniformui64vARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMUI64VARBPROC)( program_, location_, bufSize_, params_ );
}

void glProgramUniform1i64ARBWrapper(GLuint program_, GLint location_, GLint64 x_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1I64ARBPROC, "glProgramUniform1i64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1I64ARBPROC)( program_, location_, x_ );
}

void glProgramUniform2i64ARBWrapper(GLuint program_, GLint location_, GLint64 x_, GLint64 y_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2I64ARBPROC, "glProgramUniform2i64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2I64ARBPROC)( program_, location_, x_, y_ );
}

void glProgramUniform3i64ARBWrapper(GLuint program_, GLint location_, GLint64 x_, GLint64 y_, GLint64 z_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3I64ARBPROC, "glProgramUniform3i64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3I64ARBPROC)( program_, location_, x_, y_, z_ );
}

void glProgramUniform4i64ARBWrapper(GLuint program_, GLint location_, GLint64 x_, GLint64 y_, GLint64 z_, GLint64 w_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4I64ARBPROC, "glProgramUniform4i64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4I64ARBPROC)( program_, location_, x_, y_, z_, w_ );
}

void glProgramUniform1i64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1I64VARBPROC, "glProgramUniform1i64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1I64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2i64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2I64VARBPROC, "glProgramUniform2i64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2I64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3i64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3I64VARBPROC, "glProgramUniform3i64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3I64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4i64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4I64VARBPROC, "glProgramUniform4i64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4I64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1ui64ARBWrapper(GLuint program_, GLint location_, GLuint64 x_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UI64ARBPROC, "glProgramUniform1ui64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UI64ARBPROC)( program_, location_, x_ );
}

void glProgramUniform2ui64ARBWrapper(GLuint program_, GLint location_, GLuint64 x_, GLuint64 y_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UI64ARBPROC, "glProgramUniform2ui64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UI64ARBPROC)( program_, location_, x_, y_ );
}

void glProgramUniform3ui64ARBWrapper(GLuint program_, GLint location_, GLuint64 x_, GLuint64 y_, GLuint64 z_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UI64ARBPROC, "glProgramUniform3ui64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UI64ARBPROC)( program_, location_, x_, y_, z_ );
}

void glProgramUniform4ui64ARBWrapper(GLuint program_, GLint location_, GLuint64 x_, GLuint64 y_, GLuint64 z_, GLuint64 w_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UI64ARBPROC, "glProgramUniform4ui64ARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UI64ARBPROC)( program_, location_, x_, y_, z_, w_ );
}

void glProgramUniform1ui64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UI64VARBPROC, "glProgramUniform1ui64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UI64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2ui64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UI64VARBPROC, "glProgramUniform2ui64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UI64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3ui64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UI64VARBPROC, "glProgramUniform3ui64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UI64VARBPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4ui64vARBWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UI64VARBPROC, "glProgramUniform4ui64vARB");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UI64VARBPROC)( program_, location_, count_, value_ );
}

void glColorTableWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLenum format_, GLenum type_, const void * table_)
{
  RESOLVE(PFNGLCOLORTABLEPROC, "glColorTable");
  RESOLVED_PROC(PFNGLCOLORTABLEPROC)( target_, internalformat_, width_, format_, type_, table_ );
}

void glColorTableParameterfvWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCOLORTABLEPARAMETERFVPROC, "glColorTableParameterfv");
  RESOLVED_PROC(PFNGLCOLORTABLEPARAMETERFVPROC)( target_, pname_, params_ );
}

void glColorTableParameterivWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLCOLORTABLEPARAMETERIVPROC, "glColorTableParameteriv");
  RESOLVED_PROC(PFNGLCOLORTABLEPARAMETERIVPROC)( target_, pname_, params_ );
}

void glCopyColorTableWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCOLORTABLEPROC, "glCopyColorTable");
  RESOLVED_PROC(PFNGLCOPYCOLORTABLEPROC)( target_, internalformat_, x_, y_, width_ );
}

void glGetColorTableWrapper(GLenum target_, GLenum format_, GLenum type_, void * table_)
{
  RESOLVE(PFNGLGETCOLORTABLEPROC, "glGetColorTable");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPROC)( target_, format_, type_, table_ );
}

void glGetColorTableParameterfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERFVPROC, "glGetColorTableParameterfv");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERFVPROC)( target_, pname_, params_ );
}

void glGetColorTableParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERIVPROC, "glGetColorTableParameteriv");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERIVPROC)( target_, pname_, params_ );
}

void glColorSubTableWrapper(GLenum target_, GLsizei start_, GLsizei count_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCOLORSUBTABLEPROC, "glColorSubTable");
  RESOLVED_PROC(PFNGLCOLORSUBTABLEPROC)( target_, start_, count_, format_, type_, data_ );
}

void glCopyColorSubTableWrapper(GLenum target_, GLsizei start_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCOLORSUBTABLEPROC, "glCopyColorSubTable");
  RESOLVED_PROC(PFNGLCOPYCOLORSUBTABLEPROC)( target_, start_, x_, y_, width_ );
}

void glConvolutionFilter1DWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLenum format_, GLenum type_, const void * image_)
{
  RESOLVE(PFNGLCONVOLUTIONFILTER1DPROC, "glConvolutionFilter1D");
  RESOLVED_PROC(PFNGLCONVOLUTIONFILTER1DPROC)( target_, internalformat_, width_, format_, type_, image_ );
}

void glConvolutionFilter2DWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * image_)
{
  RESOLVE(PFNGLCONVOLUTIONFILTER2DPROC, "glConvolutionFilter2D");
  RESOLVED_PROC(PFNGLCONVOLUTIONFILTER2DPROC)( target_, internalformat_, width_, height_, format_, type_, image_ );
}

void glConvolutionParameterfWrapper(GLenum target_, GLenum pname_, GLfloat params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERFPROC, "glConvolutionParameterf");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERFPROC)( target_, pname_, params_ );
}

void glConvolutionParameterfvWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERFVPROC, "glConvolutionParameterfv");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERFVPROC)( target_, pname_, params_ );
}

void glConvolutionParameteriWrapper(GLenum target_, GLenum pname_, GLint params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERIPROC, "glConvolutionParameteri");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERIPROC)( target_, pname_, params_ );
}

void glConvolutionParameterivWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERIVPROC, "glConvolutionParameteriv");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERIVPROC)( target_, pname_, params_ );
}

void glCopyConvolutionFilter1DWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCONVOLUTIONFILTER1DPROC, "glCopyConvolutionFilter1D");
  RESOLVED_PROC(PFNGLCOPYCONVOLUTIONFILTER1DPROC)( target_, internalformat_, x_, y_, width_ );
}

void glCopyConvolutionFilter2DWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYCONVOLUTIONFILTER2DPROC, "glCopyConvolutionFilter2D");
  RESOLVED_PROC(PFNGLCOPYCONVOLUTIONFILTER2DPROC)( target_, internalformat_, x_, y_, width_, height_ );
}

void glGetConvolutionFilterWrapper(GLenum target_, GLenum format_, GLenum type_, void * image_)
{
  RESOLVE(PFNGLGETCONVOLUTIONFILTERPROC, "glGetConvolutionFilter");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONFILTERPROC)( target_, format_, type_, image_ );
}

void glGetConvolutionParameterfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCONVOLUTIONPARAMETERFVPROC, "glGetConvolutionParameterfv");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONPARAMETERFVPROC)( target_, pname_, params_ );
}

void glGetConvolutionParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCONVOLUTIONPARAMETERIVPROC, "glGetConvolutionParameteriv");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONPARAMETERIVPROC)( target_, pname_, params_ );
}

void glGetSeparableFilterWrapper(GLenum target_, GLenum format_, GLenum type_, void * row_, void * column_, void * span_)
{
  RESOLVE(PFNGLGETSEPARABLEFILTERPROC, "glGetSeparableFilter");
  RESOLVED_PROC(PFNGLGETSEPARABLEFILTERPROC)( target_, format_, type_, row_, column_, span_ );
}

void glSeparableFilter2DWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * row_, const void * column_)
{
  RESOLVE(PFNGLSEPARABLEFILTER2DPROC, "glSeparableFilter2D");
  RESOLVED_PROC(PFNGLSEPARABLEFILTER2DPROC)( target_, internalformat_, width_, height_, format_, type_, row_, column_ );
}

void glGetHistogramWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, void * values_)
{
  RESOLVE(PFNGLGETHISTOGRAMPROC, "glGetHistogram");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPROC)( target_, reset_, format_, type_, values_ );
}

void glGetHistogramParameterfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETHISTOGRAMPARAMETERFVPROC, "glGetHistogramParameterfv");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPARAMETERFVPROC)( target_, pname_, params_ );
}

void glGetHistogramParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETHISTOGRAMPARAMETERIVPROC, "glGetHistogramParameteriv");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPARAMETERIVPROC)( target_, pname_, params_ );
}

void glGetMinmaxWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, void * values_)
{
  RESOLVE(PFNGLGETMINMAXPROC, "glGetMinmax");
  RESOLVED_PROC(PFNGLGETMINMAXPROC)( target_, reset_, format_, type_, values_ );
}

void glGetMinmaxParameterfvWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMINMAXPARAMETERFVPROC, "glGetMinmaxParameterfv");
  RESOLVED_PROC(PFNGLGETMINMAXPARAMETERFVPROC)( target_, pname_, params_ );
}

void glGetMinmaxParameterivWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMINMAXPARAMETERIVPROC, "glGetMinmaxParameteriv");
  RESOLVED_PROC(PFNGLGETMINMAXPARAMETERIVPROC)( target_, pname_, params_ );
}

void glHistogramWrapper(GLenum target_, GLsizei width_, GLenum internalformat_, GLboolean sink_)
{
  RESOLVE(PFNGLHISTOGRAMPROC, "glHistogram");
  RESOLVED_PROC(PFNGLHISTOGRAMPROC)( target_, width_, internalformat_, sink_ );
}

void glMinmaxWrapper(GLenum target_, GLenum internalformat_, GLboolean sink_)
{
  RESOLVE(PFNGLMINMAXPROC, "glMinmax");
  RESOLVED_PROC(PFNGLMINMAXPROC)( target_, internalformat_, sink_ );
}

void glResetHistogramWrapper(GLenum target_)
{
  RESOLVE(PFNGLRESETHISTOGRAMPROC, "glResetHistogram");
  RESOLVED_PROC(PFNGLRESETHISTOGRAMPROC)( target_ );
}

void glResetMinmaxWrapper(GLenum target_)
{
  RESOLVE(PFNGLRESETMINMAXPROC, "glResetMinmax");
  RESOLVED_PROC(PFNGLRESETMINMAXPROC)( target_ );
}

void glMultiDrawArraysIndirectCountARBWrapper(GLenum mode_, GLintptr indirect_, GLintptr drawcount_, GLsizei maxdrawcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC, "glMultiDrawArraysIndirectCountARB");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSINDIRECTCOUNTARBPROC)( mode_, indirect_, drawcount_, maxdrawcount_, stride_ );
}

void glMultiDrawElementsIndirectCountARBWrapper(GLenum mode_, GLenum type_, GLintptr indirect_, GLintptr drawcount_, GLsizei maxdrawcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC, "glMultiDrawElementsIndirectCountARB");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTARBPROC)( mode_, type_, indirect_, drawcount_, maxdrawcount_, stride_ );
}

void glVertexAttribDivisorARBWrapper(GLuint index_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXATTRIBDIVISORARBPROC, "glVertexAttribDivisorARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIBDIVISORARBPROC)( index_, divisor_ );
}

void glCurrentPaletteMatrixARBWrapper(GLint index_)
{
  RESOLVE(PFNGLCURRENTPALETTEMATRIXARBPROC, "glCurrentPaletteMatrixARB");
  RESOLVED_PROC(PFNGLCURRENTPALETTEMATRIXARBPROC)( index_ );
}

void glMatrixIndexubvARBWrapper(GLint size_, const GLubyte* indices_)
{
  RESOLVE(PFNGLMATRIXINDEXUBVARBPROC, "glMatrixIndexubvARB");
  RESOLVED_PROC(PFNGLMATRIXINDEXUBVARBPROC)( size_, indices_ );
}

void glMatrixIndexusvARBWrapper(GLint size_, const GLushort* indices_)
{
  RESOLVE(PFNGLMATRIXINDEXUSVARBPROC, "glMatrixIndexusvARB");
  RESOLVED_PROC(PFNGLMATRIXINDEXUSVARBPROC)( size_, indices_ );
}

void glMatrixIndexuivARBWrapper(GLint size_, const GLuint* indices_)
{
  RESOLVE(PFNGLMATRIXINDEXUIVARBPROC, "glMatrixIndexuivARB");
  RESOLVED_PROC(PFNGLMATRIXINDEXUIVARBPROC)( size_, indices_ );
}

void glMatrixIndexPointerARBWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLMATRIXINDEXPOINTERARBPROC, "glMatrixIndexPointerARB");
  RESOLVED_PROC(PFNGLMATRIXINDEXPOINTERARBPROC)( size_, type_, stride_, pointer_ );
}

void glSampleCoverageARBWrapper(GLfloat value_, GLboolean invert_)
{
  RESOLVE(PFNGLSAMPLECOVERAGEARBPROC, "glSampleCoverageARB");
  RESOLVED_PROC(PFNGLSAMPLECOVERAGEARBPROC)( value_, invert_ );
}

void glActiveTextureARBWrapper(GLenum texture_)
{
  RESOLVE(PFNGLACTIVETEXTUREARBPROC, "glActiveTextureARB");
  RESOLVED_PROC(PFNGLACTIVETEXTUREARBPROC)( texture_ );
}

void glClientActiveTextureARBWrapper(GLenum texture_)
{
  RESOLVE(PFNGLCLIENTACTIVETEXTUREARBPROC, "glClientActiveTextureARB");
  RESOLVED_PROC(PFNGLCLIENTACTIVETEXTUREARBPROC)( texture_ );
}

void glMultiTexCoord1dARBWrapper(GLenum target_, GLdouble s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1DARBPROC, "glMultiTexCoord1dARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1DARBPROC)( target_, s_ );
}

void glMultiTexCoord1dvARBWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1DVARBPROC, "glMultiTexCoord1dvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1DVARBPROC)( target_, v_ );
}

void glMultiTexCoord1fARBWrapper(GLenum target_, GLfloat s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1FARBPROC, "glMultiTexCoord1fARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1FARBPROC)( target_, s_ );
}

void glMultiTexCoord1fvARBWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1FVARBPROC, "glMultiTexCoord1fvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1FVARBPROC)( target_, v_ );
}

void glMultiTexCoord1iARBWrapper(GLenum target_, GLint s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1IARBPROC, "glMultiTexCoord1iARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1IARBPROC)( target_, s_ );
}

void glMultiTexCoord1ivARBWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1IVARBPROC, "glMultiTexCoord1ivARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1IVARBPROC)( target_, v_ );
}

void glMultiTexCoord1sARBWrapper(GLenum target_, GLshort s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1SARBPROC, "glMultiTexCoord1sARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1SARBPROC)( target_, s_ );
}

void glMultiTexCoord1svARBWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1SVARBPROC, "glMultiTexCoord1svARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1SVARBPROC)( target_, v_ );
}

void glMultiTexCoord2dARBWrapper(GLenum target_, GLdouble s_, GLdouble t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2DARBPROC, "glMultiTexCoord2dARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2DARBPROC)( target_, s_, t_ );
}

void glMultiTexCoord2dvARBWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2DVARBPROC, "glMultiTexCoord2dvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2DVARBPROC)( target_, v_ );
}

void glMultiTexCoord2fARBWrapper(GLenum target_, GLfloat s_, GLfloat t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2FARBPROC, "glMultiTexCoord2fARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2FARBPROC)( target_, s_, t_ );
}

void glMultiTexCoord2fvARBWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2FVARBPROC, "glMultiTexCoord2fvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2FVARBPROC)( target_, v_ );
}

void glMultiTexCoord2iARBWrapper(GLenum target_, GLint s_, GLint t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2IARBPROC, "glMultiTexCoord2iARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2IARBPROC)( target_, s_, t_ );
}

void glMultiTexCoord2ivARBWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2IVARBPROC, "glMultiTexCoord2ivARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2IVARBPROC)( target_, v_ );
}

void glMultiTexCoord2sARBWrapper(GLenum target_, GLshort s_, GLshort t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2SARBPROC, "glMultiTexCoord2sARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2SARBPROC)( target_, s_, t_ );
}

void glMultiTexCoord2svARBWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2SVARBPROC, "glMultiTexCoord2svARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2SVARBPROC)( target_, v_ );
}

void glMultiTexCoord3dARBWrapper(GLenum target_, GLdouble s_, GLdouble t_, GLdouble r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3DARBPROC, "glMultiTexCoord3dARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3DARBPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3dvARBWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3DVARBPROC, "glMultiTexCoord3dvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3DVARBPROC)( target_, v_ );
}

void glMultiTexCoord3fARBWrapper(GLenum target_, GLfloat s_, GLfloat t_, GLfloat r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3FARBPROC, "glMultiTexCoord3fARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3FARBPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3fvARBWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3FVARBPROC, "glMultiTexCoord3fvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3FVARBPROC)( target_, v_ );
}

void glMultiTexCoord3iARBWrapper(GLenum target_, GLint s_, GLint t_, GLint r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3IARBPROC, "glMultiTexCoord3iARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3IARBPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3ivARBWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3IVARBPROC, "glMultiTexCoord3ivARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3IVARBPROC)( target_, v_ );
}

void glMultiTexCoord3sARBWrapper(GLenum target_, GLshort s_, GLshort t_, GLshort r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3SARBPROC, "glMultiTexCoord3sARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3SARBPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3svARBWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3SVARBPROC, "glMultiTexCoord3svARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3SVARBPROC)( target_, v_ );
}

void glMultiTexCoord4dARBWrapper(GLenum target_, GLdouble s_, GLdouble t_, GLdouble r_, GLdouble q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4DARBPROC, "glMultiTexCoord4dARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4DARBPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4dvARBWrapper(GLenum target_, const GLdouble* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4DVARBPROC, "glMultiTexCoord4dvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4DVARBPROC)( target_, v_ );
}

void glMultiTexCoord4fARBWrapper(GLenum target_, GLfloat s_, GLfloat t_, GLfloat r_, GLfloat q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4FARBPROC, "glMultiTexCoord4fARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4FARBPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4fvARBWrapper(GLenum target_, const GLfloat* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4FVARBPROC, "glMultiTexCoord4fvARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4FVARBPROC)( target_, v_ );
}

void glMultiTexCoord4iARBWrapper(GLenum target_, GLint s_, GLint t_, GLint r_, GLint q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4IARBPROC, "glMultiTexCoord4iARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4IARBPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4ivARBWrapper(GLenum target_, const GLint* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4IVARBPROC, "glMultiTexCoord4ivARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4IVARBPROC)( target_, v_ );
}

void glMultiTexCoord4sARBWrapper(GLenum target_, GLshort s_, GLshort t_, GLshort r_, GLshort q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4SARBPROC, "glMultiTexCoord4sARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4SARBPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4svARBWrapper(GLenum target_, const GLshort* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4SVARBPROC, "glMultiTexCoord4svARB");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4SVARBPROC)( target_, v_ );
}

void glGenQueriesARBWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLGENQUERIESARBPROC, "glGenQueriesARB");
  RESOLVED_PROC(PFNGLGENQUERIESARBPROC)( n_, ids_ );
}

void glDeleteQueriesARBWrapper(GLsizei n_, const GLuint* ids_)
{
  RESOLVE(PFNGLDELETEQUERIESARBPROC, "glDeleteQueriesARB");
  RESOLVED_PROC(PFNGLDELETEQUERIESARBPROC)( n_, ids_ );
}

GLboolean glIsQueryARBWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISQUERYARBPROC, "glIsQueryARB", FALSE);
  return RESOLVED_PROC(PFNGLISQUERYARBPROC)(id_ );
}

void glBeginQueryARBWrapper(GLenum target_, GLuint id_)
{
  RESOLVE(PFNGLBEGINQUERYARBPROC, "glBeginQueryARB");
  RESOLVED_PROC(PFNGLBEGINQUERYARBPROC)( target_, id_ );
}

void glEndQueryARBWrapper(GLenum target_)
{
  RESOLVE(PFNGLENDQUERYARBPROC, "glEndQueryARB");
  RESOLVED_PROC(PFNGLENDQUERYARBPROC)( target_ );
}

void glGetQueryivARBWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETQUERYIVARBPROC, "glGetQueryivARB");
  RESOLVED_PROC(PFNGLGETQUERYIVARBPROC)( target_, pname_, params_ );
}

void glGetQueryObjectivARBWrapper(GLuint id_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTIVARBPROC, "glGetQueryObjectivARB");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTIVARBPROC)( id_, pname_, params_ );
}

void glGetQueryObjectuivARBWrapper(GLuint id_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTUIVARBPROC, "glGetQueryObjectuivARB");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTUIVARBPROC)( id_, pname_, params_ );
}

void glMaxShaderCompilerThreadsARBWrapper(GLuint count_)
{
  RESOLVE(PFNGLMAXSHADERCOMPILERTHREADSARBPROC, "glMaxShaderCompilerThreadsARB");
  RESOLVED_PROC(PFNGLMAXSHADERCOMPILERTHREADSARBPROC)( count_ );
}

void glPointParameterfARBWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPOINTPARAMETERFARBPROC, "glPointParameterfARB");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFARBPROC)( pname_, param_ );
}

void glPointParameterfvARBWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERFVARBPROC, "glPointParameterfvARB");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFVARBPROC)( pname_, params_ );
}

GLenum glGetGraphicsResetStatusARBWrapper(void)
{
  RESOLVE_RET(PFNGLGETGRAPHICSRESETSTATUSARBPROC, "glGetGraphicsResetStatusARB", FALSE);
  return RESOLVED_PROC(PFNGLGETGRAPHICSRESETSTATUSARBPROC)( );
}

void glGetnTexImageARBWrapper(GLenum target_, GLint level_, GLenum format_, GLenum type_, GLsizei bufSize_, void * img_)
{
  RESOLVE(PFNGLGETNTEXIMAGEARBPROC, "glGetnTexImageARB");
  RESOLVED_PROC(PFNGLGETNTEXIMAGEARBPROC)( target_, level_, format_, type_, bufSize_, img_ );
}

void glReadnPixelsARBWrapper(GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, GLsizei bufSize_, void * data_)
{
  RESOLVE(PFNGLREADNPIXELSARBPROC, "glReadnPixelsARB");
  RESOLVED_PROC(PFNGLREADNPIXELSARBPROC)( x_, y_, width_, height_, format_, type_, bufSize_, data_ );
}

void glGetnCompressedTexImageARBWrapper(GLenum target_, GLint lod_, GLsizei bufSize_, void * img_)
{
  RESOLVE(PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC, "glGetnCompressedTexImageARB");
  RESOLVED_PROC(PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)( target_, lod_, bufSize_, img_ );
}

void glGetnUniformfvARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLfloat* params_)
{
  RESOLVE(PFNGLGETNUNIFORMFVARBPROC, "glGetnUniformfvARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMFVARBPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformivARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLint* params_)
{
  RESOLVE(PFNGLGETNUNIFORMIVARBPROC, "glGetnUniformivARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMIVARBPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformuivARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLuint* params_)
{
  RESOLVE(PFNGLGETNUNIFORMUIVARBPROC, "glGetnUniformuivARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMUIVARBPROC)( program_, location_, bufSize_, params_ );
}

void glGetnUniformdvARBWrapper(GLuint program_, GLint location_, GLsizei bufSize_, GLdouble* params_)
{
  RESOLVE(PFNGLGETNUNIFORMDVARBPROC, "glGetnUniformdvARB");
  RESOLVED_PROC(PFNGLGETNUNIFORMDVARBPROC)( program_, location_, bufSize_, params_ );
}

void glGetnMapdvARBWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLdouble* v_)
{
  RESOLVE(PFNGLGETNMAPDVARBPROC, "glGetnMapdvARB");
  RESOLVED_PROC(PFNGLGETNMAPDVARBPROC)( target_, query_, bufSize_, v_ );
}

void glGetnMapfvARBWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLfloat* v_)
{
  RESOLVE(PFNGLGETNMAPFVARBPROC, "glGetnMapfvARB");
  RESOLVED_PROC(PFNGLGETNMAPFVARBPROC)( target_, query_, bufSize_, v_ );
}

void glGetnMapivARBWrapper(GLenum target_, GLenum query_, GLsizei bufSize_, GLint* v_)
{
  RESOLVE(PFNGLGETNMAPIVARBPROC, "glGetnMapivARB");
  RESOLVED_PROC(PFNGLGETNMAPIVARBPROC)( target_, query_, bufSize_, v_ );
}

void glGetnPixelMapfvARBWrapper(GLenum map_, GLsizei bufSize_, GLfloat* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPFVARBPROC, "glGetnPixelMapfvARB");
  RESOLVED_PROC(PFNGLGETNPIXELMAPFVARBPROC)( map_, bufSize_, values_ );
}

void glGetnPixelMapuivARBWrapper(GLenum map_, GLsizei bufSize_, GLuint* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPUIVARBPROC, "glGetnPixelMapuivARB");
  RESOLVED_PROC(PFNGLGETNPIXELMAPUIVARBPROC)( map_, bufSize_, values_ );
}

void glGetnPixelMapusvARBWrapper(GLenum map_, GLsizei bufSize_, GLushort* values_)
{
  RESOLVE(PFNGLGETNPIXELMAPUSVARBPROC, "glGetnPixelMapusvARB");
  RESOLVED_PROC(PFNGLGETNPIXELMAPUSVARBPROC)( map_, bufSize_, values_ );
}

void glGetnPolygonStippleARBWrapper(GLsizei bufSize_, GLubyte* pattern_)
{
  RESOLVE(PFNGLGETNPOLYGONSTIPPLEARBPROC, "glGetnPolygonStippleARB");
  RESOLVED_PROC(PFNGLGETNPOLYGONSTIPPLEARBPROC)( bufSize_, pattern_ );
}

void glGetnColorTableARBWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei bufSize_, void * table_)
{
  RESOLVE(PFNGLGETNCOLORTABLEARBPROC, "glGetnColorTableARB");
  RESOLVED_PROC(PFNGLGETNCOLORTABLEARBPROC)( target_, format_, type_, bufSize_, table_ );
}

void glGetnConvolutionFilterARBWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei bufSize_, void * image_)
{
  RESOLVE(PFNGLGETNCONVOLUTIONFILTERARBPROC, "glGetnConvolutionFilterARB");
  RESOLVED_PROC(PFNGLGETNCONVOLUTIONFILTERARBPROC)( target_, format_, type_, bufSize_, image_ );
}

void glGetnSeparableFilterARBWrapper(GLenum target_, GLenum format_, GLenum type_, GLsizei rowBufSize_, void * row_, GLsizei columnBufSize_, void * column_, void * span_)
{
  RESOLVE(PFNGLGETNSEPARABLEFILTERARBPROC, "glGetnSeparableFilterARB");
  RESOLVED_PROC(PFNGLGETNSEPARABLEFILTERARBPROC)( target_, format_, type_, rowBufSize_, row_, columnBufSize_, column_, span_ );
}

void glGetnHistogramARBWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, GLsizei bufSize_, void * values_)
{
  RESOLVE(PFNGLGETNHISTOGRAMARBPROC, "glGetnHistogramARB");
  RESOLVED_PROC(PFNGLGETNHISTOGRAMARBPROC)( target_, reset_, format_, type_, bufSize_, values_ );
}

void glGetnMinmaxARBWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, GLsizei bufSize_, void * values_)
{
  RESOLVE(PFNGLGETNMINMAXARBPROC, "glGetnMinmaxARB");
  RESOLVED_PROC(PFNGLGETNMINMAXARBPROC)( target_, reset_, format_, type_, bufSize_, values_ );
}

void glFramebufferSampleLocationsfvARBWrapper(GLenum target_, GLuint start_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC, "glFramebufferSampleLocationsfvARB");
  RESOLVED_PROC(PFNGLFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)( target_, start_, count_, v_ );
}

void glNamedFramebufferSampleLocationsfvARBWrapper(GLuint framebuffer_, GLuint start_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC, "glNamedFramebufferSampleLocationsfvARB");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARBPROC)( framebuffer_, start_, count_, v_ );
}

void glEvaluateDepthValuesARBWrapper(void)
{
  RESOLVE(PFNGLEVALUATEDEPTHVALUESARBPROC, "glEvaluateDepthValuesARB");
  RESOLVED_PROC(PFNGLEVALUATEDEPTHVALUESARBPROC)(  );
}

void glMinSampleShadingARBWrapper(GLfloat value_)
{
  RESOLVE(PFNGLMINSAMPLESHADINGARBPROC, "glMinSampleShadingARB");
  RESOLVED_PROC(PFNGLMINSAMPLESHADINGARBPROC)( value_ );
}

void glDeleteObjectARBWrapper(GLhandleARB obj_)
{
  RESOLVE(PFNGLDELETEOBJECTARBPROC, "glDeleteObjectARB");
  RESOLVED_PROC(PFNGLDELETEOBJECTARBPROC)( obj_ );
}

GLhandleARB glGetHandleARBWrapper(GLenum pname_)
{
  RESOLVE_RET(PFNGLGETHANDLEARBPROC, "glGetHandleARB", FALSE);
  return RESOLVED_PROC(PFNGLGETHANDLEARBPROC)(pname_ );
}

void glDetachObjectARBWrapper(GLhandleARB containerObj_, GLhandleARB attachedObj_)
{
  RESOLVE(PFNGLDETACHOBJECTARBPROC, "glDetachObjectARB");
  RESOLVED_PROC(PFNGLDETACHOBJECTARBPROC)( containerObj_, attachedObj_ );
}

GLhandleARB glCreateShaderObjectARBWrapper(GLenum shaderType_)
{
  RESOLVE_RET(PFNGLCREATESHADEROBJECTARBPROC, "glCreateShaderObjectARB", FALSE);
  return RESOLVED_PROC(PFNGLCREATESHADEROBJECTARBPROC)(shaderType_ );
}

void glShaderSourceARBWrapper(GLhandleARB shaderObj_, GLsizei count_, const GLcharARB** string_, const GLint* length_)
{
  RESOLVE(PFNGLSHADERSOURCEARBPROC, "glShaderSourceARB");
  RESOLVED_PROC(PFNGLSHADERSOURCEARBPROC)( shaderObj_, count_, string_, length_ );
}

void glCompileShaderARBWrapper(GLhandleARB shaderObj_)
{
  RESOLVE(PFNGLCOMPILESHADERARBPROC, "glCompileShaderARB");
  RESOLVED_PROC(PFNGLCOMPILESHADERARBPROC)( shaderObj_ );
}

GLhandleARB glCreateProgramObjectARBWrapper(void)
{
  RESOLVE_RET(PFNGLCREATEPROGRAMOBJECTARBPROC, "glCreateProgramObjectARB", FALSE);
  return RESOLVED_PROC(PFNGLCREATEPROGRAMOBJECTARBPROC)( );
}

void glAttachObjectARBWrapper(GLhandleARB containerObj_, GLhandleARB obj_)
{
  RESOLVE(PFNGLATTACHOBJECTARBPROC, "glAttachObjectARB");
  RESOLVED_PROC(PFNGLATTACHOBJECTARBPROC)( containerObj_, obj_ );
}

void glLinkProgramARBWrapper(GLhandleARB programObj_)
{
  RESOLVE(PFNGLLINKPROGRAMARBPROC, "glLinkProgramARB");
  RESOLVED_PROC(PFNGLLINKPROGRAMARBPROC)( programObj_ );
}

void glUseProgramObjectARBWrapper(GLhandleARB programObj_)
{
  RESOLVE(PFNGLUSEPROGRAMOBJECTARBPROC, "glUseProgramObjectARB");
  RESOLVED_PROC(PFNGLUSEPROGRAMOBJECTARBPROC)( programObj_ );
}

void glValidateProgramARBWrapper(GLhandleARB programObj_)
{
  RESOLVE(PFNGLVALIDATEPROGRAMARBPROC, "glValidateProgramARB");
  RESOLVED_PROC(PFNGLVALIDATEPROGRAMARBPROC)( programObj_ );
}

void glUniform1fARBWrapper(GLint location_, GLfloat v0_)
{
  RESOLVE(PFNGLUNIFORM1FARBPROC, "glUniform1fARB");
  RESOLVED_PROC(PFNGLUNIFORM1FARBPROC)( location_, v0_ );
}

void glUniform2fARBWrapper(GLint location_, GLfloat v0_, GLfloat v1_)
{
  RESOLVE(PFNGLUNIFORM2FARBPROC, "glUniform2fARB");
  RESOLVED_PROC(PFNGLUNIFORM2FARBPROC)( location_, v0_, v1_ );
}

void glUniform3fARBWrapper(GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_)
{
  RESOLVE(PFNGLUNIFORM3FARBPROC, "glUniform3fARB");
  RESOLVED_PROC(PFNGLUNIFORM3FARBPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4fARBWrapper(GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_, GLfloat v3_)
{
  RESOLVE(PFNGLUNIFORM4FARBPROC, "glUniform4fARB");
  RESOLVED_PROC(PFNGLUNIFORM4FARBPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1iARBWrapper(GLint location_, GLint v0_)
{
  RESOLVE(PFNGLUNIFORM1IARBPROC, "glUniform1iARB");
  RESOLVED_PROC(PFNGLUNIFORM1IARBPROC)( location_, v0_ );
}

void glUniform2iARBWrapper(GLint location_, GLint v0_, GLint v1_)
{
  RESOLVE(PFNGLUNIFORM2IARBPROC, "glUniform2iARB");
  RESOLVED_PROC(PFNGLUNIFORM2IARBPROC)( location_, v0_, v1_ );
}

void glUniform3iARBWrapper(GLint location_, GLint v0_, GLint v1_, GLint v2_)
{
  RESOLVE(PFNGLUNIFORM3IARBPROC, "glUniform3iARB");
  RESOLVED_PROC(PFNGLUNIFORM3IARBPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4iARBWrapper(GLint location_, GLint v0_, GLint v1_, GLint v2_, GLint v3_)
{
  RESOLVE(PFNGLUNIFORM4IARBPROC, "glUniform4iARB");
  RESOLVED_PROC(PFNGLUNIFORM4IARBPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1fvARBWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM1FVARBPROC, "glUniform1fvARB");
  RESOLVED_PROC(PFNGLUNIFORM1FVARBPROC)( location_, count_, value_ );
}

void glUniform2fvARBWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM2FVARBPROC, "glUniform2fvARB");
  RESOLVED_PROC(PFNGLUNIFORM2FVARBPROC)( location_, count_, value_ );
}

void glUniform3fvARBWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM3FVARBPROC, "glUniform3fvARB");
  RESOLVED_PROC(PFNGLUNIFORM3FVARBPROC)( location_, count_, value_ );
}

void glUniform4fvARBWrapper(GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORM4FVARBPROC, "glUniform4fvARB");
  RESOLVED_PROC(PFNGLUNIFORM4FVARBPROC)( location_, count_, value_ );
}

void glUniform1ivARBWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM1IVARBPROC, "glUniform1ivARB");
  RESOLVED_PROC(PFNGLUNIFORM1IVARBPROC)( location_, count_, value_ );
}

void glUniform2ivARBWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM2IVARBPROC, "glUniform2ivARB");
  RESOLVED_PROC(PFNGLUNIFORM2IVARBPROC)( location_, count_, value_ );
}

void glUniform3ivARBWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM3IVARBPROC, "glUniform3ivARB");
  RESOLVED_PROC(PFNGLUNIFORM3IVARBPROC)( location_, count_, value_ );
}

void glUniform4ivARBWrapper(GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLUNIFORM4IVARBPROC, "glUniform4ivARB");
  RESOLVED_PROC(PFNGLUNIFORM4IVARBPROC)( location_, count_, value_ );
}

void glUniformMatrix2fvARBWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX2FVARBPROC, "glUniformMatrix2fvARB");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX2FVARBPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix3fvARBWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX3FVARBPROC, "glUniformMatrix3fvARB");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX3FVARBPROC)( location_, count_, transpose_, value_ );
}

void glUniformMatrix4fvARBWrapper(GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLUNIFORMMATRIX4FVARBPROC, "glUniformMatrix4fvARB");
  RESOLVED_PROC(PFNGLUNIFORMMATRIX4FVARBPROC)( location_, count_, transpose_, value_ );
}

void glGetObjectParameterfvARBWrapper(GLhandleARB obj_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETOBJECTPARAMETERFVARBPROC, "glGetObjectParameterfvARB");
  RESOLVED_PROC(PFNGLGETOBJECTPARAMETERFVARBPROC)( obj_, pname_, params_ );
}

void glGetObjectParameterivARBWrapper(GLhandleARB obj_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETOBJECTPARAMETERIVARBPROC, "glGetObjectParameterivARB");
  RESOLVED_PROC(PFNGLGETOBJECTPARAMETERIVARBPROC)( obj_, pname_, params_ );
}

void glGetInfoLogARBWrapper(GLhandleARB obj_, GLsizei maxLength_, GLsizei* length_, GLcharARB* infoLog_)
{
  RESOLVE(PFNGLGETINFOLOGARBPROC, "glGetInfoLogARB");
  RESOLVED_PROC(PFNGLGETINFOLOGARBPROC)( obj_, maxLength_, length_, infoLog_ );
}

void glGetAttachedObjectsARBWrapper(GLhandleARB containerObj_, GLsizei maxCount_, GLsizei* count_, GLhandleARB* obj_)
{
  RESOLVE(PFNGLGETATTACHEDOBJECTSARBPROC, "glGetAttachedObjectsARB");
  RESOLVED_PROC(PFNGLGETATTACHEDOBJECTSARBPROC)( containerObj_, maxCount_, count_, obj_ );
}

GLint glGetUniformLocationARBWrapper(GLhandleARB programObj_, const GLcharARB* name_)
{
  RESOLVE_RET(PFNGLGETUNIFORMLOCATIONARBPROC, "glGetUniformLocationARB", FALSE);
  return RESOLVED_PROC(PFNGLGETUNIFORMLOCATIONARBPROC)(programObj_, name_ );
}

void glGetActiveUniformARBWrapper(GLhandleARB programObj_, GLuint index_, GLsizei maxLength_, GLsizei* length_, GLint* size_, GLenum* type_, GLcharARB* name_)
{
  RESOLVE(PFNGLGETACTIVEUNIFORMARBPROC, "glGetActiveUniformARB");
  RESOLVED_PROC(PFNGLGETACTIVEUNIFORMARBPROC)( programObj_, index_, maxLength_, length_, size_, type_, name_ );
}

void glGetUniformfvARBWrapper(GLhandleARB programObj_, GLint location_, GLfloat* params_)
{
  RESOLVE(PFNGLGETUNIFORMFVARBPROC, "glGetUniformfvARB");
  RESOLVED_PROC(PFNGLGETUNIFORMFVARBPROC)( programObj_, location_, params_ );
}

void glGetUniformivARBWrapper(GLhandleARB programObj_, GLint location_, GLint* params_)
{
  RESOLVE(PFNGLGETUNIFORMIVARBPROC, "glGetUniformivARB");
  RESOLVED_PROC(PFNGLGETUNIFORMIVARBPROC)( programObj_, location_, params_ );
}

void glGetShaderSourceARBWrapper(GLhandleARB obj_, GLsizei maxLength_, GLsizei* length_, GLcharARB* source_)
{
  RESOLVE(PFNGLGETSHADERSOURCEARBPROC, "glGetShaderSourceARB");
  RESOLVED_PROC(PFNGLGETSHADERSOURCEARBPROC)( obj_, maxLength_, length_, source_ );
}

void glNamedStringARBWrapper(GLenum type_, GLint namelen_, const GLchar* name_, GLint stringlen_, const GLchar* string_)
{
  RESOLVE(PFNGLNAMEDSTRINGARBPROC, "glNamedStringARB");
  RESOLVED_PROC(PFNGLNAMEDSTRINGARBPROC)( type_, namelen_, name_, stringlen_, string_ );
}

void glDeleteNamedStringARBWrapper(GLint namelen_, const GLchar* name_)
{
  RESOLVE(PFNGLDELETENAMEDSTRINGARBPROC, "glDeleteNamedStringARB");
  RESOLVED_PROC(PFNGLDELETENAMEDSTRINGARBPROC)( namelen_, name_ );
}

void glCompileShaderIncludeARBWrapper(GLuint shader_, GLsizei count_, const GLchar*const* path_, const GLint* length_)
{
  RESOLVE(PFNGLCOMPILESHADERINCLUDEARBPROC, "glCompileShaderIncludeARB");
  RESOLVED_PROC(PFNGLCOMPILESHADERINCLUDEARBPROC)( shader_, count_, path_, length_ );
}

GLboolean glIsNamedStringARBWrapper(GLint namelen_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLISNAMEDSTRINGARBPROC, "glIsNamedStringARB", FALSE);
  return RESOLVED_PROC(PFNGLISNAMEDSTRINGARBPROC)(namelen_, name_ );
}

void glGetNamedStringARBWrapper(GLint namelen_, const GLchar* name_, GLsizei bufSize_, GLint* stringlen_, GLchar* string_)
{
  RESOLVE(PFNGLGETNAMEDSTRINGARBPROC, "glGetNamedStringARB");
  RESOLVED_PROC(PFNGLGETNAMEDSTRINGARBPROC)( namelen_, name_, bufSize_, stringlen_, string_ );
}

void glGetNamedStringivARBWrapper(GLint namelen_, const GLchar* name_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDSTRINGIVARBPROC, "glGetNamedStringivARB");
  RESOLVED_PROC(PFNGLGETNAMEDSTRINGIVARBPROC)( namelen_, name_, pname_, params_ );
}

void glBufferPageCommitmentARBWrapper(GLenum target_, GLintptr offset_, GLsizeiptr size_, GLboolean commit_)
{
  RESOLVE(PFNGLBUFFERPAGECOMMITMENTARBPROC, "glBufferPageCommitmentARB");
  RESOLVED_PROC(PFNGLBUFFERPAGECOMMITMENTARBPROC)( target_, offset_, size_, commit_ );
}

void glNamedBufferPageCommitmentEXTWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, GLboolean commit_)
{
  RESOLVE(PFNGLNAMEDBUFFERPAGECOMMITMENTEXTPROC, "glNamedBufferPageCommitmentEXT");
  RESOLVED_PROC(PFNGLNAMEDBUFFERPAGECOMMITMENTEXTPROC)( buffer_, offset_, size_, commit_ );
}

void glNamedBufferPageCommitmentARBWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, GLboolean commit_)
{
  RESOLVE(PFNGLNAMEDBUFFERPAGECOMMITMENTARBPROC, "glNamedBufferPageCommitmentARB");
  RESOLVED_PROC(PFNGLNAMEDBUFFERPAGECOMMITMENTARBPROC)( buffer_, offset_, size_, commit_ );
}

void glTexPageCommitmentARBWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean commit_)
{
  RESOLVE(PFNGLTEXPAGECOMMITMENTARBPROC, "glTexPageCommitmentARB");
  RESOLVED_PROC(PFNGLTEXPAGECOMMITMENTARBPROC)( target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, commit_ );
}

void glTexBufferARBWrapper(GLenum target_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLTEXBUFFERARBPROC, "glTexBufferARB");
  RESOLVED_PROC(PFNGLTEXBUFFERARBPROC)( target_, internalformat_, buffer_ );
}

void glCompressedTexImage3DARBWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE3DARBPROC, "glCompressedTexImage3DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)( target_, level_, internalformat_, width_, height_, depth_, border_, imageSize_, data_ );
}

void glCompressedTexImage2DARBWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE2DARBPROC, "glCompressedTexImage2DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)( target_, level_, internalformat_, width_, height_, border_, imageSize_, data_ );
}

void glCompressedTexImage1DARBWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLint border_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXIMAGE1DARBPROC, "glCompressedTexImage1DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)( target_, level_, internalformat_, width_, border_, imageSize_, data_ );
}

void glCompressedTexSubImage3DARBWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC, "glCompressedTexSubImage3DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)( target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, imageSize_, data_ );
}

void glCompressedTexSubImage2DARBWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC, "glCompressedTexSubImage2DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)( target_, level_, xoffset_, yoffset_, width_, height_, format_, imageSize_, data_ );
}

void glCompressedTexSubImage1DARBWrapper(GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLsizei imageSize_, const void * data_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC, "glCompressedTexSubImage1DARB");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)( target_, level_, xoffset_, width_, format_, imageSize_, data_ );
}

void glGetCompressedTexImageARBWrapper(GLenum target_, GLint level_, void * img_)
{
  RESOLVE(PFNGLGETCOMPRESSEDTEXIMAGEARBPROC, "glGetCompressedTexImageARB");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)( target_, level_, img_ );
}

void glLoadTransposeMatrixfARBWrapper(const GLfloat* m_)
{
  RESOLVE(PFNGLLOADTRANSPOSEMATRIXFARBPROC, "glLoadTransposeMatrixfARB");
  RESOLVED_PROC(PFNGLLOADTRANSPOSEMATRIXFARBPROC)( m_ );
}

void glLoadTransposeMatrixdARBWrapper(const GLdouble* m_)
{
  RESOLVE(PFNGLLOADTRANSPOSEMATRIXDARBPROC, "glLoadTransposeMatrixdARB");
  RESOLVED_PROC(PFNGLLOADTRANSPOSEMATRIXDARBPROC)( m_ );
}

void glMultTransposeMatrixfARBWrapper(const GLfloat* m_)
{
  RESOLVE(PFNGLMULTTRANSPOSEMATRIXFARBPROC, "glMultTransposeMatrixfARB");
  RESOLVED_PROC(PFNGLMULTTRANSPOSEMATRIXFARBPROC)( m_ );
}

void glMultTransposeMatrixdARBWrapper(const GLdouble* m_)
{
  RESOLVE(PFNGLMULTTRANSPOSEMATRIXDARBPROC, "glMultTransposeMatrixdARB");
  RESOLVED_PROC(PFNGLMULTTRANSPOSEMATRIXDARBPROC)( m_ );
}

void glWeightbvARBWrapper(GLint size_, const GLbyte* weights_)
{
  RESOLVE(PFNGLWEIGHTBVARBPROC, "glWeightbvARB");
  RESOLVED_PROC(PFNGLWEIGHTBVARBPROC)( size_, weights_ );
}

void glWeightsvARBWrapper(GLint size_, const GLshort* weights_)
{
  RESOLVE(PFNGLWEIGHTSVARBPROC, "glWeightsvARB");
  RESOLVED_PROC(PFNGLWEIGHTSVARBPROC)( size_, weights_ );
}

void glWeightivARBWrapper(GLint size_, const GLint* weights_)
{
  RESOLVE(PFNGLWEIGHTIVARBPROC, "glWeightivARB");
  RESOLVED_PROC(PFNGLWEIGHTIVARBPROC)( size_, weights_ );
}

void glWeightfvARBWrapper(GLint size_, const GLfloat* weights_)
{
  RESOLVE(PFNGLWEIGHTFVARBPROC, "glWeightfvARB");
  RESOLVED_PROC(PFNGLWEIGHTFVARBPROC)( size_, weights_ );
}

void glWeightdvARBWrapper(GLint size_, const GLdouble* weights_)
{
  RESOLVE(PFNGLWEIGHTDVARBPROC, "glWeightdvARB");
  RESOLVED_PROC(PFNGLWEIGHTDVARBPROC)( size_, weights_ );
}

void glWeightubvARBWrapper(GLint size_, const GLubyte* weights_)
{
  RESOLVE(PFNGLWEIGHTUBVARBPROC, "glWeightubvARB");
  RESOLVED_PROC(PFNGLWEIGHTUBVARBPROC)( size_, weights_ );
}

void glWeightusvARBWrapper(GLint size_, const GLushort* weights_)
{
  RESOLVE(PFNGLWEIGHTUSVARBPROC, "glWeightusvARB");
  RESOLVED_PROC(PFNGLWEIGHTUSVARBPROC)( size_, weights_ );
}

void glWeightuivARBWrapper(GLint size_, const GLuint* weights_)
{
  RESOLVE(PFNGLWEIGHTUIVARBPROC, "glWeightuivARB");
  RESOLVED_PROC(PFNGLWEIGHTUIVARBPROC)( size_, weights_ );
}

void glWeightPointerARBWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLWEIGHTPOINTERARBPROC, "glWeightPointerARB");
  RESOLVED_PROC(PFNGLWEIGHTPOINTERARBPROC)( size_, type_, stride_, pointer_ );
}

void glVertexBlendARBWrapper(GLint count_)
{
  RESOLVE(PFNGLVERTEXBLENDARBPROC, "glVertexBlendARB");
  RESOLVED_PROC(PFNGLVERTEXBLENDARBPROC)( count_ );
}

void glBindBufferARBWrapper(GLenum target_, GLuint buffer_)
{
  RESOLVE(PFNGLBINDBUFFERARBPROC, "glBindBufferARB");
  RESOLVED_PROC(PFNGLBINDBUFFERARBPROC)( target_, buffer_ );
}

void glDeleteBuffersARBWrapper(GLsizei n_, const GLuint* buffers_)
{
  RESOLVE(PFNGLDELETEBUFFERSARBPROC, "glDeleteBuffersARB");
  RESOLVED_PROC(PFNGLDELETEBUFFERSARBPROC)( n_, buffers_ );
}

void glGenBuffersARBWrapper(GLsizei n_, GLuint* buffers_)
{
  RESOLVE(PFNGLGENBUFFERSARBPROC, "glGenBuffersARB");
  RESOLVED_PROC(PFNGLGENBUFFERSARBPROC)( n_, buffers_ );
}

GLboolean glIsBufferARBWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLISBUFFERARBPROC, "glIsBufferARB", FALSE);
  return RESOLVED_PROC(PFNGLISBUFFERARBPROC)(buffer_ );
}

void glBufferDataARBWrapper(GLenum target_, GLsizeiptrARB size_, const void * data_, GLenum usage_)
{
  RESOLVE(PFNGLBUFFERDATAARBPROC, "glBufferDataARB");
  RESOLVED_PROC(PFNGLBUFFERDATAARBPROC)( target_, size_, data_, usage_ );
}

void glBufferSubDataARBWrapper(GLenum target_, GLintptrARB offset_, GLsizeiptrARB size_, const void * data_)
{
  RESOLVE(PFNGLBUFFERSUBDATAARBPROC, "glBufferSubDataARB");
  RESOLVED_PROC(PFNGLBUFFERSUBDATAARBPROC)( target_, offset_, size_, data_ );
}

void glGetBufferSubDataARBWrapper(GLenum target_, GLintptrARB offset_, GLsizeiptrARB size_, void * data_)
{
  RESOLVE(PFNGLGETBUFFERSUBDATAARBPROC, "glGetBufferSubDataARB");
  RESOLVED_PROC(PFNGLGETBUFFERSUBDATAARBPROC)( target_, offset_, size_, data_ );
}

void * glMapBufferARBWrapper(GLenum target_, GLenum access_)
{
  RESOLVE_RET(PFNGLMAPBUFFERARBPROC, "glMapBufferARB", FALSE);
  return RESOLVED_PROC(PFNGLMAPBUFFERARBPROC)(target_, access_ );
}

GLboolean glUnmapBufferARBWrapper(GLenum target_)
{
  RESOLVE_RET(PFNGLUNMAPBUFFERARBPROC, "glUnmapBufferARB", FALSE);
  return RESOLVED_PROC(PFNGLUNMAPBUFFERARBPROC)(target_ );
}

void glGetBufferParameterivARBWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETBUFFERPARAMETERIVARBPROC, "glGetBufferParameterivARB");
  RESOLVED_PROC(PFNGLGETBUFFERPARAMETERIVARBPROC)( target_, pname_, params_ );
}

void glGetBufferPointervARBWrapper(GLenum target_, GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETBUFFERPOINTERVARBPROC, "glGetBufferPointervARB");
  RESOLVED_PROC(PFNGLGETBUFFERPOINTERVARBPROC)( target_, pname_, params_ );
}

void glVertexAttrib1dARBWrapper(GLuint index_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DARBPROC, "glVertexAttrib1dARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DARBPROC)( index_, x_ );
}

void glVertexAttrib1dvARBWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DVARBPROC, "glVertexAttrib1dvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DVARBPROC)( index_, v_ );
}

void glVertexAttrib1fARBWrapper(GLuint index_, GLfloat x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FARBPROC, "glVertexAttrib1fARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FARBPROC)( index_, x_ );
}

void glVertexAttrib1fvARBWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FVARBPROC, "glVertexAttrib1fvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FVARBPROC)( index_, v_ );
}

void glVertexAttrib1sARBWrapper(GLuint index_, GLshort x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SARBPROC, "glVertexAttrib1sARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SARBPROC)( index_, x_ );
}

void glVertexAttrib1svARBWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SVARBPROC, "glVertexAttrib1svARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SVARBPROC)( index_, v_ );
}

void glVertexAttrib2dARBWrapper(GLuint index_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DARBPROC, "glVertexAttrib2dARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DARBPROC)( index_, x_, y_ );
}

void glVertexAttrib2dvARBWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DVARBPROC, "glVertexAttrib2dvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DVARBPROC)( index_, v_ );
}

void glVertexAttrib2fARBWrapper(GLuint index_, GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FARBPROC, "glVertexAttrib2fARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FARBPROC)( index_, x_, y_ );
}

void glVertexAttrib2fvARBWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FVARBPROC, "glVertexAttrib2fvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FVARBPROC)( index_, v_ );
}

void glVertexAttrib2sARBWrapper(GLuint index_, GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SARBPROC, "glVertexAttrib2sARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SARBPROC)( index_, x_, y_ );
}

void glVertexAttrib2svARBWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SVARBPROC, "glVertexAttrib2svARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SVARBPROC)( index_, v_ );
}

void glVertexAttrib3dARBWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DARBPROC, "glVertexAttrib3dARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DARBPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3dvARBWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DVARBPROC, "glVertexAttrib3dvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DVARBPROC)( index_, v_ );
}

void glVertexAttrib3fARBWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FARBPROC, "glVertexAttrib3fARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FARBPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3fvARBWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FVARBPROC, "glVertexAttrib3fvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FVARBPROC)( index_, v_ );
}

void glVertexAttrib3sARBWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SARBPROC, "glVertexAttrib3sARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SARBPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3svARBWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SVARBPROC, "glVertexAttrib3svARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SVARBPROC)( index_, v_ );
}

void glVertexAttrib4NbvARBWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NBVARBPROC, "glVertexAttrib4NbvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NBVARBPROC)( index_, v_ );
}

void glVertexAttrib4NivARBWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NIVARBPROC, "glVertexAttrib4NivARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NIVARBPROC)( index_, v_ );
}

void glVertexAttrib4NsvARBWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NSVARBPROC, "glVertexAttrib4NsvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NSVARBPROC)( index_, v_ );
}

void glVertexAttrib4NubARBWrapper(GLuint index_, GLubyte x_, GLubyte y_, GLubyte z_, GLubyte w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUBARBPROC, "glVertexAttrib4NubARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUBARBPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4NubvARBWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUBVARBPROC, "glVertexAttrib4NubvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUBVARBPROC)( index_, v_ );
}

void glVertexAttrib4NuivARBWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUIVARBPROC, "glVertexAttrib4NuivARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUIVARBPROC)( index_, v_ );
}

void glVertexAttrib4NusvARBWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4NUSVARBPROC, "glVertexAttrib4NusvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4NUSVARBPROC)( index_, v_ );
}

void glVertexAttrib4bvARBWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4BVARBPROC, "glVertexAttrib4bvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4BVARBPROC)( index_, v_ );
}

void glVertexAttrib4dARBWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DARBPROC, "glVertexAttrib4dARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DARBPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4dvARBWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DVARBPROC, "glVertexAttrib4dvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DVARBPROC)( index_, v_ );
}

void glVertexAttrib4fARBWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FARBPROC, "glVertexAttrib4fARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FARBPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4fvARBWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FVARBPROC, "glVertexAttrib4fvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FVARBPROC)( index_, v_ );
}

void glVertexAttrib4ivARBWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4IVARBPROC, "glVertexAttrib4ivARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4IVARBPROC)( index_, v_ );
}

void glVertexAttrib4sARBWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SARBPROC, "glVertexAttrib4sARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SARBPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4svARBWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SVARBPROC, "glVertexAttrib4svARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SVARBPROC)( index_, v_ );
}

void glVertexAttrib4ubvARBWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UBVARBPROC, "glVertexAttrib4ubvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UBVARBPROC)( index_, v_ );
}

void glVertexAttrib4uivARBWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UIVARBPROC, "glVertexAttrib4uivARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UIVARBPROC)( index_, v_ );
}

void glVertexAttrib4usvARBWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4USVARBPROC, "glVertexAttrib4usvARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4USVARBPROC)( index_, v_ );
}

void glVertexAttribPointerARBWrapper(GLuint index_, GLint size_, GLenum type_, GLboolean normalized_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBPOINTERARBPROC, "glVertexAttribPointerARB");
  RESOLVED_PROC(PFNGLVERTEXATTRIBPOINTERARBPROC)( index_, size_, type_, normalized_, stride_, pointer_ );
}

void glEnableVertexAttribArrayARBWrapper(GLuint index_)
{
  RESOLVE(PFNGLENABLEVERTEXATTRIBARRAYARBPROC, "glEnableVertexAttribArrayARB");
  RESOLVED_PROC(PFNGLENABLEVERTEXATTRIBARRAYARBPROC)( index_ );
}

void glDisableVertexAttribArrayARBWrapper(GLuint index_)
{
  RESOLVE(PFNGLDISABLEVERTEXATTRIBARRAYARBPROC, "glDisableVertexAttribArrayARB");
  RESOLVED_PROC(PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)( index_ );
}

void glGetVertexAttribdvARBWrapper(GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBDVARBPROC, "glGetVertexAttribdvARB");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBDVARBPROC)( index_, pname_, params_ );
}

void glGetVertexAttribfvARBWrapper(GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBFVARBPROC, "glGetVertexAttribfvARB");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBFVARBPROC)( index_, pname_, params_ );
}

void glGetVertexAttribivARBWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIVARBPROC, "glGetVertexAttribivARB");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIVARBPROC)( index_, pname_, params_ );
}

void glGetVertexAttribPointervARBWrapper(GLuint index_, GLenum pname_, void ** pointer_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBPOINTERVARBPROC, "glGetVertexAttribPointervARB");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBPOINTERVARBPROC)( index_, pname_, pointer_ );
}

void glBindAttribLocationARBWrapper(GLhandleARB programObj_, GLuint index_, const GLcharARB* name_)
{
  RESOLVE(PFNGLBINDATTRIBLOCATIONARBPROC, "glBindAttribLocationARB");
  RESOLVED_PROC(PFNGLBINDATTRIBLOCATIONARBPROC)( programObj_, index_, name_ );
}

void glGetActiveAttribARBWrapper(GLhandleARB programObj_, GLuint index_, GLsizei maxLength_, GLsizei* length_, GLint* size_, GLenum* type_, GLcharARB* name_)
{
  RESOLVE(PFNGLGETACTIVEATTRIBARBPROC, "glGetActiveAttribARB");
  RESOLVED_PROC(PFNGLGETACTIVEATTRIBARBPROC)( programObj_, index_, maxLength_, length_, size_, type_, name_ );
}

GLint glGetAttribLocationARBWrapper(GLhandleARB programObj_, const GLcharARB* name_)
{
  RESOLVE_RET(PFNGLGETATTRIBLOCATIONARBPROC, "glGetAttribLocationARB", FALSE);
  return RESOLVED_PROC(PFNGLGETATTRIBLOCATIONARBPROC)(programObj_, name_ );
}

void glWindowPos2dARBWrapper(GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLWINDOWPOS2DARBPROC, "glWindowPos2dARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2DARBPROC)( x_, y_ );
}

void glWindowPos2dvARBWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS2DVARBPROC, "glWindowPos2dvARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2DVARBPROC)( v_ );
}

void glWindowPos2fARBWrapper(GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLWINDOWPOS2FARBPROC, "glWindowPos2fARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2FARBPROC)( x_, y_ );
}

void glWindowPos2fvARBWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS2FVARBPROC, "glWindowPos2fvARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2FVARBPROC)( v_ );
}

void glWindowPos2iARBWrapper(GLint x_, GLint y_)
{
  RESOLVE(PFNGLWINDOWPOS2IARBPROC, "glWindowPos2iARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2IARBPROC)( x_, y_ );
}

void glWindowPos2ivARBWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS2IVARBPROC, "glWindowPos2ivARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2IVARBPROC)( v_ );
}

void glWindowPos2sARBWrapper(GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLWINDOWPOS2SARBPROC, "glWindowPos2sARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2SARBPROC)( x_, y_ );
}

void glWindowPos2svARBWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS2SVARBPROC, "glWindowPos2svARB");
  RESOLVED_PROC(PFNGLWINDOWPOS2SVARBPROC)( v_ );
}

void glWindowPos3dARBWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLWINDOWPOS3DARBPROC, "glWindowPos3dARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3DARBPROC)( x_, y_, z_ );
}

void glWindowPos3dvARBWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS3DVARBPROC, "glWindowPos3dvARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3DVARBPROC)( v_ );
}

void glWindowPos3fARBWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLWINDOWPOS3FARBPROC, "glWindowPos3fARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3FARBPROC)( x_, y_, z_ );
}

void glWindowPos3fvARBWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS3FVARBPROC, "glWindowPos3fvARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3FVARBPROC)( v_ );
}

void glWindowPos3iARBWrapper(GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLWINDOWPOS3IARBPROC, "glWindowPos3iARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3IARBPROC)( x_, y_, z_ );
}

void glWindowPos3ivARBWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS3IVARBPROC, "glWindowPos3ivARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3IVARBPROC)( v_ );
}

void glWindowPos3sARBWrapper(GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLWINDOWPOS3SARBPROC, "glWindowPos3sARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3SARBPROC)( x_, y_, z_ );
}

void glWindowPos3svARBWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS3SVARBPROC, "glWindowPos3svARB");
  RESOLVED_PROC(PFNGLWINDOWPOS3SVARBPROC)( v_ );
}

void glBlendBarrierKHRWrapper(void)
{
  RESOLVE(PFNGLBLENDBARRIERKHRPROC, "glBlendBarrierKHR");
  RESOLVED_PROC(PFNGLBLENDBARRIERKHRPROC)(  );
}

void glMultiTexCoord1bOESWrapper(GLenum texture_, GLbyte s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1BOESPROC, "glMultiTexCoord1bOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1BOESPROC)( texture_, s_ );
}

void glMultiTexCoord1bvOESWrapper(GLenum texture_, const GLbyte* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD1BVOESPROC, "glMultiTexCoord1bvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1BVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord2bOESWrapper(GLenum texture_, GLbyte s_, GLbyte t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2BOESPROC, "glMultiTexCoord2bOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2BOESPROC)( texture_, s_, t_ );
}

void glMultiTexCoord2bvOESWrapper(GLenum texture_, const GLbyte* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD2BVOESPROC, "glMultiTexCoord2bvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2BVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord3bOESWrapper(GLenum texture_, GLbyte s_, GLbyte t_, GLbyte r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3BOESPROC, "glMultiTexCoord3bOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3BOESPROC)( texture_, s_, t_, r_ );
}

void glMultiTexCoord3bvOESWrapper(GLenum texture_, const GLbyte* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD3BVOESPROC, "glMultiTexCoord3bvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3BVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord4bOESWrapper(GLenum texture_, GLbyte s_, GLbyte t_, GLbyte r_, GLbyte q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4BOESPROC, "glMultiTexCoord4bOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4BOESPROC)( texture_, s_, t_, r_, q_ );
}

void glMultiTexCoord4bvOESWrapper(GLenum texture_, const GLbyte* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD4BVOESPROC, "glMultiTexCoord4bvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4BVOESPROC)( texture_, coords_ );
}

void glTexCoord1bOESWrapper(GLbyte s_)
{
  RESOLVE(PFNGLTEXCOORD1BOESPROC, "glTexCoord1bOES");
  RESOLVED_PROC(PFNGLTEXCOORD1BOESPROC)( s_ );
}

void glTexCoord1bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLTEXCOORD1BVOESPROC, "glTexCoord1bvOES");
  RESOLVED_PROC(PFNGLTEXCOORD1BVOESPROC)( coords_ );
}

void glTexCoord2bOESWrapper(GLbyte s_, GLbyte t_)
{
  RESOLVE(PFNGLTEXCOORD2BOESPROC, "glTexCoord2bOES");
  RESOLVED_PROC(PFNGLTEXCOORD2BOESPROC)( s_, t_ );
}

void glTexCoord2bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLTEXCOORD2BVOESPROC, "glTexCoord2bvOES");
  RESOLVED_PROC(PFNGLTEXCOORD2BVOESPROC)( coords_ );
}

void glTexCoord3bOESWrapper(GLbyte s_, GLbyte t_, GLbyte r_)
{
  RESOLVE(PFNGLTEXCOORD3BOESPROC, "glTexCoord3bOES");
  RESOLVED_PROC(PFNGLTEXCOORD3BOESPROC)( s_, t_, r_ );
}

void glTexCoord3bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLTEXCOORD3BVOESPROC, "glTexCoord3bvOES");
  RESOLVED_PROC(PFNGLTEXCOORD3BVOESPROC)( coords_ );
}

void glTexCoord4bOESWrapper(GLbyte s_, GLbyte t_, GLbyte r_, GLbyte q_)
{
  RESOLVE(PFNGLTEXCOORD4BOESPROC, "glTexCoord4bOES");
  RESOLVED_PROC(PFNGLTEXCOORD4BOESPROC)( s_, t_, r_, q_ );
}

void glTexCoord4bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLTEXCOORD4BVOESPROC, "glTexCoord4bvOES");
  RESOLVED_PROC(PFNGLTEXCOORD4BVOESPROC)( coords_ );
}

void glVertex2bOESWrapper(GLbyte x_, GLbyte y_)
{
  RESOLVE(PFNGLVERTEX2BOESPROC, "glVertex2bOES");
  RESOLVED_PROC(PFNGLVERTEX2BOESPROC)( x_, y_ );
}

void glVertex2bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLVERTEX2BVOESPROC, "glVertex2bvOES");
  RESOLVED_PROC(PFNGLVERTEX2BVOESPROC)( coords_ );
}

void glVertex3bOESWrapper(GLbyte x_, GLbyte y_, GLbyte z_)
{
  RESOLVE(PFNGLVERTEX3BOESPROC, "glVertex3bOES");
  RESOLVED_PROC(PFNGLVERTEX3BOESPROC)( x_, y_, z_ );
}

void glVertex3bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLVERTEX3BVOESPROC, "glVertex3bvOES");
  RESOLVED_PROC(PFNGLVERTEX3BVOESPROC)( coords_ );
}

void glVertex4bOESWrapper(GLbyte x_, GLbyte y_, GLbyte z_, GLbyte w_)
{
  RESOLVE(PFNGLVERTEX4BOESPROC, "glVertex4bOES");
  RESOLVED_PROC(PFNGLVERTEX4BOESPROC)( x_, y_, z_, w_ );
}

void glVertex4bvOESWrapper(const GLbyte* coords_)
{
  RESOLVE(PFNGLVERTEX4BVOESPROC, "glVertex4bvOES");
  RESOLVED_PROC(PFNGLVERTEX4BVOESPROC)( coords_ );
}

void glAlphaFuncxOESWrapper(GLenum func_, GLfixed ref_)
{
  RESOLVE(PFNGLALPHAFUNCXOESPROC, "glAlphaFuncxOES");
  RESOLVED_PROC(PFNGLALPHAFUNCXOESPROC)( func_, ref_ );
}

void glClearColorxOESWrapper(GLfixed red_, GLfixed green_, GLfixed blue_, GLfixed alpha_)
{
  RESOLVE(PFNGLCLEARCOLORXOESPROC, "glClearColorxOES");
  RESOLVED_PROC(PFNGLCLEARCOLORXOESPROC)( red_, green_, blue_, alpha_ );
}

void glClearDepthxOESWrapper(GLfixed depth_)
{
  RESOLVE(PFNGLCLEARDEPTHXOESPROC, "glClearDepthxOES");
  RESOLVED_PROC(PFNGLCLEARDEPTHXOESPROC)( depth_ );
}

void glClipPlanexOESWrapper(GLenum plane_, const GLfixed* equation_)
{
  RESOLVE(PFNGLCLIPPLANEXOESPROC, "glClipPlanexOES");
  RESOLVED_PROC(PFNGLCLIPPLANEXOESPROC)( plane_, equation_ );
}

void glColor4xOESWrapper(GLfixed red_, GLfixed green_, GLfixed blue_, GLfixed alpha_)
{
  RESOLVE(PFNGLCOLOR4XOESPROC, "glColor4xOES");
  RESOLVED_PROC(PFNGLCOLOR4XOESPROC)( red_, green_, blue_, alpha_ );
}

void glDepthRangexOESWrapper(GLfixed n_, GLfixed f_)
{
  RESOLVE(PFNGLDEPTHRANGEXOESPROC, "glDepthRangexOES");
  RESOLVED_PROC(PFNGLDEPTHRANGEXOESPROC)( n_, f_ );
}

void glFogxOESWrapper(GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLFOGXOESPROC, "glFogxOES");
  RESOLVED_PROC(PFNGLFOGXOESPROC)( pname_, param_ );
}

void glFogxvOESWrapper(GLenum pname_, const GLfixed* param_)
{
  RESOLVE(PFNGLFOGXVOESPROC, "glFogxvOES");
  RESOLVED_PROC(PFNGLFOGXVOESPROC)( pname_, param_ );
}

void glFrustumxOESWrapper(GLfixed l_, GLfixed r_, GLfixed b_, GLfixed t_, GLfixed n_, GLfixed f_)
{
  RESOLVE(PFNGLFRUSTUMXOESPROC, "glFrustumxOES");
  RESOLVED_PROC(PFNGLFRUSTUMXOESPROC)( l_, r_, b_, t_, n_, f_ );
}

void glGetClipPlanexOESWrapper(GLenum plane_, GLfixed* equation_)
{
  RESOLVE(PFNGLGETCLIPPLANEXOESPROC, "glGetClipPlanexOES");
  RESOLVED_PROC(PFNGLGETCLIPPLANEXOESPROC)( plane_, equation_ );
}

void glGetFixedvOESWrapper(GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETFIXEDVOESPROC, "glGetFixedvOES");
  RESOLVED_PROC(PFNGLGETFIXEDVOESPROC)( pname_, params_ );
}

void glGetTexEnvxvOESWrapper(GLenum target_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETTEXENVXVOESPROC, "glGetTexEnvxvOES");
  RESOLVED_PROC(PFNGLGETTEXENVXVOESPROC)( target_, pname_, params_ );
}

void glGetTexParameterxvOESWrapper(GLenum target_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERXVOESPROC, "glGetTexParameterxvOES");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERXVOESPROC)( target_, pname_, params_ );
}

void glLightModelxOESWrapper(GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLLIGHTMODELXOESPROC, "glLightModelxOES");
  RESOLVED_PROC(PFNGLLIGHTMODELXOESPROC)( pname_, param_ );
}

void glLightModelxvOESWrapper(GLenum pname_, const GLfixed* param_)
{
  RESOLVE(PFNGLLIGHTMODELXVOESPROC, "glLightModelxvOES");
  RESOLVED_PROC(PFNGLLIGHTMODELXVOESPROC)( pname_, param_ );
}

void glLightxOESWrapper(GLenum light_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLLIGHTXOESPROC, "glLightxOES");
  RESOLVED_PROC(PFNGLLIGHTXOESPROC)( light_, pname_, param_ );
}

void glLightxvOESWrapper(GLenum light_, GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLLIGHTXVOESPROC, "glLightxvOES");
  RESOLVED_PROC(PFNGLLIGHTXVOESPROC)( light_, pname_, params_ );
}

void glLineWidthxOESWrapper(GLfixed width_)
{
  RESOLVE(PFNGLLINEWIDTHXOESPROC, "glLineWidthxOES");
  RESOLVED_PROC(PFNGLLINEWIDTHXOESPROC)( width_ );
}

void glLoadMatrixxOESWrapper(const GLfixed* m_)
{
  RESOLVE(PFNGLLOADMATRIXXOESPROC, "glLoadMatrixxOES");
  RESOLVED_PROC(PFNGLLOADMATRIXXOESPROC)( m_ );
}

void glMaterialxOESWrapper(GLenum face_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLMATERIALXOESPROC, "glMaterialxOES");
  RESOLVED_PROC(PFNGLMATERIALXOESPROC)( face_, pname_, param_ );
}

void glMaterialxvOESWrapper(GLenum face_, GLenum pname_, const GLfixed* param_)
{
  RESOLVE(PFNGLMATERIALXVOESPROC, "glMaterialxvOES");
  RESOLVED_PROC(PFNGLMATERIALXVOESPROC)( face_, pname_, param_ );
}

void glMultMatrixxOESWrapper(const GLfixed* m_)
{
  RESOLVE(PFNGLMULTMATRIXXOESPROC, "glMultMatrixxOES");
  RESOLVED_PROC(PFNGLMULTMATRIXXOESPROC)( m_ );
}

void glMultiTexCoord4xOESWrapper(GLenum texture_, GLfixed s_, GLfixed t_, GLfixed r_, GLfixed q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4XOESPROC, "glMultiTexCoord4xOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4XOESPROC)( texture_, s_, t_, r_, q_ );
}

void glNormal3xOESWrapper(GLfixed nx_, GLfixed ny_, GLfixed nz_)
{
  RESOLVE(PFNGLNORMAL3XOESPROC, "glNormal3xOES");
  RESOLVED_PROC(PFNGLNORMAL3XOESPROC)( nx_, ny_, nz_ );
}

void glOrthoxOESWrapper(GLfixed l_, GLfixed r_, GLfixed b_, GLfixed t_, GLfixed n_, GLfixed f_)
{
  RESOLVE(PFNGLORTHOXOESPROC, "glOrthoxOES");
  RESOLVED_PROC(PFNGLORTHOXOESPROC)( l_, r_, b_, t_, n_, f_ );
}

void glPointParameterxvOESWrapper(GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERXVOESPROC, "glPointParameterxvOES");
  RESOLVED_PROC(PFNGLPOINTPARAMETERXVOESPROC)( pname_, params_ );
}

void glPointSizexOESWrapper(GLfixed size_)
{
  RESOLVE(PFNGLPOINTSIZEXOESPROC, "glPointSizexOES");
  RESOLVED_PROC(PFNGLPOINTSIZEXOESPROC)( size_ );
}

void glPolygonOffsetxOESWrapper(GLfixed factor_, GLfixed units_)
{
  RESOLVE(PFNGLPOLYGONOFFSETXOESPROC, "glPolygonOffsetxOES");
  RESOLVED_PROC(PFNGLPOLYGONOFFSETXOESPROC)( factor_, units_ );
}

void glRotatexOESWrapper(GLfixed angle_, GLfixed x_, GLfixed y_, GLfixed z_)
{
  RESOLVE(PFNGLROTATEXOESPROC, "glRotatexOES");
  RESOLVED_PROC(PFNGLROTATEXOESPROC)( angle_, x_, y_, z_ );
}

void glScalexOESWrapper(GLfixed x_, GLfixed y_, GLfixed z_)
{
  RESOLVE(PFNGLSCALEXOESPROC, "glScalexOES");
  RESOLVED_PROC(PFNGLSCALEXOESPROC)( x_, y_, z_ );
}

void glTexEnvxOESWrapper(GLenum target_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLTEXENVXOESPROC, "glTexEnvxOES");
  RESOLVED_PROC(PFNGLTEXENVXOESPROC)( target_, pname_, param_ );
}

void glTexEnvxvOESWrapper(GLenum target_, GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLTEXENVXVOESPROC, "glTexEnvxvOES");
  RESOLVED_PROC(PFNGLTEXENVXVOESPROC)( target_, pname_, params_ );
}

void glTexParameterxOESWrapper(GLenum target_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLTEXPARAMETERXOESPROC, "glTexParameterxOES");
  RESOLVED_PROC(PFNGLTEXPARAMETERXOESPROC)( target_, pname_, param_ );
}

void glTexParameterxvOESWrapper(GLenum target_, GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLTEXPARAMETERXVOESPROC, "glTexParameterxvOES");
  RESOLVED_PROC(PFNGLTEXPARAMETERXVOESPROC)( target_, pname_, params_ );
}

void glTranslatexOESWrapper(GLfixed x_, GLfixed y_, GLfixed z_)
{
  RESOLVE(PFNGLTRANSLATEXOESPROC, "glTranslatexOES");
  RESOLVED_PROC(PFNGLTRANSLATEXOESPROC)( x_, y_, z_ );
}

void glAccumxOESWrapper(GLenum op_, GLfixed value_)
{
  RESOLVE(PFNGLACCUMXOESPROC, "glAccumxOES");
  RESOLVED_PROC(PFNGLACCUMXOESPROC)( op_, value_ );
}

void glBitmapxOESWrapper(GLsizei width_, GLsizei height_, GLfixed xorig_, GLfixed yorig_, GLfixed xmove_, GLfixed ymove_, const GLubyte* bitmap_)
{
  RESOLVE(PFNGLBITMAPXOESPROC, "glBitmapxOES");
  RESOLVED_PROC(PFNGLBITMAPXOESPROC)( width_, height_, xorig_, yorig_, xmove_, ymove_, bitmap_ );
}

void glBlendColorxOESWrapper(GLfixed red_, GLfixed green_, GLfixed blue_, GLfixed alpha_)
{
  RESOLVE(PFNGLBLENDCOLORXOESPROC, "glBlendColorxOES");
  RESOLVED_PROC(PFNGLBLENDCOLORXOESPROC)( red_, green_, blue_, alpha_ );
}

void glClearAccumxOESWrapper(GLfixed red_, GLfixed green_, GLfixed blue_, GLfixed alpha_)
{
  RESOLVE(PFNGLCLEARACCUMXOESPROC, "glClearAccumxOES");
  RESOLVED_PROC(PFNGLCLEARACCUMXOESPROC)( red_, green_, blue_, alpha_ );
}

void glColor3xOESWrapper(GLfixed red_, GLfixed green_, GLfixed blue_)
{
  RESOLVE(PFNGLCOLOR3XOESPROC, "glColor3xOES");
  RESOLVED_PROC(PFNGLCOLOR3XOESPROC)( red_, green_, blue_ );
}

void glColor3xvOESWrapper(const GLfixed* components_)
{
  RESOLVE(PFNGLCOLOR3XVOESPROC, "glColor3xvOES");
  RESOLVED_PROC(PFNGLCOLOR3XVOESPROC)( components_ );
}

void glColor4xvOESWrapper(const GLfixed* components_)
{
  RESOLVE(PFNGLCOLOR4XVOESPROC, "glColor4xvOES");
  RESOLVED_PROC(PFNGLCOLOR4XVOESPROC)( components_ );
}

void glConvolutionParameterxOESWrapper(GLenum target_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERXOESPROC, "glConvolutionParameterxOES");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERXOESPROC)( target_, pname_, param_ );
}

void glConvolutionParameterxvOESWrapper(GLenum target_, GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERXVOESPROC, "glConvolutionParameterxvOES");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERXVOESPROC)( target_, pname_, params_ );
}

void glEvalCoord1xOESWrapper(GLfixed u_)
{
  RESOLVE(PFNGLEVALCOORD1XOESPROC, "glEvalCoord1xOES");
  RESOLVED_PROC(PFNGLEVALCOORD1XOESPROC)( u_ );
}

void glEvalCoord1xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLEVALCOORD1XVOESPROC, "glEvalCoord1xvOES");
  RESOLVED_PROC(PFNGLEVALCOORD1XVOESPROC)( coords_ );
}

void glEvalCoord2xOESWrapper(GLfixed u_, GLfixed v_)
{
  RESOLVE(PFNGLEVALCOORD2XOESPROC, "glEvalCoord2xOES");
  RESOLVED_PROC(PFNGLEVALCOORD2XOESPROC)( u_, v_ );
}

void glEvalCoord2xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLEVALCOORD2XVOESPROC, "glEvalCoord2xvOES");
  RESOLVED_PROC(PFNGLEVALCOORD2XVOESPROC)( coords_ );
}

void glFeedbackBufferxOESWrapper(GLsizei n_, GLenum type_, const GLfixed* buffer_)
{
  RESOLVE(PFNGLFEEDBACKBUFFERXOESPROC, "glFeedbackBufferxOES");
  RESOLVED_PROC(PFNGLFEEDBACKBUFFERXOESPROC)( n_, type_, buffer_ );
}

void glGetConvolutionParameterxvOESWrapper(GLenum target_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETCONVOLUTIONPARAMETERXVOESPROC, "glGetConvolutionParameterxvOES");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONPARAMETERXVOESPROC)( target_, pname_, params_ );
}

void glGetHistogramParameterxvOESWrapper(GLenum target_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETHISTOGRAMPARAMETERXVOESPROC, "glGetHistogramParameterxvOES");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPARAMETERXVOESPROC)( target_, pname_, params_ );
}

void glGetLightxOESWrapper(GLenum light_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETLIGHTXOESPROC, "glGetLightxOES");
  RESOLVED_PROC(PFNGLGETLIGHTXOESPROC)( light_, pname_, params_ );
}

void glGetMapxvOESWrapper(GLenum target_, GLenum query_, GLfixed* v_)
{
  RESOLVE(PFNGLGETMAPXVOESPROC, "glGetMapxvOES");
  RESOLVED_PROC(PFNGLGETMAPXVOESPROC)( target_, query_, v_ );
}

void glGetMaterialxOESWrapper(GLenum face_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLGETMATERIALXOESPROC, "glGetMaterialxOES");
  RESOLVED_PROC(PFNGLGETMATERIALXOESPROC)( face_, pname_, param_ );
}

void glGetPixelMapxvWrapper(GLenum map_, GLint size_, GLfixed* values_)
{
  RESOLVE(PFNGLGETPIXELMAPXVPROC, "glGetPixelMapxv");
  RESOLVED_PROC(PFNGLGETPIXELMAPXVPROC)( map_, size_, values_ );
}

void glGetTexGenxvOESWrapper(GLenum coord_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETTEXGENXVOESPROC, "glGetTexGenxvOES");
  RESOLVED_PROC(PFNGLGETTEXGENXVOESPROC)( coord_, pname_, params_ );
}

void glGetTexLevelParameterxvOESWrapper(GLenum target_, GLint level_, GLenum pname_, GLfixed* params_)
{
  RESOLVE(PFNGLGETTEXLEVELPARAMETERXVOESPROC, "glGetTexLevelParameterxvOES");
  RESOLVED_PROC(PFNGLGETTEXLEVELPARAMETERXVOESPROC)( target_, level_, pname_, params_ );
}

void glIndexxOESWrapper(GLfixed component_)
{
  RESOLVE(PFNGLINDEXXOESPROC, "glIndexxOES");
  RESOLVED_PROC(PFNGLINDEXXOESPROC)( component_ );
}

void glIndexxvOESWrapper(const GLfixed* component_)
{
  RESOLVE(PFNGLINDEXXVOESPROC, "glIndexxvOES");
  RESOLVED_PROC(PFNGLINDEXXVOESPROC)( component_ );
}

void glLoadTransposeMatrixxOESWrapper(const GLfixed* m_)
{
  RESOLVE(PFNGLLOADTRANSPOSEMATRIXXOESPROC, "glLoadTransposeMatrixxOES");
  RESOLVED_PROC(PFNGLLOADTRANSPOSEMATRIXXOESPROC)( m_ );
}

void glMap1xOESWrapper(GLenum target_, GLfixed u1_, GLfixed u2_, GLint stride_, GLint order_, GLfixed points_)
{
  RESOLVE(PFNGLMAP1XOESPROC, "glMap1xOES");
  RESOLVED_PROC(PFNGLMAP1XOESPROC)( target_, u1_, u2_, stride_, order_, points_ );
}

void glMap2xOESWrapper(GLenum target_, GLfixed u1_, GLfixed u2_, GLint ustride_, GLint uorder_, GLfixed v1_, GLfixed v2_, GLint vstride_, GLint vorder_, GLfixed points_)
{
  RESOLVE(PFNGLMAP2XOESPROC, "glMap2xOES");
  RESOLVED_PROC(PFNGLMAP2XOESPROC)( target_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, points_ );
}

void glMapGrid1xOESWrapper(GLint n_, GLfixed u1_, GLfixed u2_)
{
  RESOLVE(PFNGLMAPGRID1XOESPROC, "glMapGrid1xOES");
  RESOLVED_PROC(PFNGLMAPGRID1XOESPROC)( n_, u1_, u2_ );
}

void glMapGrid2xOESWrapper(GLint n_, GLfixed u1_, GLfixed u2_, GLfixed v1_, GLfixed v2_)
{
  RESOLVE(PFNGLMAPGRID2XOESPROC, "glMapGrid2xOES");
  RESOLVED_PROC(PFNGLMAPGRID2XOESPROC)( n_, u1_, u2_, v1_, v2_ );
}

void glMultTransposeMatrixxOESWrapper(const GLfixed* m_)
{
  RESOLVE(PFNGLMULTTRANSPOSEMATRIXXOESPROC, "glMultTransposeMatrixxOES");
  RESOLVED_PROC(PFNGLMULTTRANSPOSEMATRIXXOESPROC)( m_ );
}

void glMultiTexCoord1xOESWrapper(GLenum texture_, GLfixed s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1XOESPROC, "glMultiTexCoord1xOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1XOESPROC)( texture_, s_ );
}

void glMultiTexCoord1xvOESWrapper(GLenum texture_, const GLfixed* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD1XVOESPROC, "glMultiTexCoord1xvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1XVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord2xOESWrapper(GLenum texture_, GLfixed s_, GLfixed t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2XOESPROC, "glMultiTexCoord2xOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2XOESPROC)( texture_, s_, t_ );
}

void glMultiTexCoord2xvOESWrapper(GLenum texture_, const GLfixed* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD2XVOESPROC, "glMultiTexCoord2xvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2XVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord3xOESWrapper(GLenum texture_, GLfixed s_, GLfixed t_, GLfixed r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3XOESPROC, "glMultiTexCoord3xOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3XOESPROC)( texture_, s_, t_, r_ );
}

void glMultiTexCoord3xvOESWrapper(GLenum texture_, const GLfixed* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD3XVOESPROC, "glMultiTexCoord3xvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3XVOESPROC)( texture_, coords_ );
}

void glMultiTexCoord4xvOESWrapper(GLenum texture_, const GLfixed* coords_)
{
  RESOLVE(PFNGLMULTITEXCOORD4XVOESPROC, "glMultiTexCoord4xvOES");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4XVOESPROC)( texture_, coords_ );
}

void glNormal3xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLNORMAL3XVOESPROC, "glNormal3xvOES");
  RESOLVED_PROC(PFNGLNORMAL3XVOESPROC)( coords_ );
}

void glPassThroughxOESWrapper(GLfixed token_)
{
  RESOLVE(PFNGLPASSTHROUGHXOESPROC, "glPassThroughxOES");
  RESOLVED_PROC(PFNGLPASSTHROUGHXOESPROC)( token_ );
}

void glPixelMapxWrapper(GLenum map_, GLint size_, const GLfixed* values_)
{
  RESOLVE(PFNGLPIXELMAPXPROC, "glPixelMapx");
  RESOLVED_PROC(PFNGLPIXELMAPXPROC)( map_, size_, values_ );
}

void glPixelStorexWrapper(GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLPIXELSTOREXPROC, "glPixelStorex");
  RESOLVED_PROC(PFNGLPIXELSTOREXPROC)( pname_, param_ );
}

void glPixelTransferxOESWrapper(GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLPIXELTRANSFERXOESPROC, "glPixelTransferxOES");
  RESOLVED_PROC(PFNGLPIXELTRANSFERXOESPROC)( pname_, param_ );
}

void glPixelZoomxOESWrapper(GLfixed xfactor_, GLfixed yfactor_)
{
  RESOLVE(PFNGLPIXELZOOMXOESPROC, "glPixelZoomxOES");
  RESOLVED_PROC(PFNGLPIXELZOOMXOESPROC)( xfactor_, yfactor_ );
}

void glPrioritizeTexturesxOESWrapper(GLsizei n_, const GLuint* textures_, const GLfixed* priorities_)
{
  RESOLVE(PFNGLPRIORITIZETEXTURESXOESPROC, "glPrioritizeTexturesxOES");
  RESOLVED_PROC(PFNGLPRIORITIZETEXTURESXOESPROC)( n_, textures_, priorities_ );
}

void glRasterPos2xOESWrapper(GLfixed x_, GLfixed y_)
{
  RESOLVE(PFNGLRASTERPOS2XOESPROC, "glRasterPos2xOES");
  RESOLVED_PROC(PFNGLRASTERPOS2XOESPROC)( x_, y_ );
}

void glRasterPos2xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLRASTERPOS2XVOESPROC, "glRasterPos2xvOES");
  RESOLVED_PROC(PFNGLRASTERPOS2XVOESPROC)( coords_ );
}

void glRasterPos3xOESWrapper(GLfixed x_, GLfixed y_, GLfixed z_)
{
  RESOLVE(PFNGLRASTERPOS3XOESPROC, "glRasterPos3xOES");
  RESOLVED_PROC(PFNGLRASTERPOS3XOESPROC)( x_, y_, z_ );
}

void glRasterPos3xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLRASTERPOS3XVOESPROC, "glRasterPos3xvOES");
  RESOLVED_PROC(PFNGLRASTERPOS3XVOESPROC)( coords_ );
}

void glRasterPos4xOESWrapper(GLfixed x_, GLfixed y_, GLfixed z_, GLfixed w_)
{
  RESOLVE(PFNGLRASTERPOS4XOESPROC, "glRasterPos4xOES");
  RESOLVED_PROC(PFNGLRASTERPOS4XOESPROC)( x_, y_, z_, w_ );
}

void glRasterPos4xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLRASTERPOS4XVOESPROC, "glRasterPos4xvOES");
  RESOLVED_PROC(PFNGLRASTERPOS4XVOESPROC)( coords_ );
}

void glRectxOESWrapper(GLfixed x1_, GLfixed y1_, GLfixed x2_, GLfixed y2_)
{
  RESOLVE(PFNGLRECTXOESPROC, "glRectxOES");
  RESOLVED_PROC(PFNGLRECTXOESPROC)( x1_, y1_, x2_, y2_ );
}

void glRectxvOESWrapper(const GLfixed* v1_, const GLfixed* v2_)
{
  RESOLVE(PFNGLRECTXVOESPROC, "glRectxvOES");
  RESOLVED_PROC(PFNGLRECTXVOESPROC)( v1_, v2_ );
}

void glTexCoord1xOESWrapper(GLfixed s_)
{
  RESOLVE(PFNGLTEXCOORD1XOESPROC, "glTexCoord1xOES");
  RESOLVED_PROC(PFNGLTEXCOORD1XOESPROC)( s_ );
}

void glTexCoord1xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLTEXCOORD1XVOESPROC, "glTexCoord1xvOES");
  RESOLVED_PROC(PFNGLTEXCOORD1XVOESPROC)( coords_ );
}

void glTexCoord2xOESWrapper(GLfixed s_, GLfixed t_)
{
  RESOLVE(PFNGLTEXCOORD2XOESPROC, "glTexCoord2xOES");
  RESOLVED_PROC(PFNGLTEXCOORD2XOESPROC)( s_, t_ );
}

void glTexCoord2xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLTEXCOORD2XVOESPROC, "glTexCoord2xvOES");
  RESOLVED_PROC(PFNGLTEXCOORD2XVOESPROC)( coords_ );
}

void glTexCoord3xOESWrapper(GLfixed s_, GLfixed t_, GLfixed r_)
{
  RESOLVE(PFNGLTEXCOORD3XOESPROC, "glTexCoord3xOES");
  RESOLVED_PROC(PFNGLTEXCOORD3XOESPROC)( s_, t_, r_ );
}

void glTexCoord3xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLTEXCOORD3XVOESPROC, "glTexCoord3xvOES");
  RESOLVED_PROC(PFNGLTEXCOORD3XVOESPROC)( coords_ );
}

void glTexCoord4xOESWrapper(GLfixed s_, GLfixed t_, GLfixed r_, GLfixed q_)
{
  RESOLVE(PFNGLTEXCOORD4XOESPROC, "glTexCoord4xOES");
  RESOLVED_PROC(PFNGLTEXCOORD4XOESPROC)( s_, t_, r_, q_ );
}

void glTexCoord4xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLTEXCOORD4XVOESPROC, "glTexCoord4xvOES");
  RESOLVED_PROC(PFNGLTEXCOORD4XVOESPROC)( coords_ );
}

void glTexGenxOESWrapper(GLenum coord_, GLenum pname_, GLfixed param_)
{
  RESOLVE(PFNGLTEXGENXOESPROC, "glTexGenxOES");
  RESOLVED_PROC(PFNGLTEXGENXOESPROC)( coord_, pname_, param_ );
}

void glTexGenxvOESWrapper(GLenum coord_, GLenum pname_, const GLfixed* params_)
{
  RESOLVE(PFNGLTEXGENXVOESPROC, "glTexGenxvOES");
  RESOLVED_PROC(PFNGLTEXGENXVOESPROC)( coord_, pname_, params_ );
}

void glVertex2xOESWrapper(GLfixed x_)
{
  RESOLVE(PFNGLVERTEX2XOESPROC, "glVertex2xOES");
  RESOLVED_PROC(PFNGLVERTEX2XOESPROC)( x_ );
}

void glVertex2xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLVERTEX2XVOESPROC, "glVertex2xvOES");
  RESOLVED_PROC(PFNGLVERTEX2XVOESPROC)( coords_ );
}

void glVertex3xOESWrapper(GLfixed x_, GLfixed y_)
{
  RESOLVE(PFNGLVERTEX3XOESPROC, "glVertex3xOES");
  RESOLVED_PROC(PFNGLVERTEX3XOESPROC)( x_, y_ );
}

void glVertex3xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLVERTEX3XVOESPROC, "glVertex3xvOES");
  RESOLVED_PROC(PFNGLVERTEX3XVOESPROC)( coords_ );
}

void glVertex4xOESWrapper(GLfixed x_, GLfixed y_, GLfixed z_)
{
  RESOLVE(PFNGLVERTEX4XOESPROC, "glVertex4xOES");
  RESOLVED_PROC(PFNGLVERTEX4XOESPROC)( x_, y_, z_ );
}

void glVertex4xvOESWrapper(const GLfixed* coords_)
{
  RESOLVE(PFNGLVERTEX4XVOESPROC, "glVertex4xvOES");
  RESOLVED_PROC(PFNGLVERTEX4XVOESPROC)( coords_ );
}

GLbitfield glQueryMatrixxOESWrapper(GLfixed* mantissa_, GLint* exponent_)
{
  RESOLVE_RET(PFNGLQUERYMATRIXXOESPROC, "glQueryMatrixxOES", FALSE);
  return RESOLVED_PROC(PFNGLQUERYMATRIXXOESPROC)(mantissa_, exponent_ );
}

void glClearDepthfOESWrapper(GLclampf depth_)
{
  RESOLVE(PFNGLCLEARDEPTHFOESPROC, "glClearDepthfOES");
  RESOLVED_PROC(PFNGLCLEARDEPTHFOESPROC)( depth_ );
}

void glClipPlanefOESWrapper(GLenum plane_, const GLfloat* equation_)
{
  RESOLVE(PFNGLCLIPPLANEFOESPROC, "glClipPlanefOES");
  RESOLVED_PROC(PFNGLCLIPPLANEFOESPROC)( plane_, equation_ );
}

void glDepthRangefOESWrapper(GLclampf n_, GLclampf f_)
{
  RESOLVE(PFNGLDEPTHRANGEFOESPROC, "glDepthRangefOES");
  RESOLVED_PROC(PFNGLDEPTHRANGEFOESPROC)( n_, f_ );
}

void glFrustumfOESWrapper(GLfloat l_, GLfloat r_, GLfloat b_, GLfloat t_, GLfloat n_, GLfloat f_)
{
  RESOLVE(PFNGLFRUSTUMFOESPROC, "glFrustumfOES");
  RESOLVED_PROC(PFNGLFRUSTUMFOESPROC)( l_, r_, b_, t_, n_, f_ );
}

void glGetClipPlanefOESWrapper(GLenum plane_, GLfloat* equation_)
{
  RESOLVE(PFNGLGETCLIPPLANEFOESPROC, "glGetClipPlanefOES");
  RESOLVED_PROC(PFNGLGETCLIPPLANEFOESPROC)( plane_, equation_ );
}

void glOrthofOESWrapper(GLfloat l_, GLfloat r_, GLfloat b_, GLfloat t_, GLfloat n_, GLfloat f_)
{
  RESOLVE(PFNGLORTHOFOESPROC, "glOrthofOES");
  RESOLVED_PROC(PFNGLORTHOFOESPROC)( l_, r_, b_, t_, n_, f_ );
}

void glTbufferMask3DFXWrapper(GLuint mask_)
{
  RESOLVE(PFNGLTBUFFERMASK3DFXPROC, "glTbufferMask3DFX");
  RESOLVED_PROC(PFNGLTBUFFERMASK3DFXPROC)( mask_ );
}

void glDebugMessageEnableAMDWrapper(GLenum category_, GLenum severity_, GLsizei count_, const GLuint* ids_, GLboolean enabled_)
{
  RESOLVE(PFNGLDEBUGMESSAGEENABLEAMDPROC, "glDebugMessageEnableAMD");
  RESOLVED_PROC(PFNGLDEBUGMESSAGEENABLEAMDPROC)( category_, severity_, count_, ids_, enabled_ );
}

void glDebugMessageInsertAMDWrapper(GLenum category_, GLenum severity_, GLuint id_, GLsizei length_, const GLchar* buf_)
{
  RESOLVE(PFNGLDEBUGMESSAGEINSERTAMDPROC, "glDebugMessageInsertAMD");
  RESOLVED_PROC(PFNGLDEBUGMESSAGEINSERTAMDPROC)( category_, severity_, id_, length_, buf_ );
}

void glDebugMessageCallbackAMDWrapper(GLDEBUGPROCAMD callback_, void * userParam_)
{
  RESOLVE(PFNGLDEBUGMESSAGECALLBACKAMDPROC, "glDebugMessageCallbackAMD");
  RESOLVED_PROC(PFNGLDEBUGMESSAGECALLBACKAMDPROC)( callback_, userParam_ );
}

GLuint glGetDebugMessageLogAMDWrapper(GLuint count_, GLsizei bufsize_, GLenum* categories_, GLuint* severities_, GLuint* ids_, GLsizei* lengths_, GLchar* message_)
{
  RESOLVE_RET(PFNGLGETDEBUGMESSAGELOGAMDPROC, "glGetDebugMessageLogAMD", FALSE);
  return RESOLVED_PROC(PFNGLGETDEBUGMESSAGELOGAMDPROC)(count_, bufsize_, categories_, severities_, ids_, lengths_, message_ );
}

void glBlendFuncIndexedAMDWrapper(GLuint buf_, GLenum src_, GLenum dst_)
{
  RESOLVE(PFNGLBLENDFUNCINDEXEDAMDPROC, "glBlendFuncIndexedAMD");
  RESOLVED_PROC(PFNGLBLENDFUNCINDEXEDAMDPROC)( buf_, src_, dst_ );
}

void glBlendFuncSeparateIndexedAMDWrapper(GLuint buf_, GLenum srcRGB_, GLenum dstRGB_, GLenum srcAlpha_, GLenum dstAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC, "glBlendFuncSeparateIndexedAMD");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)( buf_, srcRGB_, dstRGB_, srcAlpha_, dstAlpha_ );
}

void glBlendEquationIndexedAMDWrapper(GLuint buf_, GLenum mode_)
{
  RESOLVE(PFNGLBLENDEQUATIONINDEXEDAMDPROC, "glBlendEquationIndexedAMD");
  RESOLVED_PROC(PFNGLBLENDEQUATIONINDEXEDAMDPROC)( buf_, mode_ );
}

void glBlendEquationSeparateIndexedAMDWrapper(GLuint buf_, GLenum modeRGB_, GLenum modeAlpha_)
{
  RESOLVE(PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC, "glBlendEquationSeparateIndexedAMD");
  RESOLVED_PROC(PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)( buf_, modeRGB_, modeAlpha_ );
}

void glUniform1i64NVWrapper(GLint location_, GLint64EXT x_)
{
  RESOLVE(PFNGLUNIFORM1I64NVPROC, "glUniform1i64NV");
  RESOLVED_PROC(PFNGLUNIFORM1I64NVPROC)( location_, x_ );
}

void glUniform2i64NVWrapper(GLint location_, GLint64EXT x_, GLint64EXT y_)
{
  RESOLVE(PFNGLUNIFORM2I64NVPROC, "glUniform2i64NV");
  RESOLVED_PROC(PFNGLUNIFORM2I64NVPROC)( location_, x_, y_ );
}

void glUniform3i64NVWrapper(GLint location_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_)
{
  RESOLVE(PFNGLUNIFORM3I64NVPROC, "glUniform3i64NV");
  RESOLVED_PROC(PFNGLUNIFORM3I64NVPROC)( location_, x_, y_, z_ );
}

void glUniform4i64NVWrapper(GLint location_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_, GLint64EXT w_)
{
  RESOLVE(PFNGLUNIFORM4I64NVPROC, "glUniform4i64NV");
  RESOLVED_PROC(PFNGLUNIFORM4I64NVPROC)( location_, x_, y_, z_, w_ );
}

void glUniform1i64vNVWrapper(GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM1I64VNVPROC, "glUniform1i64vNV");
  RESOLVED_PROC(PFNGLUNIFORM1I64VNVPROC)( location_, count_, value_ );
}

void glUniform2i64vNVWrapper(GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM2I64VNVPROC, "glUniform2i64vNV");
  RESOLVED_PROC(PFNGLUNIFORM2I64VNVPROC)( location_, count_, value_ );
}

void glUniform3i64vNVWrapper(GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM3I64VNVPROC, "glUniform3i64vNV");
  RESOLVED_PROC(PFNGLUNIFORM3I64VNVPROC)( location_, count_, value_ );
}

void glUniform4i64vNVWrapper(GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM4I64VNVPROC, "glUniform4i64vNV");
  RESOLVED_PROC(PFNGLUNIFORM4I64VNVPROC)( location_, count_, value_ );
}

void glUniform1ui64NVWrapper(GLint location_, GLuint64EXT x_)
{
  RESOLVE(PFNGLUNIFORM1UI64NVPROC, "glUniform1ui64NV");
  RESOLVED_PROC(PFNGLUNIFORM1UI64NVPROC)( location_, x_ );
}

void glUniform2ui64NVWrapper(GLint location_, GLuint64EXT x_, GLuint64EXT y_)
{
  RESOLVE(PFNGLUNIFORM2UI64NVPROC, "glUniform2ui64NV");
  RESOLVED_PROC(PFNGLUNIFORM2UI64NVPROC)( location_, x_, y_ );
}

void glUniform3ui64NVWrapper(GLint location_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_)
{
  RESOLVE(PFNGLUNIFORM3UI64NVPROC, "glUniform3ui64NV");
  RESOLVED_PROC(PFNGLUNIFORM3UI64NVPROC)( location_, x_, y_, z_ );
}

void glUniform4ui64NVWrapper(GLint location_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_, GLuint64EXT w_)
{
  RESOLVE(PFNGLUNIFORM4UI64NVPROC, "glUniform4ui64NV");
  RESOLVED_PROC(PFNGLUNIFORM4UI64NVPROC)( location_, x_, y_, z_, w_ );
}

void glUniform1ui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM1UI64VNVPROC, "glUniform1ui64vNV");
  RESOLVED_PROC(PFNGLUNIFORM1UI64VNVPROC)( location_, count_, value_ );
}

void glUniform2ui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM2UI64VNVPROC, "glUniform2ui64vNV");
  RESOLVED_PROC(PFNGLUNIFORM2UI64VNVPROC)( location_, count_, value_ );
}

void glUniform3ui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM3UI64VNVPROC, "glUniform3ui64vNV");
  RESOLVED_PROC(PFNGLUNIFORM3UI64VNVPROC)( location_, count_, value_ );
}

void glUniform4ui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORM4UI64VNVPROC, "glUniform4ui64vNV");
  RESOLVED_PROC(PFNGLUNIFORM4UI64VNVPROC)( location_, count_, value_ );
}

void glGetUniformi64vNVWrapper(GLuint program_, GLint location_, GLint64EXT* params_)
{
  RESOLVE(PFNGLGETUNIFORMI64VNVPROC, "glGetUniformi64vNV");
  RESOLVED_PROC(PFNGLGETUNIFORMI64VNVPROC)( program_, location_, params_ );
}

void glGetUniformui64vNVWrapper(GLuint program_, GLint location_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETUNIFORMUI64VNVPROC, "glGetUniformui64vNV");
  RESOLVED_PROC(PFNGLGETUNIFORMUI64VNVPROC)( program_, location_, params_ );
}

void glProgramUniform1i64NVWrapper(GLuint program_, GLint location_, GLint64EXT x_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1I64NVPROC, "glProgramUniform1i64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1I64NVPROC)( program_, location_, x_ );
}

void glProgramUniform2i64NVWrapper(GLuint program_, GLint location_, GLint64EXT x_, GLint64EXT y_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2I64NVPROC, "glProgramUniform2i64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2I64NVPROC)( program_, location_, x_, y_ );
}

void glProgramUniform3i64NVWrapper(GLuint program_, GLint location_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3I64NVPROC, "glProgramUniform3i64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3I64NVPROC)( program_, location_, x_, y_, z_ );
}

void glProgramUniform4i64NVWrapper(GLuint program_, GLint location_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_, GLint64EXT w_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4I64NVPROC, "glProgramUniform4i64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4I64NVPROC)( program_, location_, x_, y_, z_, w_ );
}

void glProgramUniform1i64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1I64VNVPROC, "glProgramUniform1i64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1I64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2i64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2I64VNVPROC, "glProgramUniform2i64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2I64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3i64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3I64VNVPROC, "glProgramUniform3i64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3I64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4i64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4I64VNVPROC, "glProgramUniform4i64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4I64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1ui64NVWrapper(GLuint program_, GLint location_, GLuint64EXT x_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UI64NVPROC, "glProgramUniform1ui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UI64NVPROC)( program_, location_, x_ );
}

void glProgramUniform2ui64NVWrapper(GLuint program_, GLint location_, GLuint64EXT x_, GLuint64EXT y_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UI64NVPROC, "glProgramUniform2ui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UI64NVPROC)( program_, location_, x_, y_ );
}

void glProgramUniform3ui64NVWrapper(GLuint program_, GLint location_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UI64NVPROC, "glProgramUniform3ui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UI64NVPROC)( program_, location_, x_, y_, z_ );
}

void glProgramUniform4ui64NVWrapper(GLuint program_, GLint location_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_, GLuint64EXT w_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UI64NVPROC, "glProgramUniform4ui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UI64NVPROC)( program_, location_, x_, y_, z_, w_ );
}

void glProgramUniform1ui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UI64VNVPROC, "glProgramUniform1ui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UI64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2ui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UI64VNVPROC, "glProgramUniform2ui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UI64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3ui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UI64VNVPROC, "glProgramUniform3ui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UI64VNVPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4ui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UI64VNVPROC, "glProgramUniform4ui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UI64VNVPROC)( program_, location_, count_, value_ );
}

void glVertexAttribParameteriAMDWrapper(GLuint index_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLVERTEXATTRIBPARAMETERIAMDPROC, "glVertexAttribParameteriAMD");
  RESOLVED_PROC(PFNGLVERTEXATTRIBPARAMETERIAMDPROC)( index_, pname_, param_ );
}

void glMultiDrawArraysIndirectAMDWrapper(GLenum mode_, const void * indirect_, GLsizei primcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC, "glMultiDrawArraysIndirectAMD");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)( mode_, indirect_, primcount_, stride_ );
}

void glMultiDrawElementsIndirectAMDWrapper(GLenum mode_, GLenum type_, const void * indirect_, GLsizei primcount_, GLsizei stride_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC, "glMultiDrawElementsIndirectAMD");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)( mode_, type_, indirect_, primcount_, stride_ );
}

void glGenNamesAMDWrapper(GLenum identifier_, GLuint num_, GLuint* names_)
{
  RESOLVE(PFNGLGENNAMESAMDPROC, "glGenNamesAMD");
  RESOLVED_PROC(PFNGLGENNAMESAMDPROC)( identifier_, num_, names_ );
}

void glDeleteNamesAMDWrapper(GLenum identifier_, GLuint num_, const GLuint* names_)
{
  RESOLVE(PFNGLDELETENAMESAMDPROC, "glDeleteNamesAMD");
  RESOLVED_PROC(PFNGLDELETENAMESAMDPROC)( identifier_, num_, names_ );
}

GLboolean glIsNameAMDWrapper(GLenum identifier_, GLuint name_)
{
  RESOLVE_RET(PFNGLISNAMEAMDPROC, "glIsNameAMD", FALSE);
  return RESOLVED_PROC(PFNGLISNAMEAMDPROC)(identifier_, name_ );
}

void glQueryObjectParameteruiAMDWrapper(GLenum target_, GLuint id_, GLenum pname_, GLuint param_)
{
  RESOLVE(PFNGLQUERYOBJECTPARAMETERUIAMDPROC, "glQueryObjectParameteruiAMD");
  RESOLVED_PROC(PFNGLQUERYOBJECTPARAMETERUIAMDPROC)( target_, id_, pname_, param_ );
}

void glGetPerfMonitorGroupsAMDWrapper(GLint* numGroups_, GLsizei groupsSize_, GLuint* groups_)
{
  RESOLVE(PFNGLGETPERFMONITORGROUPSAMDPROC, "glGetPerfMonitorGroupsAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORGROUPSAMDPROC)( numGroups_, groupsSize_, groups_ );
}

void glGetPerfMonitorCountersAMDWrapper(GLuint group_, GLint* numCounters_, GLint* maxActiveCounters_, GLsizei counterSize_, GLuint* counters_)
{
  RESOLVE(PFNGLGETPERFMONITORCOUNTERSAMDPROC, "glGetPerfMonitorCountersAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORCOUNTERSAMDPROC)( group_, numCounters_, maxActiveCounters_, counterSize_, counters_ );
}

void glGetPerfMonitorGroupStringAMDWrapper(GLuint group_, GLsizei bufSize_, GLsizei* length_, GLchar* groupString_)
{
  RESOLVE(PFNGLGETPERFMONITORGROUPSTRINGAMDPROC, "glGetPerfMonitorGroupStringAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)( group_, bufSize_, length_, groupString_ );
}

void glGetPerfMonitorCounterStringAMDWrapper(GLuint group_, GLuint counter_, GLsizei bufSize_, GLsizei* length_, GLchar* counterString_)
{
  RESOLVE(PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC, "glGetPerfMonitorCounterStringAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)( group_, counter_, bufSize_, length_, counterString_ );
}

void glGetPerfMonitorCounterInfoAMDWrapper(GLuint group_, GLuint counter_, GLenum pname_, void * data_)
{
  RESOLVE(PFNGLGETPERFMONITORCOUNTERINFOAMDPROC, "glGetPerfMonitorCounterInfoAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)( group_, counter_, pname_, data_ );
}

void glGenPerfMonitorsAMDWrapper(GLsizei n_, GLuint* monitors_)
{
  RESOLVE(PFNGLGENPERFMONITORSAMDPROC, "glGenPerfMonitorsAMD");
  RESOLVED_PROC(PFNGLGENPERFMONITORSAMDPROC)( n_, monitors_ );
}

void glDeletePerfMonitorsAMDWrapper(GLsizei n_, GLuint* monitors_)
{
  RESOLVE(PFNGLDELETEPERFMONITORSAMDPROC, "glDeletePerfMonitorsAMD");
  RESOLVED_PROC(PFNGLDELETEPERFMONITORSAMDPROC)( n_, monitors_ );
}

void glSelectPerfMonitorCountersAMDWrapper(GLuint monitor_, GLboolean enable_, GLuint group_, GLint numCounters_, GLuint* counterList_)
{
  RESOLVE(PFNGLSELECTPERFMONITORCOUNTERSAMDPROC, "glSelectPerfMonitorCountersAMD");
  RESOLVED_PROC(PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)( monitor_, enable_, group_, numCounters_, counterList_ );
}

void glBeginPerfMonitorAMDWrapper(GLuint monitor_)
{
  RESOLVE(PFNGLBEGINPERFMONITORAMDPROC, "glBeginPerfMonitorAMD");
  RESOLVED_PROC(PFNGLBEGINPERFMONITORAMDPROC)( monitor_ );
}

void glEndPerfMonitorAMDWrapper(GLuint monitor_)
{
  RESOLVE(PFNGLENDPERFMONITORAMDPROC, "glEndPerfMonitorAMD");
  RESOLVED_PROC(PFNGLENDPERFMONITORAMDPROC)( monitor_ );
}

void glGetPerfMonitorCounterDataAMDWrapper(GLuint monitor_, GLenum pname_, GLsizei dataSize_, GLuint* data_, GLint* bytesWritten_)
{
  RESOLVE(PFNGLGETPERFMONITORCOUNTERDATAAMDPROC, "glGetPerfMonitorCounterDataAMD");
  RESOLVED_PROC(PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)( monitor_, pname_, dataSize_, data_, bytesWritten_ );
}

void glSetMultisamplefvAMDWrapper(GLenum pname_, GLuint index_, const GLfloat* val_)
{
  RESOLVE(PFNGLSETMULTISAMPLEFVAMDPROC, "glSetMultisamplefvAMD");
  RESOLVED_PROC(PFNGLSETMULTISAMPLEFVAMDPROC)( pname_, index_, val_ );
}

void glTexStorageSparseAMDWrapper(GLenum target_, GLenum internalFormat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLsizei layers_, GLbitfield flags_)
{
  RESOLVE(PFNGLTEXSTORAGESPARSEAMDPROC, "glTexStorageSparseAMD");
  RESOLVED_PROC(PFNGLTEXSTORAGESPARSEAMDPROC)( target_, internalFormat_, width_, height_, depth_, layers_, flags_ );
}

void glTextureStorageSparseAMDWrapper(GLuint texture_, GLenum target_, GLenum internalFormat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLsizei layers_, GLbitfield flags_)
{
  RESOLVE(PFNGLTEXTURESTORAGESPARSEAMDPROC, "glTextureStorageSparseAMD");
  RESOLVED_PROC(PFNGLTEXTURESTORAGESPARSEAMDPROC)( texture_, target_, internalFormat_, width_, height_, depth_, layers_, flags_ );
}

void glStencilOpValueAMDWrapper(GLenum face_, GLuint value_)
{
  RESOLVE(PFNGLSTENCILOPVALUEAMDPROC, "glStencilOpValueAMD");
  RESOLVED_PROC(PFNGLSTENCILOPVALUEAMDPROC)( face_, value_ );
}

void glTessellationFactorAMDWrapper(GLfloat factor_)
{
  RESOLVE(PFNGLTESSELLATIONFACTORAMDPROC, "glTessellationFactorAMD");
  RESOLVED_PROC(PFNGLTESSELLATIONFACTORAMDPROC)( factor_ );
}

void glTessellationModeAMDWrapper(GLenum mode_)
{
  RESOLVE(PFNGLTESSELLATIONMODEAMDPROC, "glTessellationModeAMD");
  RESOLVED_PROC(PFNGLTESSELLATIONMODEAMDPROC)( mode_ );
}

void glElementPointerAPPLEWrapper(GLenum type_, const void * pointer_)
{
  RESOLVE(PFNGLELEMENTPOINTERAPPLEPROC, "glElementPointerAPPLE");
  RESOLVED_PROC(PFNGLELEMENTPOINTERAPPLEPROC)( type_, pointer_ );
}

void glDrawElementArrayAPPLEWrapper(GLenum mode_, GLint first_, GLsizei count_)
{
  RESOLVE(PFNGLDRAWELEMENTARRAYAPPLEPROC, "glDrawElementArrayAPPLE");
  RESOLVED_PROC(PFNGLDRAWELEMENTARRAYAPPLEPROC)( mode_, first_, count_ );
}

void glDrawRangeElementArrayAPPLEWrapper(GLenum mode_, GLuint start_, GLuint end_, GLint first_, GLsizei count_)
{
  RESOLVE(PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC, "glDrawRangeElementArrayAPPLE");
  RESOLVED_PROC(PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)( mode_, start_, end_, first_, count_ );
}

void glMultiDrawElementArrayAPPLEWrapper(GLenum mode_, const GLint* first_, const GLsizei* count_, GLsizei primcount_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC, "glMultiDrawElementArrayAPPLE");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)( mode_, first_, count_, primcount_ );
}

void glMultiDrawRangeElementArrayAPPLEWrapper(GLenum mode_, GLuint start_, GLuint end_, const GLint* first_, const GLsizei* count_, GLsizei primcount_)
{
  RESOLVE(PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC, "glMultiDrawRangeElementArrayAPPLE");
  RESOLVED_PROC(PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)( mode_, start_, end_, first_, count_, primcount_ );
}

void glGenFencesAPPLEWrapper(GLsizei n_, GLuint* fences_)
{
  RESOLVE(PFNGLGENFENCESAPPLEPROC, "glGenFencesAPPLE");
  RESOLVED_PROC(PFNGLGENFENCESAPPLEPROC)( n_, fences_ );
}

void glDeleteFencesAPPLEWrapper(GLsizei n_, const GLuint* fences_)
{
  RESOLVE(PFNGLDELETEFENCESAPPLEPROC, "glDeleteFencesAPPLE");
  RESOLVED_PROC(PFNGLDELETEFENCESAPPLEPROC)( n_, fences_ );
}

void glSetFenceAPPLEWrapper(GLuint fence_)
{
  RESOLVE(PFNGLSETFENCEAPPLEPROC, "glSetFenceAPPLE");
  RESOLVED_PROC(PFNGLSETFENCEAPPLEPROC)( fence_ );
}

GLboolean glIsFenceAPPLEWrapper(GLuint fence_)
{
  RESOLVE_RET(PFNGLISFENCEAPPLEPROC, "glIsFenceAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLISFENCEAPPLEPROC)(fence_ );
}

GLboolean glTestFenceAPPLEWrapper(GLuint fence_)
{
  RESOLVE_RET(PFNGLTESTFENCEAPPLEPROC, "glTestFenceAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLTESTFENCEAPPLEPROC)(fence_ );
}

void glFinishFenceAPPLEWrapper(GLuint fence_)
{
  RESOLVE(PFNGLFINISHFENCEAPPLEPROC, "glFinishFenceAPPLE");
  RESOLVED_PROC(PFNGLFINISHFENCEAPPLEPROC)( fence_ );
}

GLboolean glTestObjectAPPLEWrapper(GLenum object_, GLuint name_)
{
  RESOLVE_RET(PFNGLTESTOBJECTAPPLEPROC, "glTestObjectAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLTESTOBJECTAPPLEPROC)(object_, name_ );
}

void glFinishObjectAPPLEWrapper(GLenum object_, GLint name_)
{
  RESOLVE(PFNGLFINISHOBJECTAPPLEPROC, "glFinishObjectAPPLE");
  RESOLVED_PROC(PFNGLFINISHOBJECTAPPLEPROC)( object_, name_ );
}

void glBufferParameteriAPPLEWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLBUFFERPARAMETERIAPPLEPROC, "glBufferParameteriAPPLE");
  RESOLVED_PROC(PFNGLBUFFERPARAMETERIAPPLEPROC)( target_, pname_, param_ );
}

void glFlushMappedBufferRangeAPPLEWrapper(GLenum target_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC, "glFlushMappedBufferRangeAPPLE");
  RESOLVED_PROC(PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)( target_, offset_, size_ );
}

GLenum glObjectPurgeableAPPLEWrapper(GLenum objectType_, GLuint name_, GLenum option_)
{
  RESOLVE_RET(PFNGLOBJECTPURGEABLEAPPLEPROC, "glObjectPurgeableAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLOBJECTPURGEABLEAPPLEPROC)(objectType_, name_, option_ );
}

GLenum glObjectUnpurgeableAPPLEWrapper(GLenum objectType_, GLuint name_, GLenum option_)
{
  RESOLVE_RET(PFNGLOBJECTUNPURGEABLEAPPLEPROC, "glObjectUnpurgeableAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLOBJECTUNPURGEABLEAPPLEPROC)(objectType_, name_, option_ );
}

void glGetObjectParameterivAPPLEWrapper(GLenum objectType_, GLuint name_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETOBJECTPARAMETERIVAPPLEPROC, "glGetObjectParameterivAPPLE");
  RESOLVED_PROC(PFNGLGETOBJECTPARAMETERIVAPPLEPROC)( objectType_, name_, pname_, params_ );
}

void glTextureRangeAPPLEWrapper(GLenum target_, GLsizei length_, const void * pointer_)
{
  RESOLVE(PFNGLTEXTURERANGEAPPLEPROC, "glTextureRangeAPPLE");
  RESOLVED_PROC(PFNGLTEXTURERANGEAPPLEPROC)( target_, length_, pointer_ );
}

void glGetTexParameterPointervAPPLEWrapper(GLenum target_, GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC, "glGetTexParameterPointervAPPLE");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)( target_, pname_, params_ );
}

void glBindVertexArrayAPPLEWrapper(GLuint array_)
{
  RESOLVE(PFNGLBINDVERTEXARRAYAPPLEPROC, "glBindVertexArrayAPPLE");
  RESOLVED_PROC(PFNGLBINDVERTEXARRAYAPPLEPROC)( array_ );
}

void glDeleteVertexArraysAPPLEWrapper(GLsizei n_, const GLuint* arrays_)
{
  RESOLVE(PFNGLDELETEVERTEXARRAYSAPPLEPROC, "glDeleteVertexArraysAPPLE");
  RESOLVED_PROC(PFNGLDELETEVERTEXARRAYSAPPLEPROC)( n_, arrays_ );
}

void glGenVertexArraysAPPLEWrapper(GLsizei n_, GLuint* arrays_)
{
  RESOLVE(PFNGLGENVERTEXARRAYSAPPLEPROC, "glGenVertexArraysAPPLE");
  RESOLVED_PROC(PFNGLGENVERTEXARRAYSAPPLEPROC)( n_, arrays_ );
}

GLboolean glIsVertexArrayAPPLEWrapper(GLuint array_)
{
  RESOLVE_RET(PFNGLISVERTEXARRAYAPPLEPROC, "glIsVertexArrayAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLISVERTEXARRAYAPPLEPROC)(array_ );
}

void glVertexArrayRangeAPPLEWrapper(GLsizei length_, void * pointer_)
{
  RESOLVE(PFNGLVERTEXARRAYRANGEAPPLEPROC, "glVertexArrayRangeAPPLE");
  RESOLVED_PROC(PFNGLVERTEXARRAYRANGEAPPLEPROC)( length_, pointer_ );
}

void glFlushVertexArrayRangeAPPLEWrapper(GLsizei length_, void * pointer_)
{
  RESOLVE(PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC, "glFlushVertexArrayRangeAPPLE");
  RESOLVED_PROC(PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)( length_, pointer_ );
}

void glVertexArrayParameteriAPPLEWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLVERTEXARRAYPARAMETERIAPPLEPROC, "glVertexArrayParameteriAPPLE");
  RESOLVED_PROC(PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)( pname_, param_ );
}

void glEnableVertexAttribAPPLEWrapper(GLuint index_, GLenum pname_)
{
  RESOLVE(PFNGLENABLEVERTEXATTRIBAPPLEPROC, "glEnableVertexAttribAPPLE");
  RESOLVED_PROC(PFNGLENABLEVERTEXATTRIBAPPLEPROC)( index_, pname_ );
}

void glDisableVertexAttribAPPLEWrapper(GLuint index_, GLenum pname_)
{
  RESOLVE(PFNGLDISABLEVERTEXATTRIBAPPLEPROC, "glDisableVertexAttribAPPLE");
  RESOLVED_PROC(PFNGLDISABLEVERTEXATTRIBAPPLEPROC)( index_, pname_ );
}

GLboolean glIsVertexAttribEnabledAPPLEWrapper(GLuint index_, GLenum pname_)
{
  RESOLVE_RET(PFNGLISVERTEXATTRIBENABLEDAPPLEPROC, "glIsVertexAttribEnabledAPPLE", FALSE);
  return RESOLVED_PROC(PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)(index_, pname_ );
}

void glMapVertexAttrib1dAPPLEWrapper(GLuint index_, GLuint size_, GLdouble u1_, GLdouble u2_, GLint stride_, GLint order_, const GLdouble* points_)
{
  RESOLVE(PFNGLMAPVERTEXATTRIB1DAPPLEPROC, "glMapVertexAttrib1dAPPLE");
  RESOLVED_PROC(PFNGLMAPVERTEXATTRIB1DAPPLEPROC)( index_, size_, u1_, u2_, stride_, order_, points_ );
}

void glMapVertexAttrib1fAPPLEWrapper(GLuint index_, GLuint size_, GLfloat u1_, GLfloat u2_, GLint stride_, GLint order_, const GLfloat* points_)
{
  RESOLVE(PFNGLMAPVERTEXATTRIB1FAPPLEPROC, "glMapVertexAttrib1fAPPLE");
  RESOLVED_PROC(PFNGLMAPVERTEXATTRIB1FAPPLEPROC)( index_, size_, u1_, u2_, stride_, order_, points_ );
}

void glMapVertexAttrib2dAPPLEWrapper(GLuint index_, GLuint size_, GLdouble u1_, GLdouble u2_, GLint ustride_, GLint uorder_, GLdouble v1_, GLdouble v2_, GLint vstride_, GLint vorder_, const GLdouble* points_)
{
  RESOLVE(PFNGLMAPVERTEXATTRIB2DAPPLEPROC, "glMapVertexAttrib2dAPPLE");
  RESOLVED_PROC(PFNGLMAPVERTEXATTRIB2DAPPLEPROC)( index_, size_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, points_ );
}

void glMapVertexAttrib2fAPPLEWrapper(GLuint index_, GLuint size_, GLfloat u1_, GLfloat u2_, GLint ustride_, GLint uorder_, GLfloat v1_, GLfloat v2_, GLint vstride_, GLint vorder_, const GLfloat* points_)
{
  RESOLVE(PFNGLMAPVERTEXATTRIB2FAPPLEPROC, "glMapVertexAttrib2fAPPLE");
  RESOLVED_PROC(PFNGLMAPVERTEXATTRIB2FAPPLEPROC)( index_, size_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, points_ );
}

void glDrawBuffersATIWrapper(GLsizei n_, const GLenum* bufs_)
{
  RESOLVE(PFNGLDRAWBUFFERSATIPROC, "glDrawBuffersATI");
  RESOLVED_PROC(PFNGLDRAWBUFFERSATIPROC)( n_, bufs_ );
}

void glElementPointerATIWrapper(GLenum type_, const void * pointer_)
{
  RESOLVE(PFNGLELEMENTPOINTERATIPROC, "glElementPointerATI");
  RESOLVED_PROC(PFNGLELEMENTPOINTERATIPROC)( type_, pointer_ );
}

void glDrawElementArrayATIWrapper(GLenum mode_, GLsizei count_)
{
  RESOLVE(PFNGLDRAWELEMENTARRAYATIPROC, "glDrawElementArrayATI");
  RESOLVED_PROC(PFNGLDRAWELEMENTARRAYATIPROC)( mode_, count_ );
}

void glDrawRangeElementArrayATIWrapper(GLenum mode_, GLuint start_, GLuint end_, GLsizei count_)
{
  RESOLVE(PFNGLDRAWRANGEELEMENTARRAYATIPROC, "glDrawRangeElementArrayATI");
  RESOLVED_PROC(PFNGLDRAWRANGEELEMENTARRAYATIPROC)( mode_, start_, end_, count_ );
}

void glTexBumpParameterivATIWrapper(GLenum pname_, const GLint* param_)
{
  RESOLVE(PFNGLTEXBUMPPARAMETERIVATIPROC, "glTexBumpParameterivATI");
  RESOLVED_PROC(PFNGLTEXBUMPPARAMETERIVATIPROC)( pname_, param_ );
}

void glTexBumpParameterfvATIWrapper(GLenum pname_, const GLfloat* param_)
{
  RESOLVE(PFNGLTEXBUMPPARAMETERFVATIPROC, "glTexBumpParameterfvATI");
  RESOLVED_PROC(PFNGLTEXBUMPPARAMETERFVATIPROC)( pname_, param_ );
}

void glGetTexBumpParameterivATIWrapper(GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETTEXBUMPPARAMETERIVATIPROC, "glGetTexBumpParameterivATI");
  RESOLVED_PROC(PFNGLGETTEXBUMPPARAMETERIVATIPROC)( pname_, param_ );
}

void glGetTexBumpParameterfvATIWrapper(GLenum pname_, GLfloat* param_)
{
  RESOLVE(PFNGLGETTEXBUMPPARAMETERFVATIPROC, "glGetTexBumpParameterfvATI");
  RESOLVED_PROC(PFNGLGETTEXBUMPPARAMETERFVATIPROC)( pname_, param_ );
}

GLuint glGenFragmentShadersATIWrapper(GLuint range_)
{
  RESOLVE_RET(PFNGLGENFRAGMENTSHADERSATIPROC, "glGenFragmentShadersATI", FALSE);
  return RESOLVED_PROC(PFNGLGENFRAGMENTSHADERSATIPROC)(range_ );
}

void glBindFragmentShaderATIWrapper(GLuint id_)
{
  RESOLVE(PFNGLBINDFRAGMENTSHADERATIPROC, "glBindFragmentShaderATI");
  RESOLVED_PROC(PFNGLBINDFRAGMENTSHADERATIPROC)( id_ );
}

void glDeleteFragmentShaderATIWrapper(GLuint id_)
{
  RESOLVE(PFNGLDELETEFRAGMENTSHADERATIPROC, "glDeleteFragmentShaderATI");
  RESOLVED_PROC(PFNGLDELETEFRAGMENTSHADERATIPROC)( id_ );
}

void glBeginFragmentShaderATIWrapper(void)
{
  RESOLVE(PFNGLBEGINFRAGMENTSHADERATIPROC, "glBeginFragmentShaderATI");
  RESOLVED_PROC(PFNGLBEGINFRAGMENTSHADERATIPROC)(  );
}

void glEndFragmentShaderATIWrapper(void)
{
  RESOLVE(PFNGLENDFRAGMENTSHADERATIPROC, "glEndFragmentShaderATI");
  RESOLVED_PROC(PFNGLENDFRAGMENTSHADERATIPROC)(  );
}

void glPassTexCoordATIWrapper(GLuint dst_, GLuint coord_, GLenum swizzle_)
{
  RESOLVE(PFNGLPASSTEXCOORDATIPROC, "glPassTexCoordATI");
  RESOLVED_PROC(PFNGLPASSTEXCOORDATIPROC)( dst_, coord_, swizzle_ );
}

void glSampleMapATIWrapper(GLuint dst_, GLuint interp_, GLenum swizzle_)
{
  RESOLVE(PFNGLSAMPLEMAPATIPROC, "glSampleMapATI");
  RESOLVED_PROC(PFNGLSAMPLEMAPATIPROC)( dst_, interp_, swizzle_ );
}

void glColorFragmentOp1ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMask_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_)
{
  RESOLVE(PFNGLCOLORFRAGMENTOP1ATIPROC, "glColorFragmentOp1ATI");
  RESOLVED_PROC(PFNGLCOLORFRAGMENTOP1ATIPROC)( op_, dst_, dstMask_, dstMod_, arg1_, arg1Rep_, arg1Mod_ );
}

void glColorFragmentOp2ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMask_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_, GLuint arg2_, GLuint arg2Rep_, GLuint arg2Mod_)
{
  RESOLVE(PFNGLCOLORFRAGMENTOP2ATIPROC, "glColorFragmentOp2ATI");
  RESOLVED_PROC(PFNGLCOLORFRAGMENTOP2ATIPROC)( op_, dst_, dstMask_, dstMod_, arg1_, arg1Rep_, arg1Mod_, arg2_, arg2Rep_, arg2Mod_ );
}

void glColorFragmentOp3ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMask_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_, GLuint arg2_, GLuint arg2Rep_, GLuint arg2Mod_, GLuint arg3_, GLuint arg3Rep_, GLuint arg3Mod_)
{
  RESOLVE(PFNGLCOLORFRAGMENTOP3ATIPROC, "glColorFragmentOp3ATI");
  RESOLVED_PROC(PFNGLCOLORFRAGMENTOP3ATIPROC)( op_, dst_, dstMask_, dstMod_, arg1_, arg1Rep_, arg1Mod_, arg2_, arg2Rep_, arg2Mod_, arg3_, arg3Rep_, arg3Mod_ );
}

void glAlphaFragmentOp1ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_)
{
  RESOLVE(PFNGLALPHAFRAGMENTOP1ATIPROC, "glAlphaFragmentOp1ATI");
  RESOLVED_PROC(PFNGLALPHAFRAGMENTOP1ATIPROC)( op_, dst_, dstMod_, arg1_, arg1Rep_, arg1Mod_ );
}

void glAlphaFragmentOp2ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_, GLuint arg2_, GLuint arg2Rep_, GLuint arg2Mod_)
{
  RESOLVE(PFNGLALPHAFRAGMENTOP2ATIPROC, "glAlphaFragmentOp2ATI");
  RESOLVED_PROC(PFNGLALPHAFRAGMENTOP2ATIPROC)( op_, dst_, dstMod_, arg1_, arg1Rep_, arg1Mod_, arg2_, arg2Rep_, arg2Mod_ );
}

void glAlphaFragmentOp3ATIWrapper(GLenum op_, GLuint dst_, GLuint dstMod_, GLuint arg1_, GLuint arg1Rep_, GLuint arg1Mod_, GLuint arg2_, GLuint arg2Rep_, GLuint arg2Mod_, GLuint arg3_, GLuint arg3Rep_, GLuint arg3Mod_)
{
  RESOLVE(PFNGLALPHAFRAGMENTOP3ATIPROC, "glAlphaFragmentOp3ATI");
  RESOLVED_PROC(PFNGLALPHAFRAGMENTOP3ATIPROC)( op_, dst_, dstMod_, arg1_, arg1Rep_, arg1Mod_, arg2_, arg2Rep_, arg2Mod_, arg3_, arg3Rep_, arg3Mod_ );
}

void glSetFragmentShaderConstantATIWrapper(GLuint dst_, const GLfloat* value_)
{
  RESOLVE(PFNGLSETFRAGMENTSHADERCONSTANTATIPROC, "glSetFragmentShaderConstantATI");
  RESOLVED_PROC(PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)( dst_, value_ );
}

void * glMapObjectBufferATIWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLMAPOBJECTBUFFERATIPROC, "glMapObjectBufferATI", FALSE);
  return RESOLVED_PROC(PFNGLMAPOBJECTBUFFERATIPROC)(buffer_ );
}

void glUnmapObjectBufferATIWrapper(GLuint buffer_)
{
  RESOLVE(PFNGLUNMAPOBJECTBUFFERATIPROC, "glUnmapObjectBufferATI");
  RESOLVED_PROC(PFNGLUNMAPOBJECTBUFFERATIPROC)( buffer_ );
}

void glPNTrianglesiATIWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLPNTRIANGLESIATIPROC, "glPNTrianglesiATI");
  RESOLVED_PROC(PFNGLPNTRIANGLESIATIPROC)( pname_, param_ );
}

void glPNTrianglesfATIWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPNTRIANGLESFATIPROC, "glPNTrianglesfATI");
  RESOLVED_PROC(PFNGLPNTRIANGLESFATIPROC)( pname_, param_ );
}

void glStencilOpSeparateATIWrapper(GLenum face_, GLenum sfail_, GLenum dpfail_, GLenum dppass_)
{
  RESOLVE(PFNGLSTENCILOPSEPARATEATIPROC, "glStencilOpSeparateATI");
  RESOLVED_PROC(PFNGLSTENCILOPSEPARATEATIPROC)( face_, sfail_, dpfail_, dppass_ );
}

void glStencilFuncSeparateATIWrapper(GLenum frontfunc_, GLenum backfunc_, GLint ref_, GLuint mask_)
{
  RESOLVE(PFNGLSTENCILFUNCSEPARATEATIPROC, "glStencilFuncSeparateATI");
  RESOLVED_PROC(PFNGLSTENCILFUNCSEPARATEATIPROC)( frontfunc_, backfunc_, ref_, mask_ );
}

GLuint glNewObjectBufferATIWrapper(GLsizei size_, const void * pointer_, GLenum usage_)
{
  RESOLVE_RET(PFNGLNEWOBJECTBUFFERATIPROC, "glNewObjectBufferATI", FALSE);
  return RESOLVED_PROC(PFNGLNEWOBJECTBUFFERATIPROC)(size_, pointer_, usage_ );
}

GLboolean glIsObjectBufferATIWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLISOBJECTBUFFERATIPROC, "glIsObjectBufferATI", FALSE);
  return RESOLVED_PROC(PFNGLISOBJECTBUFFERATIPROC)(buffer_ );
}

void glUpdateObjectBufferATIWrapper(GLuint buffer_, GLuint offset_, GLsizei size_, const void * pointer_, GLenum preserve_)
{
  RESOLVE(PFNGLUPDATEOBJECTBUFFERATIPROC, "glUpdateObjectBufferATI");
  RESOLVED_PROC(PFNGLUPDATEOBJECTBUFFERATIPROC)( buffer_, offset_, size_, pointer_, preserve_ );
}

void glGetObjectBufferfvATIWrapper(GLuint buffer_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETOBJECTBUFFERFVATIPROC, "glGetObjectBufferfvATI");
  RESOLVED_PROC(PFNGLGETOBJECTBUFFERFVATIPROC)( buffer_, pname_, params_ );
}

void glGetObjectBufferivATIWrapper(GLuint buffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETOBJECTBUFFERIVATIPROC, "glGetObjectBufferivATI");
  RESOLVED_PROC(PFNGLGETOBJECTBUFFERIVATIPROC)( buffer_, pname_, params_ );
}

void glFreeObjectBufferATIWrapper(GLuint buffer_)
{
  RESOLVE(PFNGLFREEOBJECTBUFFERATIPROC, "glFreeObjectBufferATI");
  RESOLVED_PROC(PFNGLFREEOBJECTBUFFERATIPROC)( buffer_ );
}

void glArrayObjectATIWrapper(GLenum array_, GLint size_, GLenum type_, GLsizei stride_, GLuint buffer_, GLuint offset_)
{
  RESOLVE(PFNGLARRAYOBJECTATIPROC, "glArrayObjectATI");
  RESOLVED_PROC(PFNGLARRAYOBJECTATIPROC)( array_, size_, type_, stride_, buffer_, offset_ );
}

void glGetArrayObjectfvATIWrapper(GLenum array_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETARRAYOBJECTFVATIPROC, "glGetArrayObjectfvATI");
  RESOLVED_PROC(PFNGLGETARRAYOBJECTFVATIPROC)( array_, pname_, params_ );
}

void glGetArrayObjectivATIWrapper(GLenum array_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETARRAYOBJECTIVATIPROC, "glGetArrayObjectivATI");
  RESOLVED_PROC(PFNGLGETARRAYOBJECTIVATIPROC)( array_, pname_, params_ );
}

void glVariantArrayObjectATIWrapper(GLuint id_, GLenum type_, GLsizei stride_, GLuint buffer_, GLuint offset_)
{
  RESOLVE(PFNGLVARIANTARRAYOBJECTATIPROC, "glVariantArrayObjectATI");
  RESOLVED_PROC(PFNGLVARIANTARRAYOBJECTATIPROC)( id_, type_, stride_, buffer_, offset_ );
}

void glGetVariantArrayObjectfvATIWrapper(GLuint id_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVARIANTARRAYOBJECTFVATIPROC, "glGetVariantArrayObjectfvATI");
  RESOLVED_PROC(PFNGLGETVARIANTARRAYOBJECTFVATIPROC)( id_, pname_, params_ );
}

void glGetVariantArrayObjectivATIWrapper(GLuint id_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVARIANTARRAYOBJECTIVATIPROC, "glGetVariantArrayObjectivATI");
  RESOLVED_PROC(PFNGLGETVARIANTARRAYOBJECTIVATIPROC)( id_, pname_, params_ );
}

void glVertexAttribArrayObjectATIWrapper(GLuint index_, GLint size_, GLenum type_, GLboolean normalized_, GLsizei stride_, GLuint buffer_, GLuint offset_)
{
  RESOLVE(PFNGLVERTEXATTRIBARRAYOBJECTATIPROC, "glVertexAttribArrayObjectATI");
  RESOLVED_PROC(PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)( index_, size_, type_, normalized_, stride_, buffer_, offset_ );
}

void glGetVertexAttribArrayObjectfvATIWrapper(GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC, "glGetVertexAttribArrayObjectfvATI");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)( index_, pname_, params_ );
}

void glGetVertexAttribArrayObjectivATIWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC, "glGetVertexAttribArrayObjectivATI");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)( index_, pname_, params_ );
}

void glVertexStream1sATIWrapper(GLenum stream_, GLshort x_)
{
  RESOLVE(PFNGLVERTEXSTREAM1SATIPROC, "glVertexStream1sATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1SATIPROC)( stream_, x_ );
}

void glVertexStream1svATIWrapper(GLenum stream_, const GLshort* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM1SVATIPROC, "glVertexStream1svATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1SVATIPROC)( stream_, coords_ );
}

void glVertexStream1iATIWrapper(GLenum stream_, GLint x_)
{
  RESOLVE(PFNGLVERTEXSTREAM1IATIPROC, "glVertexStream1iATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1IATIPROC)( stream_, x_ );
}

void glVertexStream1ivATIWrapper(GLenum stream_, const GLint* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM1IVATIPROC, "glVertexStream1ivATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1IVATIPROC)( stream_, coords_ );
}

void glVertexStream1fATIWrapper(GLenum stream_, GLfloat x_)
{
  RESOLVE(PFNGLVERTEXSTREAM1FATIPROC, "glVertexStream1fATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1FATIPROC)( stream_, x_ );
}

void glVertexStream1fvATIWrapper(GLenum stream_, const GLfloat* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM1FVATIPROC, "glVertexStream1fvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1FVATIPROC)( stream_, coords_ );
}

void glVertexStream1dATIWrapper(GLenum stream_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXSTREAM1DATIPROC, "glVertexStream1dATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1DATIPROC)( stream_, x_ );
}

void glVertexStream1dvATIWrapper(GLenum stream_, const GLdouble* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM1DVATIPROC, "glVertexStream1dvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM1DVATIPROC)( stream_, coords_ );
}

void glVertexStream2sATIWrapper(GLenum stream_, GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLVERTEXSTREAM2SATIPROC, "glVertexStream2sATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2SATIPROC)( stream_, x_, y_ );
}

void glVertexStream2svATIWrapper(GLenum stream_, const GLshort* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM2SVATIPROC, "glVertexStream2svATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2SVATIPROC)( stream_, coords_ );
}

void glVertexStream2iATIWrapper(GLenum stream_, GLint x_, GLint y_)
{
  RESOLVE(PFNGLVERTEXSTREAM2IATIPROC, "glVertexStream2iATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2IATIPROC)( stream_, x_, y_ );
}

void glVertexStream2ivATIWrapper(GLenum stream_, const GLint* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM2IVATIPROC, "glVertexStream2ivATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2IVATIPROC)( stream_, coords_ );
}

void glVertexStream2fATIWrapper(GLenum stream_, GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLVERTEXSTREAM2FATIPROC, "glVertexStream2fATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2FATIPROC)( stream_, x_, y_ );
}

void glVertexStream2fvATIWrapper(GLenum stream_, const GLfloat* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM2FVATIPROC, "glVertexStream2fvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2FVATIPROC)( stream_, coords_ );
}

void glVertexStream2dATIWrapper(GLenum stream_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXSTREAM2DATIPROC, "glVertexStream2dATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2DATIPROC)( stream_, x_, y_ );
}

void glVertexStream2dvATIWrapper(GLenum stream_, const GLdouble* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM2DVATIPROC, "glVertexStream2dvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM2DVATIPROC)( stream_, coords_ );
}

void glVertexStream3sATIWrapper(GLenum stream_, GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLVERTEXSTREAM3SATIPROC, "glVertexStream3sATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3SATIPROC)( stream_, x_, y_, z_ );
}

void glVertexStream3svATIWrapper(GLenum stream_, const GLshort* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM3SVATIPROC, "glVertexStream3svATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3SVATIPROC)( stream_, coords_ );
}

void glVertexStream3iATIWrapper(GLenum stream_, GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLVERTEXSTREAM3IATIPROC, "glVertexStream3iATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3IATIPROC)( stream_, x_, y_, z_ );
}

void glVertexStream3ivATIWrapper(GLenum stream_, const GLint* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM3IVATIPROC, "glVertexStream3ivATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3IVATIPROC)( stream_, coords_ );
}

void glVertexStream3fATIWrapper(GLenum stream_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLVERTEXSTREAM3FATIPROC, "glVertexStream3fATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3FATIPROC)( stream_, x_, y_, z_ );
}

void glVertexStream3fvATIWrapper(GLenum stream_, const GLfloat* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM3FVATIPROC, "glVertexStream3fvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3FVATIPROC)( stream_, coords_ );
}

void glVertexStream3dATIWrapper(GLenum stream_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXSTREAM3DATIPROC, "glVertexStream3dATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3DATIPROC)( stream_, x_, y_, z_ );
}

void glVertexStream3dvATIWrapper(GLenum stream_, const GLdouble* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM3DVATIPROC, "glVertexStream3dvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM3DVATIPROC)( stream_, coords_ );
}

void glVertexStream4sATIWrapper(GLenum stream_, GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  RESOLVE(PFNGLVERTEXSTREAM4SATIPROC, "glVertexStream4sATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4SATIPROC)( stream_, x_, y_, z_, w_ );
}

void glVertexStream4svATIWrapper(GLenum stream_, const GLshort* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM4SVATIPROC, "glVertexStream4svATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4SVATIPROC)( stream_, coords_ );
}

void glVertexStream4iATIWrapper(GLenum stream_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLVERTEXSTREAM4IATIPROC, "glVertexStream4iATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4IATIPROC)( stream_, x_, y_, z_, w_ );
}

void glVertexStream4ivATIWrapper(GLenum stream_, const GLint* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM4IVATIPROC, "glVertexStream4ivATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4IVATIPROC)( stream_, coords_ );
}

void glVertexStream4fATIWrapper(GLenum stream_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLVERTEXSTREAM4FATIPROC, "glVertexStream4fATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4FATIPROC)( stream_, x_, y_, z_, w_ );
}

void glVertexStream4fvATIWrapper(GLenum stream_, const GLfloat* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM4FVATIPROC, "glVertexStream4fvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4FVATIPROC)( stream_, coords_ );
}

void glVertexStream4dATIWrapper(GLenum stream_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXSTREAM4DATIPROC, "glVertexStream4dATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4DATIPROC)( stream_, x_, y_, z_, w_ );
}

void glVertexStream4dvATIWrapper(GLenum stream_, const GLdouble* coords_)
{
  RESOLVE(PFNGLVERTEXSTREAM4DVATIPROC, "glVertexStream4dvATI");
  RESOLVED_PROC(PFNGLVERTEXSTREAM4DVATIPROC)( stream_, coords_ );
}

void glNormalStream3bATIWrapper(GLenum stream_, GLbyte nx_, GLbyte ny_, GLbyte nz_)
{
  RESOLVE(PFNGLNORMALSTREAM3BATIPROC, "glNormalStream3bATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3BATIPROC)( stream_, nx_, ny_, nz_ );
}

void glNormalStream3bvATIWrapper(GLenum stream_, const GLbyte* coords_)
{
  RESOLVE(PFNGLNORMALSTREAM3BVATIPROC, "glNormalStream3bvATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3BVATIPROC)( stream_, coords_ );
}

void glNormalStream3sATIWrapper(GLenum stream_, GLshort nx_, GLshort ny_, GLshort nz_)
{
  RESOLVE(PFNGLNORMALSTREAM3SATIPROC, "glNormalStream3sATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3SATIPROC)( stream_, nx_, ny_, nz_ );
}

void glNormalStream3svATIWrapper(GLenum stream_, const GLshort* coords_)
{
  RESOLVE(PFNGLNORMALSTREAM3SVATIPROC, "glNormalStream3svATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3SVATIPROC)( stream_, coords_ );
}

void glNormalStream3iATIWrapper(GLenum stream_, GLint nx_, GLint ny_, GLint nz_)
{
  RESOLVE(PFNGLNORMALSTREAM3IATIPROC, "glNormalStream3iATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3IATIPROC)( stream_, nx_, ny_, nz_ );
}

void glNormalStream3ivATIWrapper(GLenum stream_, const GLint* coords_)
{
  RESOLVE(PFNGLNORMALSTREAM3IVATIPROC, "glNormalStream3ivATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3IVATIPROC)( stream_, coords_ );
}

void glNormalStream3fATIWrapper(GLenum stream_, GLfloat nx_, GLfloat ny_, GLfloat nz_)
{
  RESOLVE(PFNGLNORMALSTREAM3FATIPROC, "glNormalStream3fATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3FATIPROC)( stream_, nx_, ny_, nz_ );
}

void glNormalStream3fvATIWrapper(GLenum stream_, const GLfloat* coords_)
{
  RESOLVE(PFNGLNORMALSTREAM3FVATIPROC, "glNormalStream3fvATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3FVATIPROC)( stream_, coords_ );
}

void glNormalStream3dATIWrapper(GLenum stream_, GLdouble nx_, GLdouble ny_, GLdouble nz_)
{
  RESOLVE(PFNGLNORMALSTREAM3DATIPROC, "glNormalStream3dATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3DATIPROC)( stream_, nx_, ny_, nz_ );
}

void glNormalStream3dvATIWrapper(GLenum stream_, const GLdouble* coords_)
{
  RESOLVE(PFNGLNORMALSTREAM3DVATIPROC, "glNormalStream3dvATI");
  RESOLVED_PROC(PFNGLNORMALSTREAM3DVATIPROC)( stream_, coords_ );
}

void glClientActiveVertexStreamATIWrapper(GLenum stream_)
{
  RESOLVE(PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC, "glClientActiveVertexStreamATI");
  RESOLVED_PROC(PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)( stream_ );
}

void glVertexBlendEnviATIWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLVERTEXBLENDENVIATIPROC, "glVertexBlendEnviATI");
  RESOLVED_PROC(PFNGLVERTEXBLENDENVIATIPROC)( pname_, param_ );
}

void glVertexBlendEnvfATIWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLVERTEXBLENDENVFATIPROC, "glVertexBlendEnvfATI");
  RESOLVED_PROC(PFNGLVERTEXBLENDENVFATIPROC)( pname_, param_ );
}

void glUniformBufferEXTWrapper(GLuint program_, GLint location_, GLuint buffer_)
{
  RESOLVE(PFNGLUNIFORMBUFFEREXTPROC, "glUniformBufferEXT");
  RESOLVED_PROC(PFNGLUNIFORMBUFFEREXTPROC)( program_, location_, buffer_ );
}

GLint glGetUniformBufferSizeEXTWrapper(GLuint program_, GLint location_)
{
  RESOLVE_RET(PFNGLGETUNIFORMBUFFERSIZEEXTPROC, "glGetUniformBufferSizeEXT", FALSE);
  return RESOLVED_PROC(PFNGLGETUNIFORMBUFFERSIZEEXTPROC)(program_, location_ );
}

GLintptr glGetUniformOffsetEXTWrapper(GLuint program_, GLint location_)
{
  RESOLVE_RET(PFNGLGETUNIFORMOFFSETEXTPROC, "glGetUniformOffsetEXT", FALSE);
  return RESOLVED_PROC(PFNGLGETUNIFORMOFFSETEXTPROC)(program_, location_ );
}

void glBlendColorEXTWrapper(GLfloat red_, GLfloat green_, GLfloat blue_, GLfloat alpha_)
{
  RESOLVE(PFNGLBLENDCOLOREXTPROC, "glBlendColorEXT");
  RESOLVED_PROC(PFNGLBLENDCOLOREXTPROC)( red_, green_, blue_, alpha_ );
}

void glBlendEquationSeparateEXTWrapper(GLenum modeRGB_, GLenum modeAlpha_)
{
  RESOLVE(PFNGLBLENDEQUATIONSEPARATEEXTPROC, "glBlendEquationSeparateEXT");
  RESOLVED_PROC(PFNGLBLENDEQUATIONSEPARATEEXTPROC)( modeRGB_, modeAlpha_ );
}

void glBlendFuncSeparateEXTWrapper(GLenum sfactorRGB_, GLenum dfactorRGB_, GLenum sfactorAlpha_, GLenum dfactorAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEEXTPROC, "glBlendFuncSeparateEXT");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEEXTPROC)( sfactorRGB_, dfactorRGB_, sfactorAlpha_, dfactorAlpha_ );
}

void glBlendEquationEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLBLENDEQUATIONEXTPROC, "glBlendEquationEXT");
  RESOLVED_PROC(PFNGLBLENDEQUATIONEXTPROC)( mode_ );
}

void glColorSubTableEXTWrapper(GLenum target_, GLsizei start_, GLsizei count_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCOLORSUBTABLEEXTPROC, "glColorSubTableEXT");
  RESOLVED_PROC(PFNGLCOLORSUBTABLEEXTPROC)( target_, start_, count_, format_, type_, data_ );
}

void glCopyColorSubTableEXTWrapper(GLenum target_, GLsizei start_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCOLORSUBTABLEEXTPROC, "glCopyColorSubTableEXT");
  RESOLVED_PROC(PFNGLCOPYCOLORSUBTABLEEXTPROC)( target_, start_, x_, y_, width_ );
}

void glLockArraysEXTWrapper(GLint first_, GLsizei count_)
{
  RESOLVE(PFNGLLOCKARRAYSEXTPROC, "glLockArraysEXT");
  RESOLVED_PROC(PFNGLLOCKARRAYSEXTPROC)( first_, count_ );
}

void glUnlockArraysEXTWrapper(void)
{
  RESOLVE(PFNGLUNLOCKARRAYSEXTPROC, "glUnlockArraysEXT");
  RESOLVED_PROC(PFNGLUNLOCKARRAYSEXTPROC)(  );
}

void glConvolutionFilter1DEXTWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLenum format_, GLenum type_, const void * image_)
{
  RESOLVE(PFNGLCONVOLUTIONFILTER1DEXTPROC, "glConvolutionFilter1DEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONFILTER1DEXTPROC)( target_, internalformat_, width_, format_, type_, image_ );
}

void glConvolutionFilter2DEXTWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * image_)
{
  RESOLVE(PFNGLCONVOLUTIONFILTER2DEXTPROC, "glConvolutionFilter2DEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONFILTER2DEXTPROC)( target_, internalformat_, width_, height_, format_, type_, image_ );
}

void glConvolutionParameterfEXTWrapper(GLenum target_, GLenum pname_, GLfloat params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERFEXTPROC, "glConvolutionParameterfEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERFEXTPROC)( target_, pname_, params_ );
}

void glConvolutionParameterfvEXTWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERFVEXTPROC, "glConvolutionParameterfvEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glConvolutionParameteriEXTWrapper(GLenum target_, GLenum pname_, GLint params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERIEXTPROC, "glConvolutionParameteriEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERIEXTPROC)( target_, pname_, params_ );
}

void glConvolutionParameterivEXTWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLCONVOLUTIONPARAMETERIVEXTPROC, "glConvolutionParameterivEXT");
  RESOLVED_PROC(PFNGLCONVOLUTIONPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glCopyConvolutionFilter1DEXTWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC, "glCopyConvolutionFilter1DEXT");
  RESOLVED_PROC(PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)( target_, internalformat_, x_, y_, width_ );
}

void glCopyConvolutionFilter2DEXTWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC, "glCopyConvolutionFilter2DEXT");
  RESOLVED_PROC(PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)( target_, internalformat_, x_, y_, width_, height_ );
}

void glGetConvolutionFilterEXTWrapper(GLenum target_, GLenum format_, GLenum type_, void * image_)
{
  RESOLVE(PFNGLGETCONVOLUTIONFILTEREXTPROC, "glGetConvolutionFilterEXT");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONFILTEREXTPROC)( target_, format_, type_, image_ );
}

void glGetConvolutionParameterfvEXTWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC, "glGetConvolutionParameterfvEXT");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glGetConvolutionParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC, "glGetConvolutionParameterivEXT");
  RESOLVED_PROC(PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glGetSeparableFilterEXTWrapper(GLenum target_, GLenum format_, GLenum type_, void * row_, void * column_, void * span_)
{
  RESOLVE(PFNGLGETSEPARABLEFILTEREXTPROC, "glGetSeparableFilterEXT");
  RESOLVED_PROC(PFNGLGETSEPARABLEFILTEREXTPROC)( target_, format_, type_, row_, column_, span_ );
}

void glSeparableFilter2DEXTWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * row_, const void * column_)
{
  RESOLVE(PFNGLSEPARABLEFILTER2DEXTPROC, "glSeparableFilter2DEXT");
  RESOLVED_PROC(PFNGLSEPARABLEFILTER2DEXTPROC)( target_, internalformat_, width_, height_, format_, type_, row_, column_ );
}

void glTangent3bEXTWrapper(GLbyte tx_, GLbyte ty_, GLbyte tz_)
{
  RESOLVE(PFNGLTANGENT3BEXTPROC, "glTangent3bEXT");
  RESOLVED_PROC(PFNGLTANGENT3BEXTPROC)( tx_, ty_, tz_ );
}

void glTangent3bvEXTWrapper(const GLbyte* v_)
{
  RESOLVE(PFNGLTANGENT3BVEXTPROC, "glTangent3bvEXT");
  RESOLVED_PROC(PFNGLTANGENT3BVEXTPROC)( v_ );
}

void glTangent3dEXTWrapper(GLdouble tx_, GLdouble ty_, GLdouble tz_)
{
  RESOLVE(PFNGLTANGENT3DEXTPROC, "glTangent3dEXT");
  RESOLVED_PROC(PFNGLTANGENT3DEXTPROC)( tx_, ty_, tz_ );
}

void glTangent3dvEXTWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLTANGENT3DVEXTPROC, "glTangent3dvEXT");
  RESOLVED_PROC(PFNGLTANGENT3DVEXTPROC)( v_ );
}

void glTangent3fEXTWrapper(GLfloat tx_, GLfloat ty_, GLfloat tz_)
{
  RESOLVE(PFNGLTANGENT3FEXTPROC, "glTangent3fEXT");
  RESOLVED_PROC(PFNGLTANGENT3FEXTPROC)( tx_, ty_, tz_ );
}

void glTangent3fvEXTWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLTANGENT3FVEXTPROC, "glTangent3fvEXT");
  RESOLVED_PROC(PFNGLTANGENT3FVEXTPROC)( v_ );
}

void glTangent3iEXTWrapper(GLint tx_, GLint ty_, GLint tz_)
{
  RESOLVE(PFNGLTANGENT3IEXTPROC, "glTangent3iEXT");
  RESOLVED_PROC(PFNGLTANGENT3IEXTPROC)( tx_, ty_, tz_ );
}

void glTangent3ivEXTWrapper(const GLint* v_)
{
  RESOLVE(PFNGLTANGENT3IVEXTPROC, "glTangent3ivEXT");
  RESOLVED_PROC(PFNGLTANGENT3IVEXTPROC)( v_ );
}

void glTangent3sEXTWrapper(GLshort tx_, GLshort ty_, GLshort tz_)
{
  RESOLVE(PFNGLTANGENT3SEXTPROC, "glTangent3sEXT");
  RESOLVED_PROC(PFNGLTANGENT3SEXTPROC)( tx_, ty_, tz_ );
}

void glTangent3svEXTWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLTANGENT3SVEXTPROC, "glTangent3svEXT");
  RESOLVED_PROC(PFNGLTANGENT3SVEXTPROC)( v_ );
}

void glBinormal3bEXTWrapper(GLbyte bx_, GLbyte by_, GLbyte bz_)
{
  RESOLVE(PFNGLBINORMAL3BEXTPROC, "glBinormal3bEXT");
  RESOLVED_PROC(PFNGLBINORMAL3BEXTPROC)( bx_, by_, bz_ );
}

void glBinormal3bvEXTWrapper(const GLbyte* v_)
{
  RESOLVE(PFNGLBINORMAL3BVEXTPROC, "glBinormal3bvEXT");
  RESOLVED_PROC(PFNGLBINORMAL3BVEXTPROC)( v_ );
}

void glBinormal3dEXTWrapper(GLdouble bx_, GLdouble by_, GLdouble bz_)
{
  RESOLVE(PFNGLBINORMAL3DEXTPROC, "glBinormal3dEXT");
  RESOLVED_PROC(PFNGLBINORMAL3DEXTPROC)( bx_, by_, bz_ );
}

void glBinormal3dvEXTWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLBINORMAL3DVEXTPROC, "glBinormal3dvEXT");
  RESOLVED_PROC(PFNGLBINORMAL3DVEXTPROC)( v_ );
}

void glBinormal3fEXTWrapper(GLfloat bx_, GLfloat by_, GLfloat bz_)
{
  RESOLVE(PFNGLBINORMAL3FEXTPROC, "glBinormal3fEXT");
  RESOLVED_PROC(PFNGLBINORMAL3FEXTPROC)( bx_, by_, bz_ );
}

void glBinormal3fvEXTWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLBINORMAL3FVEXTPROC, "glBinormal3fvEXT");
  RESOLVED_PROC(PFNGLBINORMAL3FVEXTPROC)( v_ );
}

void glBinormal3iEXTWrapper(GLint bx_, GLint by_, GLint bz_)
{
  RESOLVE(PFNGLBINORMAL3IEXTPROC, "glBinormal3iEXT");
  RESOLVED_PROC(PFNGLBINORMAL3IEXTPROC)( bx_, by_, bz_ );
}

void glBinormal3ivEXTWrapper(const GLint* v_)
{
  RESOLVE(PFNGLBINORMAL3IVEXTPROC, "glBinormal3ivEXT");
  RESOLVED_PROC(PFNGLBINORMAL3IVEXTPROC)( v_ );
}

void glBinormal3sEXTWrapper(GLshort bx_, GLshort by_, GLshort bz_)
{
  RESOLVE(PFNGLBINORMAL3SEXTPROC, "glBinormal3sEXT");
  RESOLVED_PROC(PFNGLBINORMAL3SEXTPROC)( bx_, by_, bz_ );
}

void glBinormal3svEXTWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLBINORMAL3SVEXTPROC, "glBinormal3svEXT");
  RESOLVED_PROC(PFNGLBINORMAL3SVEXTPROC)( v_ );
}

void glTangentPointerEXTWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLTANGENTPOINTEREXTPROC, "glTangentPointerEXT");
  RESOLVED_PROC(PFNGLTANGENTPOINTEREXTPROC)( type_, stride_, pointer_ );
}

void glBinormalPointerEXTWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLBINORMALPOINTEREXTPROC, "glBinormalPointerEXT");
  RESOLVED_PROC(PFNGLBINORMALPOINTEREXTPROC)( type_, stride_, pointer_ );
}

void glCopyTexImage1DEXTWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLint border_)
{
  RESOLVE(PFNGLCOPYTEXIMAGE1DEXTPROC, "glCopyTexImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXIMAGE1DEXTPROC)( target_, level_, internalformat_, x_, y_, width_, border_ );
}

void glCopyTexImage2DEXTWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLint border_)
{
  RESOLVE(PFNGLCOPYTEXIMAGE2DEXTPROC, "glCopyTexImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXIMAGE2DEXTPROC)( target_, level_, internalformat_, x_, y_, width_, height_, border_ );
}

void glCopyTexSubImage1DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYTEXSUBIMAGE1DEXTPROC, "glCopyTexSubImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXSUBIMAGE1DEXTPROC)( target_, level_, xoffset_, x_, y_, width_ );
}

void glCopyTexSubImage2DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXSUBIMAGE2DEXTPROC, "glCopyTexSubImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXSUBIMAGE2DEXTPROC)( target_, level_, xoffset_, yoffset_, x_, y_, width_, height_ );
}

void glCopyTexSubImage3DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXSUBIMAGE3DEXTPROC, "glCopyTexSubImage3DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXSUBIMAGE3DEXTPROC)( target_, level_, xoffset_, yoffset_, zoffset_, x_, y_, width_, height_ );
}

void glCullParameterdvEXTWrapper(GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLCULLPARAMETERDVEXTPROC, "glCullParameterdvEXT");
  RESOLVED_PROC(PFNGLCULLPARAMETERDVEXTPROC)( pname_, params_ );
}

void glCullParameterfvEXTWrapper(GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLCULLPARAMETERFVEXTPROC, "glCullParameterfvEXT");
  RESOLVED_PROC(PFNGLCULLPARAMETERFVEXTPROC)( pname_, params_ );
}

void glLabelObjectEXTWrapper(GLenum type_, GLuint object_, GLsizei length_, const GLchar* label_)
{
  RESOLVE(PFNGLLABELOBJECTEXTPROC, "glLabelObjectEXT");
  RESOLVED_PROC(PFNGLLABELOBJECTEXTPROC)( type_, object_, length_, label_ );
}

void glGetObjectLabelEXTWrapper(GLenum type_, GLuint object_, GLsizei bufSize_, GLsizei* length_, GLchar* label_)
{
  RESOLVE(PFNGLGETOBJECTLABELEXTPROC, "glGetObjectLabelEXT");
  RESOLVED_PROC(PFNGLGETOBJECTLABELEXTPROC)( type_, object_, bufSize_, length_, label_ );
}

void glInsertEventMarkerEXTWrapper(GLsizei length_, const GLchar* marker_)
{
  RESOLVE(PFNGLINSERTEVENTMARKEREXTPROC, "glInsertEventMarkerEXT");
  RESOLVED_PROC(PFNGLINSERTEVENTMARKEREXTPROC)( length_, marker_ );
}

void glPushGroupMarkerEXTWrapper(GLsizei length_, const GLchar* marker_)
{
  RESOLVE(PFNGLPUSHGROUPMARKEREXTPROC, "glPushGroupMarkerEXT");
  RESOLVED_PROC(PFNGLPUSHGROUPMARKEREXTPROC)( length_, marker_ );
}

void glPopGroupMarkerEXTWrapper(void)
{
  RESOLVE(PFNGLPOPGROUPMARKEREXTPROC, "glPopGroupMarkerEXT");
  RESOLVED_PROC(PFNGLPOPGROUPMARKEREXTPROC)(  );
}

void glDepthBoundsEXTWrapper(GLclampd zmin_, GLclampd zmax_)
{
  RESOLVE(PFNGLDEPTHBOUNDSEXTPROC, "glDepthBoundsEXT");
  RESOLVED_PROC(PFNGLDEPTHBOUNDSEXTPROC)( zmin_, zmax_ );
}

void glMatrixLoadfEXTWrapper(GLenum mode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXLOADFEXTPROC, "glMatrixLoadfEXT");
  RESOLVED_PROC(PFNGLMATRIXLOADFEXTPROC)( mode_, m_ );
}

void glMatrixLoaddEXTWrapper(GLenum mode_, const GLdouble* m_)
{
  RESOLVE(PFNGLMATRIXLOADDEXTPROC, "glMatrixLoaddEXT");
  RESOLVED_PROC(PFNGLMATRIXLOADDEXTPROC)( mode_, m_ );
}

void glMatrixMultfEXTWrapper(GLenum mode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXMULTFEXTPROC, "glMatrixMultfEXT");
  RESOLVED_PROC(PFNGLMATRIXMULTFEXTPROC)( mode_, m_ );
}

void glMatrixMultdEXTWrapper(GLenum mode_, const GLdouble* m_)
{
  RESOLVE(PFNGLMATRIXMULTDEXTPROC, "glMatrixMultdEXT");
  RESOLVED_PROC(PFNGLMATRIXMULTDEXTPROC)( mode_, m_ );
}

void glMatrixLoadIdentityEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLMATRIXLOADIDENTITYEXTPROC, "glMatrixLoadIdentityEXT");
  RESOLVED_PROC(PFNGLMATRIXLOADIDENTITYEXTPROC)( mode_ );
}

void glMatrixRotatefEXTWrapper(GLenum mode_, GLfloat angle_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLMATRIXROTATEFEXTPROC, "glMatrixRotatefEXT");
  RESOLVED_PROC(PFNGLMATRIXROTATEFEXTPROC)( mode_, angle_, x_, y_, z_ );
}

void glMatrixRotatedEXTWrapper(GLenum mode_, GLdouble angle_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLMATRIXROTATEDEXTPROC, "glMatrixRotatedEXT");
  RESOLVED_PROC(PFNGLMATRIXROTATEDEXTPROC)( mode_, angle_, x_, y_, z_ );
}

void glMatrixScalefEXTWrapper(GLenum mode_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLMATRIXSCALEFEXTPROC, "glMatrixScalefEXT");
  RESOLVED_PROC(PFNGLMATRIXSCALEFEXTPROC)( mode_, x_, y_, z_ );
}

void glMatrixScaledEXTWrapper(GLenum mode_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLMATRIXSCALEDEXTPROC, "glMatrixScaledEXT");
  RESOLVED_PROC(PFNGLMATRIXSCALEDEXTPROC)( mode_, x_, y_, z_ );
}

void glMatrixTranslatefEXTWrapper(GLenum mode_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLMATRIXTRANSLATEFEXTPROC, "glMatrixTranslatefEXT");
  RESOLVED_PROC(PFNGLMATRIXTRANSLATEFEXTPROC)( mode_, x_, y_, z_ );
}

void glMatrixTranslatedEXTWrapper(GLenum mode_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLMATRIXTRANSLATEDEXTPROC, "glMatrixTranslatedEXT");
  RESOLVED_PROC(PFNGLMATRIXTRANSLATEDEXTPROC)( mode_, x_, y_, z_ );
}

void glMatrixFrustumEXTWrapper(GLenum mode_, GLdouble left_, GLdouble right_, GLdouble bottom_, GLdouble top_, GLdouble zNear_, GLdouble zFar_)
{
  RESOLVE(PFNGLMATRIXFRUSTUMEXTPROC, "glMatrixFrustumEXT");
  RESOLVED_PROC(PFNGLMATRIXFRUSTUMEXTPROC)( mode_, left_, right_, bottom_, top_, zNear_, zFar_ );
}

void glMatrixOrthoEXTWrapper(GLenum mode_, GLdouble left_, GLdouble right_, GLdouble bottom_, GLdouble top_, GLdouble zNear_, GLdouble zFar_)
{
  RESOLVE(PFNGLMATRIXORTHOEXTPROC, "glMatrixOrthoEXT");
  RESOLVED_PROC(PFNGLMATRIXORTHOEXTPROC)( mode_, left_, right_, bottom_, top_, zNear_, zFar_ );
}

void glMatrixPopEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLMATRIXPOPEXTPROC, "glMatrixPopEXT");
  RESOLVED_PROC(PFNGLMATRIXPOPEXTPROC)( mode_ );
}

void glMatrixPushEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLMATRIXPUSHEXTPROC, "glMatrixPushEXT");
  RESOLVED_PROC(PFNGLMATRIXPUSHEXTPROC)( mode_ );
}

void glClientAttribDefaultEXTWrapper(GLbitfield mask_)
{
  RESOLVE(PFNGLCLIENTATTRIBDEFAULTEXTPROC, "glClientAttribDefaultEXT");
  RESOLVED_PROC(PFNGLCLIENTATTRIBDEFAULTEXTPROC)( mask_ );
}

void glPushClientAttribDefaultEXTWrapper(GLbitfield mask_)
{
  RESOLVE(PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC, "glPushClientAttribDefaultEXT");
  RESOLVED_PROC(PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)( mask_ );
}

void glTextureParameterfEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERFEXTPROC, "glTextureParameterfEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERFEXTPROC)( texture_, target_, pname_, param_ );
}

void glTextureParameterfvEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERFVEXTPROC, "glTextureParameterfvEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERFVEXTPROC)( texture_, target_, pname_, params_ );
}

void glTextureParameteriEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIEXTPROC, "glTextureParameteriEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIEXTPROC)( texture_, target_, pname_, param_ );
}

void glTextureParameterivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIVEXTPROC, "glTextureParameterivEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glTextureImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTUREIMAGE1DEXTPROC, "glTextureImage1DEXT");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE1DEXTPROC)( texture_, target_, level_, internalformat_, width_, border_, format_, type_, pixels_ );
}

void glTextureImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTUREIMAGE2DEXTPROC, "glTextureImage2DEXT");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE2DEXTPROC)( texture_, target_, level_, internalformat_, width_, height_, border_, format_, type_, pixels_ );
}

void glTextureSubImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE1DEXTPROC, "glTextureSubImage1DEXT");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE1DEXTPROC)( texture_, target_, level_, xoffset_, width_, format_, type_, pixels_ );
}

void glTextureSubImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE2DEXTPROC, "glTextureSubImage2DEXT");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE2DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, width_, height_, format_, type_, pixels_ );
}

void glCopyTextureImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLint border_)
{
  RESOLVE(PFNGLCOPYTEXTUREIMAGE1DEXTPROC, "glCopyTextureImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXTUREIMAGE1DEXTPROC)( texture_, target_, level_, internalformat_, x_, y_, width_, border_ );
}

void glCopyTextureImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLint border_)
{
  RESOLVE(PFNGLCOPYTEXTUREIMAGE2DEXTPROC, "glCopyTextureImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXTUREIMAGE2DEXTPROC)( texture_, target_, level_, internalformat_, x_, y_, width_, height_, border_ );
}

void glCopyTextureSubImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC, "glCopyTextureSubImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)( texture_, target_, level_, xoffset_, x_, y_, width_ );
}

void glCopyTextureSubImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC, "glCopyTextureSubImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, x_, y_, width_, height_ );
}

void glGetTextureImageEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum format_, GLenum type_, void * pixels_)
{
  RESOLVE(PFNGLGETTEXTUREIMAGEEXTPROC, "glGetTextureImageEXT");
  RESOLVED_PROC(PFNGLGETTEXTUREIMAGEEXTPROC)( texture_, target_, level_, format_, type_, pixels_ );
}

void glGetTextureParameterfvEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERFVEXTPROC, "glGetTextureParameterfvEXT");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERFVEXTPROC)( texture_, target_, pname_, params_ );
}

void glGetTextureParameterivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIVEXTPROC, "glGetTextureParameterivEXT");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glGetTextureLevelParameterfvEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC, "glGetTextureLevelParameterfvEXT");
  RESOLVED_PROC(PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)( texture_, target_, level_, pname_, params_ );
}

void glGetTextureLevelParameterivEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC, "glGetTextureLevelParameterivEXT");
  RESOLVED_PROC(PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)( texture_, target_, level_, pname_, params_ );
}

void glTextureImage3DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTUREIMAGE3DEXTPROC, "glTextureImage3DEXT");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE3DEXTPROC)( texture_, target_, level_, internalformat_, width_, height_, depth_, border_, format_, type_, pixels_ );
}

void glTextureSubImage3DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXTURESUBIMAGE3DEXTPROC, "glTextureSubImage3DEXT");
  RESOLVED_PROC(PFNGLTEXTURESUBIMAGE3DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, pixels_ );
}

void glCopyTextureSubImage3DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC, "glCopyTextureSubImage3DEXT");
  RESOLVED_PROC(PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, zoffset_, x_, y_, width_, height_ );
}

void glBindMultiTextureEXTWrapper(GLenum texunit_, GLenum target_, GLuint texture_)
{
  RESOLVE(PFNGLBINDMULTITEXTUREEXTPROC, "glBindMultiTextureEXT");
  RESOLVED_PROC(PFNGLBINDMULTITEXTUREEXTPROC)( texunit_, target_, texture_ );
}

void glMultiTexCoordPointerEXTWrapper(GLenum texunit_, GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLMULTITEXCOORDPOINTEREXTPROC, "glMultiTexCoordPointerEXT");
  RESOLVED_PROC(PFNGLMULTITEXCOORDPOINTEREXTPROC)( texunit_, size_, type_, stride_, pointer_ );
}

void glMultiTexEnvfEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLMULTITEXENVFEXTPROC, "glMultiTexEnvfEXT");
  RESOLVED_PROC(PFNGLMULTITEXENVFEXTPROC)( texunit_, target_, pname_, param_ );
}

void glMultiTexEnvfvEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLMULTITEXENVFVEXTPROC, "glMultiTexEnvfvEXT");
  RESOLVED_PROC(PFNGLMULTITEXENVFVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glMultiTexEnviEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLMULTITEXENVIEXTPROC, "glMultiTexEnviEXT");
  RESOLVED_PROC(PFNGLMULTITEXENVIEXTPROC)( texunit_, target_, pname_, param_ );
}

void glMultiTexEnvivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLMULTITEXENVIVEXTPROC, "glMultiTexEnvivEXT");
  RESOLVED_PROC(PFNGLMULTITEXENVIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glMultiTexGendEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLdouble param_)
{
  RESOLVE(PFNGLMULTITEXGENDEXTPROC, "glMultiTexGendEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENDEXTPROC)( texunit_, coord_, pname_, param_ );
}

void glMultiTexGendvEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, const GLdouble* params_)
{
  RESOLVE(PFNGLMULTITEXGENDVEXTPROC, "glMultiTexGendvEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENDVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glMultiTexGenfEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLMULTITEXGENFEXTPROC, "glMultiTexGenfEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENFEXTPROC)( texunit_, coord_, pname_, param_ );
}

void glMultiTexGenfvEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLMULTITEXGENFVEXTPROC, "glMultiTexGenfvEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENFVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glMultiTexGeniEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLMULTITEXGENIEXTPROC, "glMultiTexGeniEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENIEXTPROC)( texunit_, coord_, pname_, param_ );
}

void glMultiTexGenivEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLMULTITEXGENIVEXTPROC, "glMultiTexGenivEXT");
  RESOLVED_PROC(PFNGLMULTITEXGENIVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glGetMultiTexEnvfvEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMULTITEXENVFVEXTPROC, "glGetMultiTexEnvfvEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXENVFVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexEnvivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMULTITEXENVIVEXTPROC, "glGetMultiTexEnvivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXENVIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexGendvEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETMULTITEXGENDVEXTPROC, "glGetMultiTexGendvEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXGENDVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glGetMultiTexGenfvEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMULTITEXGENFVEXTPROC, "glGetMultiTexGenfvEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXGENFVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glGetMultiTexGenivEXTWrapper(GLenum texunit_, GLenum coord_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMULTITEXGENIVEXTPROC, "glGetMultiTexGenivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXGENIVEXTPROC)( texunit_, coord_, pname_, params_ );
}

void glMultiTexParameteriEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERIEXTPROC, "glMultiTexParameteriEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERIEXTPROC)( texunit_, target_, pname_, param_ );
}

void glMultiTexParameterivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERIVEXTPROC, "glMultiTexParameterivEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glMultiTexParameterfEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERFEXTPROC, "glMultiTexParameterfEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERFEXTPROC)( texunit_, target_, pname_, param_ );
}

void glMultiTexParameterfvEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERFVEXTPROC, "glMultiTexParameterfvEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERFVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glMultiTexImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXIMAGE1DEXTPROC, "glMultiTexImage1DEXT");
  RESOLVED_PROC(PFNGLMULTITEXIMAGE1DEXTPROC)( texunit_, target_, level_, internalformat_, width_, border_, format_, type_, pixels_ );
}

void glMultiTexImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXIMAGE2DEXTPROC, "glMultiTexImage2DEXT");
  RESOLVED_PROC(PFNGLMULTITEXIMAGE2DEXTPROC)( texunit_, target_, level_, internalformat_, width_, height_, border_, format_, type_, pixels_ );
}

void glMultiTexSubImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXSUBIMAGE1DEXTPROC, "glMultiTexSubImage1DEXT");
  RESOLVED_PROC(PFNGLMULTITEXSUBIMAGE1DEXTPROC)( texunit_, target_, level_, xoffset_, width_, format_, type_, pixels_ );
}

void glMultiTexSubImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXSUBIMAGE2DEXTPROC, "glMultiTexSubImage2DEXT");
  RESOLVED_PROC(PFNGLMULTITEXSUBIMAGE2DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, width_, height_, format_, type_, pixels_ );
}

void glCopyMultiTexImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLint border_)
{
  RESOLVE(PFNGLCOPYMULTITEXIMAGE1DEXTPROC, "glCopyMultiTexImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYMULTITEXIMAGE1DEXTPROC)( texunit_, target_, level_, internalformat_, x_, y_, width_, border_ );
}

void glCopyMultiTexImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_, GLsizei height_, GLint border_)
{
  RESOLVE(PFNGLCOPYMULTITEXIMAGE2DEXTPROC, "glCopyMultiTexImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYMULTITEXIMAGE2DEXTPROC)( texunit_, target_, level_, internalformat_, x_, y_, width_, height_, border_ );
}

void glCopyMultiTexSubImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC, "glCopyMultiTexSubImage1DEXT");
  RESOLVED_PROC(PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)( texunit_, target_, level_, xoffset_, x_, y_, width_ );
}

void glCopyMultiTexSubImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC, "glCopyMultiTexSubImage2DEXT");
  RESOLVED_PROC(PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, x_, y_, width_, height_ );
}

void glGetMultiTexImageEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum format_, GLenum type_, void * pixels_)
{
  RESOLVE(PFNGLGETMULTITEXIMAGEEXTPROC, "glGetMultiTexImageEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXIMAGEEXTPROC)( texunit_, target_, level_, format_, type_, pixels_ );
}

void glGetMultiTexParameterfvEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMULTITEXPARAMETERFVEXTPROC, "glGetMultiTexParameterfvEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXPARAMETERFVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexParameterivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMULTITEXPARAMETERIVEXTPROC, "glGetMultiTexParameterivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXPARAMETERIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexLevelParameterfvEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC, "glGetMultiTexLevelParameterfvEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)( texunit_, target_, level_, pname_, params_ );
}

void glGetMultiTexLevelParameterivEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC, "glGetMultiTexLevelParameterivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)( texunit_, target_, level_, pname_, params_ );
}

void glMultiTexImage3DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXIMAGE3DEXTPROC, "glMultiTexImage3DEXT");
  RESOLVED_PROC(PFNGLMULTITEXIMAGE3DEXTPROC)( texunit_, target_, level_, internalformat_, width_, height_, depth_, border_, format_, type_, pixels_ );
}

void glMultiTexSubImage3DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLMULTITEXSUBIMAGE3DEXTPROC, "glMultiTexSubImage3DEXT");
  RESOLVED_PROC(PFNGLMULTITEXSUBIMAGE3DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, pixels_ );
}

void glCopyMultiTexSubImage3DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint x_, GLint y_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC, "glCopyMultiTexSubImage3DEXT");
  RESOLVED_PROC(PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, zoffset_, x_, y_, width_, height_ );
}

void glEnableClientStateIndexedEXTWrapper(GLenum array_, GLuint index_)
{
  RESOLVE(PFNGLENABLECLIENTSTATEINDEXEDEXTPROC, "glEnableClientStateIndexedEXT");
  RESOLVED_PROC(PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)( array_, index_ );
}

void glDisableClientStateIndexedEXTWrapper(GLenum array_, GLuint index_)
{
  RESOLVE(PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC, "glDisableClientStateIndexedEXT");
  RESOLVED_PROC(PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)( array_, index_ );
}

void glGetFloatIndexedvEXTWrapper(GLenum target_, GLuint index_, GLfloat* data_)
{
  RESOLVE(PFNGLGETFLOATINDEXEDVEXTPROC, "glGetFloatIndexedvEXT");
  RESOLVED_PROC(PFNGLGETFLOATINDEXEDVEXTPROC)( target_, index_, data_ );
}

void glGetDoubleIndexedvEXTWrapper(GLenum target_, GLuint index_, GLdouble* data_)
{
  RESOLVE(PFNGLGETDOUBLEINDEXEDVEXTPROC, "glGetDoubleIndexedvEXT");
  RESOLVED_PROC(PFNGLGETDOUBLEINDEXEDVEXTPROC)( target_, index_, data_ );
}

void glGetPointerIndexedvEXTWrapper(GLenum target_, GLuint index_, void ** data_)
{
  RESOLVE(PFNGLGETPOINTERINDEXEDVEXTPROC, "glGetPointerIndexedvEXT");
  RESOLVED_PROC(PFNGLGETPOINTERINDEXEDVEXTPROC)( target_, index_, data_ );
}

void glEnableIndexedEXTWrapper(GLenum target_, GLuint index_)
{
  RESOLVE(PFNGLENABLEINDEXEDEXTPROC, "glEnableIndexedEXT");
  RESOLVED_PROC(PFNGLENABLEINDEXEDEXTPROC)( target_, index_ );
}

void glDisableIndexedEXTWrapper(GLenum target_, GLuint index_)
{
  RESOLVE(PFNGLDISABLEINDEXEDEXTPROC, "glDisableIndexedEXT");
  RESOLVED_PROC(PFNGLDISABLEINDEXEDEXTPROC)( target_, index_ );
}

GLboolean glIsEnabledIndexedEXTWrapper(GLenum target_, GLuint index_)
{
  RESOLVE_RET(PFNGLISENABLEDINDEXEDEXTPROC, "glIsEnabledIndexedEXT", FALSE);
  return RESOLVED_PROC(PFNGLISENABLEDINDEXEDEXTPROC)(target_, index_ );
}

void glGetIntegerIndexedvEXTWrapper(GLenum target_, GLuint index_, GLint* data_)
{
  RESOLVE(PFNGLGETINTEGERINDEXEDVEXTPROC, "glGetIntegerIndexedvEXT");
  RESOLVED_PROC(PFNGLGETINTEGERINDEXEDVEXTPROC)( target_, index_, data_ );
}

void glGetBooleanIndexedvEXTWrapper(GLenum target_, GLuint index_, GLboolean* data_)
{
  RESOLVE(PFNGLGETBOOLEANINDEXEDVEXTPROC, "glGetBooleanIndexedvEXT");
  RESOLVED_PROC(PFNGLGETBOOLEANINDEXEDVEXTPROC)( target_, index_, data_ );
}

void glCompressedTextureImage3DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC, "glCompressedTextureImage3DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)( texture_, target_, level_, internalformat_, width_, height_, depth_, border_, imageSize_, bits_ );
}

void glCompressedTextureImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC, "glCompressedTextureImage2DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)( texture_, target_, level_, internalformat_, width_, height_, border_, imageSize_, bits_ );
}

void glCompressedTextureImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC, "glCompressedTextureImage1DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)( texture_, target_, level_, internalformat_, width_, border_, imageSize_, bits_ );
}

void glCompressedTextureSubImage3DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC, "glCompressedTextureSubImage3DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, imageSize_, bits_ );
}

void glCompressedTextureSubImage2DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC, "glCompressedTextureSubImage2DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)( texture_, target_, level_, xoffset_, yoffset_, width_, height_, format_, imageSize_, bits_ );
}

void glCompressedTextureSubImage1DEXTWrapper(GLuint texture_, GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC, "glCompressedTextureSubImage1DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)( texture_, target_, level_, xoffset_, width_, format_, imageSize_, bits_ );
}

void glGetCompressedTextureImageEXTWrapper(GLuint texture_, GLenum target_, GLint lod_, void * img_)
{
  RESOLVE(PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC, "glGetCompressedTextureImageEXT");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)( texture_, target_, lod_, img_ );
}

void glCompressedMultiTexImage3DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC, "glCompressedMultiTexImage3DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)( texunit_, target_, level_, internalformat_, width_, height_, depth_, border_, imageSize_, bits_ );
}

void glCompressedMultiTexImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC, "glCompressedMultiTexImage2DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)( texunit_, target_, level_, internalformat_, width_, height_, border_, imageSize_, bits_ );
}

void glCompressedMultiTexImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLint border_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC, "glCompressedMultiTexImage1DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)( texunit_, target_, level_, internalformat_, width_, border_, imageSize_, bits_ );
}

void glCompressedMultiTexSubImage3DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC, "glCompressedMultiTexSubImage3DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, imageSize_, bits_ );
}

void glCompressedMultiTexSubImage2DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC, "glCompressedMultiTexSubImage2DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)( texunit_, target_, level_, xoffset_, yoffset_, width_, height_, format_, imageSize_, bits_ );
}

void glCompressedMultiTexSubImage1DEXTWrapper(GLenum texunit_, GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLsizei imageSize_, const void * bits_)
{
  RESOLVE(PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC, "glCompressedMultiTexSubImage1DEXT");
  RESOLVED_PROC(PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)( texunit_, target_, level_, xoffset_, width_, format_, imageSize_, bits_ );
}

void glGetCompressedMultiTexImageEXTWrapper(GLenum texunit_, GLenum target_, GLint lod_, void * img_)
{
  RESOLVE(PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC, "glGetCompressedMultiTexImageEXT");
  RESOLVED_PROC(PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)( texunit_, target_, lod_, img_ );
}

void glMatrixLoadTransposefEXTWrapper(GLenum mode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXLOADTRANSPOSEFEXTPROC, "glMatrixLoadTransposefEXT");
  RESOLVED_PROC(PFNGLMATRIXLOADTRANSPOSEFEXTPROC)( mode_, m_ );
}

void glMatrixLoadTransposedEXTWrapper(GLenum mode_, const GLdouble* m_)
{
  RESOLVE(PFNGLMATRIXLOADTRANSPOSEDEXTPROC, "glMatrixLoadTransposedEXT");
  RESOLVED_PROC(PFNGLMATRIXLOADTRANSPOSEDEXTPROC)( mode_, m_ );
}

void glMatrixMultTransposefEXTWrapper(GLenum mode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXMULTTRANSPOSEFEXTPROC, "glMatrixMultTransposefEXT");
  RESOLVED_PROC(PFNGLMATRIXMULTTRANSPOSEFEXTPROC)( mode_, m_ );
}

void glMatrixMultTransposedEXTWrapper(GLenum mode_, const GLdouble* m_)
{
  RESOLVE(PFNGLMATRIXMULTTRANSPOSEDEXTPROC, "glMatrixMultTransposedEXT");
  RESOLVED_PROC(PFNGLMATRIXMULTTRANSPOSEDEXTPROC)( mode_, m_ );
}

void glNamedBufferDataEXTWrapper(GLuint buffer_, GLsizeiptr size_, const void * data_, GLenum usage_)
{
  RESOLVE(PFNGLNAMEDBUFFERDATAEXTPROC, "glNamedBufferDataEXT");
  RESOLVED_PROC(PFNGLNAMEDBUFFERDATAEXTPROC)( buffer_, size_, data_, usage_ );
}

void glNamedBufferSubDataEXTWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, const void * data_)
{
  RESOLVE(PFNGLNAMEDBUFFERSUBDATAEXTPROC, "glNamedBufferSubDataEXT");
  RESOLVED_PROC(PFNGLNAMEDBUFFERSUBDATAEXTPROC)( buffer_, offset_, size_, data_ );
}

void * glMapNamedBufferEXTWrapper(GLuint buffer_, GLenum access_)
{
  RESOLVE_RET(PFNGLMAPNAMEDBUFFEREXTPROC, "glMapNamedBufferEXT", FALSE);
  return RESOLVED_PROC(PFNGLMAPNAMEDBUFFEREXTPROC)(buffer_, access_ );
}

GLboolean glUnmapNamedBufferEXTWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLUNMAPNAMEDBUFFEREXTPROC, "glUnmapNamedBufferEXT", FALSE);
  return RESOLVED_PROC(PFNGLUNMAPNAMEDBUFFEREXTPROC)(buffer_ );
}

void glGetNamedBufferParameterivEXTWrapper(GLuint buffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC, "glGetNamedBufferParameterivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)( buffer_, pname_, params_ );
}

void glGetNamedBufferPointervEXTWrapper(GLuint buffer_, GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPOINTERVEXTPROC, "glGetNamedBufferPointervEXT");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)( buffer_, pname_, params_ );
}

void glGetNamedBufferSubDataEXTWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr size_, void * data_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERSUBDATAEXTPROC, "glGetNamedBufferSubDataEXT");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)( buffer_, offset_, size_, data_ );
}

void glProgramUniform1fEXTWrapper(GLuint program_, GLint location_, GLfloat v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1FEXTPROC, "glProgramUniform1fEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1FEXTPROC)( program_, location_, v0_ );
}

void glProgramUniform2fEXTWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2FEXTPROC, "glProgramUniform2fEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2FEXTPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform3fEXTWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3FEXTPROC, "glProgramUniform3fEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3FEXTPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform4fEXTWrapper(GLuint program_, GLint location_, GLfloat v0_, GLfloat v1_, GLfloat v2_, GLfloat v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4FEXTPROC, "glProgramUniform4fEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4FEXTPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform1iEXTWrapper(GLuint program_, GLint location_, GLint v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1IEXTPROC, "glProgramUniform1iEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1IEXTPROC)( program_, location_, v0_ );
}

void glProgramUniform2iEXTWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2IEXTPROC, "glProgramUniform2iEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2IEXTPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform3iEXTWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_, GLint v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3IEXTPROC, "glProgramUniform3iEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3IEXTPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform4iEXTWrapper(GLuint program_, GLint location_, GLint v0_, GLint v1_, GLint v2_, GLint v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4IEXTPROC, "glProgramUniform4iEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4IEXTPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform1fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1FVEXTPROC, "glProgramUniform1fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1FVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2FVEXTPROC, "glProgramUniform2fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2FVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3FVEXTPROC, "glProgramUniform3fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3FVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4FVEXTPROC, "glProgramUniform4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4FVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform1ivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1IVEXTPROC, "glProgramUniform1ivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1IVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2ivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2IVEXTPROC, "glProgramUniform2ivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2IVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3ivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3IVEXTPROC, "glProgramUniform3ivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3IVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4ivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4IVEXTPROC, "glProgramUniform4ivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4IVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniformMatrix2fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC, "glProgramUniformMatrix2fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC, "glProgramUniformMatrix3fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC, "glProgramUniformMatrix4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x3fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC, "glProgramUniformMatrix2x3fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x2fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC, "glProgramUniformMatrix3x2fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x4fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC, "glProgramUniformMatrix2x4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x2fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC, "glProgramUniformMatrix4x2fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x4fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC, "glProgramUniformMatrix3x4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x3fvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLfloat* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC, "glProgramUniformMatrix4x3fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glTextureBufferEXTWrapper(GLuint texture_, GLenum target_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLTEXTUREBUFFEREXTPROC, "glTextureBufferEXT");
  RESOLVED_PROC(PFNGLTEXTUREBUFFEREXTPROC)( texture_, target_, internalformat_, buffer_ );
}

void glMultiTexBufferEXTWrapper(GLenum texunit_, GLenum target_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLMULTITEXBUFFEREXTPROC, "glMultiTexBufferEXT");
  RESOLVED_PROC(PFNGLMULTITEXBUFFEREXTPROC)( texunit_, target_, internalformat_, buffer_ );
}

void glTextureParameterIivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIIVEXTPROC, "glTextureParameterIivEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glTextureParameterIuivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, const GLuint* params_)
{
  RESOLVE(PFNGLTEXTUREPARAMETERIUIVEXTPROC, "glTextureParameterIuivEXT");
  RESOLVED_PROC(PFNGLTEXTUREPARAMETERIUIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glGetTextureParameterIivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIIVEXTPROC, "glGetTextureParameterIivEXT");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glGetTextureParameterIuivEXTWrapper(GLuint texture_, GLenum target_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETTEXTUREPARAMETERIUIVEXTPROC, "glGetTextureParameterIuivEXT");
  RESOLVED_PROC(PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)( texture_, target_, pname_, params_ );
}

void glMultiTexParameterIivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERIIVEXTPROC, "glMultiTexParameterIivEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERIIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glMultiTexParameterIuivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, const GLuint* params_)
{
  RESOLVE(PFNGLMULTITEXPARAMETERIUIVEXTPROC, "glMultiTexParameterIuivEXT");
  RESOLVED_PROC(PFNGLMULTITEXPARAMETERIUIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexParameterIivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMULTITEXPARAMETERIIVEXTPROC, "glGetMultiTexParameterIivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXPARAMETERIIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glGetMultiTexParameterIuivEXTWrapper(GLenum texunit_, GLenum target_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETMULTITEXPARAMETERIUIVEXTPROC, "glGetMultiTexParameterIuivEXT");
  RESOLVED_PROC(PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)( texunit_, target_, pname_, params_ );
}

void glProgramUniform1uiEXTWrapper(GLuint program_, GLint location_, GLuint v0_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UIEXTPROC, "glProgramUniform1uiEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UIEXTPROC)( program_, location_, v0_ );
}

void glProgramUniform2uiEXTWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UIEXTPROC, "glProgramUniform2uiEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UIEXTPROC)( program_, location_, v0_, v1_ );
}

void glProgramUniform3uiEXTWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_, GLuint v2_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UIEXTPROC, "glProgramUniform3uiEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UIEXTPROC)( program_, location_, v0_, v1_, v2_ );
}

void glProgramUniform4uiEXTWrapper(GLuint program_, GLint location_, GLuint v0_, GLuint v1_, GLuint v2_, GLuint v3_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UIEXTPROC, "glProgramUniform4uiEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UIEXTPROC)( program_, location_, v0_, v1_, v2_, v3_ );
}

void glProgramUniform1uivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1UIVEXTPROC, "glProgramUniform1uivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1UIVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2uivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2UIVEXTPROC, "glProgramUniform2uivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2UIVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3uivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3UIVEXTPROC, "glProgramUniform3uivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3UIVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4uivEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4UIVEXTPROC, "glProgramUniform4uivEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4UIVEXTPROC)( program_, location_, count_, value_ );
}

void glNamedProgramLocalParameters4fvEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLsizei count_, const GLfloat* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC, "glNamedProgramLocalParameters4fvEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)( program_, target_, index_, count_, params_ );
}

void glNamedProgramLocalParameterI4iEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC, "glNamedProgramLocalParameterI4iEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)( program_, target_, index_, x_, y_, z_, w_ );
}

void glNamedProgramLocalParameterI4ivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, const GLint* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC, "glNamedProgramLocalParameterI4ivEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)( program_, target_, index_, params_ );
}

void glNamedProgramLocalParametersI4ivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLsizei count_, const GLint* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC, "glNamedProgramLocalParametersI4ivEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)( program_, target_, index_, count_, params_ );
}

void glNamedProgramLocalParameterI4uiEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLuint x_, GLuint y_, GLuint z_, GLuint w_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC, "glNamedProgramLocalParameterI4uiEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)( program_, target_, index_, x_, y_, z_, w_ );
}

void glNamedProgramLocalParameterI4uivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, const GLuint* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC, "glNamedProgramLocalParameterI4uivEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)( program_, target_, index_, params_ );
}

void glNamedProgramLocalParametersI4uivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLsizei count_, const GLuint* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC, "glNamedProgramLocalParametersI4uivEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)( program_, target_, index_, count_, params_ );
}

void glGetNamedProgramLocalParameterIivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC, "glGetNamedProgramLocalParameterIivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)( program_, target_, index_, params_ );
}

void glGetNamedProgramLocalParameterIuivEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLuint* params_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC, "glGetNamedProgramLocalParameterIuivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)( program_, target_, index_, params_ );
}

void glEnableClientStateiEXTWrapper(GLenum array_, GLuint index_)
{
  RESOLVE(PFNGLENABLECLIENTSTATEIEXTPROC, "glEnableClientStateiEXT");
  RESOLVED_PROC(PFNGLENABLECLIENTSTATEIEXTPROC)( array_, index_ );
}

void glDisableClientStateiEXTWrapper(GLenum array_, GLuint index_)
{
  RESOLVE(PFNGLDISABLECLIENTSTATEIEXTPROC, "glDisableClientStateiEXT");
  RESOLVED_PROC(PFNGLDISABLECLIENTSTATEIEXTPROC)( array_, index_ );
}

void glGetFloati_vEXTWrapper(GLenum pname_, GLuint index_, GLfloat* params_)
{
  RESOLVE(PFNGLGETFLOATI_VEXTPROC, "glGetFloati_vEXT");
  RESOLVED_PROC(PFNGLGETFLOATI_VEXTPROC)( pname_, index_, params_ );
}

void glGetDoublei_vEXTWrapper(GLenum pname_, GLuint index_, GLdouble* params_)
{
  RESOLVE(PFNGLGETDOUBLEI_VEXTPROC, "glGetDoublei_vEXT");
  RESOLVED_PROC(PFNGLGETDOUBLEI_VEXTPROC)( pname_, index_, params_ );
}

void glGetPointeri_vEXTWrapper(GLenum pname_, GLuint index_, void ** params_)
{
  RESOLVE(PFNGLGETPOINTERI_VEXTPROC, "glGetPointeri_vEXT");
  RESOLVED_PROC(PFNGLGETPOINTERI_VEXTPROC)( pname_, index_, params_ );
}

void glNamedProgramStringEXTWrapper(GLuint program_, GLenum target_, GLenum format_, GLsizei len_, const void * string_)
{
  RESOLVE(PFNGLNAMEDPROGRAMSTRINGEXTPROC, "glNamedProgramStringEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMSTRINGEXTPROC)( program_, target_, format_, len_, string_ );
}

void glNamedProgramLocalParameter4dEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC, "glNamedProgramLocalParameter4dEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)( program_, target_, index_, x_, y_, z_, w_ );
}

void glNamedProgramLocalParameter4dvEXTWrapper(GLuint program_, GLenum target_, GLuint index_, const GLdouble* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC, "glNamedProgramLocalParameter4dvEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)( program_, target_, index_, params_ );
}

void glNamedProgramLocalParameter4fEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC, "glNamedProgramLocalParameter4fEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)( program_, target_, index_, x_, y_, z_, w_ );
}

void glNamedProgramLocalParameter4fvEXTWrapper(GLuint program_, GLenum target_, GLuint index_, const GLfloat* params_)
{
  RESOLVE(PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC, "glNamedProgramLocalParameter4fvEXT");
  RESOLVED_PROC(PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)( program_, target_, index_, params_ );
}

void glGetNamedProgramLocalParameterdvEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLdouble* params_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC, "glGetNamedProgramLocalParameterdvEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)( program_, target_, index_, params_ );
}

void glGetNamedProgramLocalParameterfvEXTWrapper(GLuint program_, GLenum target_, GLuint index_, GLfloat* params_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC, "glGetNamedProgramLocalParameterfvEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)( program_, target_, index_, params_ );
}

void glGetNamedProgramivEXTWrapper(GLuint program_, GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMIVEXTPROC, "glGetNamedProgramivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMIVEXTPROC)( program_, target_, pname_, params_ );
}

void glGetNamedProgramStringEXTWrapper(GLuint program_, GLenum target_, GLenum pname_, void * string_)
{
  RESOLVE(PFNGLGETNAMEDPROGRAMSTRINGEXTPROC, "glGetNamedProgramStringEXT");
  RESOLVED_PROC(PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)( program_, target_, pname_, string_ );
}

void glNamedRenderbufferStorageEXTWrapper(GLuint renderbuffer_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC, "glNamedRenderbufferStorageEXT");
  RESOLVED_PROC(PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)( renderbuffer_, internalformat_, width_, height_ );
}

void glGetNamedRenderbufferParameterivEXTWrapper(GLuint renderbuffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC, "glGetNamedRenderbufferParameterivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)( renderbuffer_, pname_, params_ );
}

void glNamedRenderbufferStorageMultisampleEXTWrapper(GLuint renderbuffer_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC, "glNamedRenderbufferStorageMultisampleEXT");
  RESOLVED_PROC(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)( renderbuffer_, samples_, internalformat_, width_, height_ );
}

void glNamedRenderbufferStorageMultisampleCoverageEXTWrapper(GLuint renderbuffer_, GLsizei coverageSamples_, GLsizei colorSamples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC, "glNamedRenderbufferStorageMultisampleCoverageEXT");
  RESOLVED_PROC(PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)( renderbuffer_, coverageSamples_, colorSamples_, internalformat_, width_, height_ );
}

GLenum glCheckNamedFramebufferStatusEXTWrapper(GLuint framebuffer_, GLenum target_)
{
  RESOLVE_RET(PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC, "glCheckNamedFramebufferStatusEXT", FALSE);
  return RESOLVED_PROC(PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)(framebuffer_, target_ );
}

void glNamedFramebufferTexture1DEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC, "glNamedFramebufferTexture1DEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)( framebuffer_, attachment_, textarget_, texture_, level_ );
}

void glNamedFramebufferTexture2DEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC, "glNamedFramebufferTexture2DEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)( framebuffer_, attachment_, textarget_, texture_, level_ );
}

void glNamedFramebufferTexture3DEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_, GLint zoffset_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC, "glNamedFramebufferTexture3DEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)( framebuffer_, attachment_, textarget_, texture_, level_, zoffset_ );
}

void glNamedFramebufferRenderbufferEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLenum renderbuffertarget_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC, "glNamedFramebufferRenderbufferEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)( framebuffer_, attachment_, renderbuffertarget_, renderbuffer_ );
}

void glGetNamedFramebufferAttachmentParameterivEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC, "glGetNamedFramebufferAttachmentParameterivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)( framebuffer_, attachment_, pname_, params_ );
}

void glGenerateTextureMipmapEXTWrapper(GLuint texture_, GLenum target_)
{
  RESOLVE(PFNGLGENERATETEXTUREMIPMAPEXTPROC, "glGenerateTextureMipmapEXT");
  RESOLVED_PROC(PFNGLGENERATETEXTUREMIPMAPEXTPROC)( texture_, target_ );
}

void glGenerateMultiTexMipmapEXTWrapper(GLenum texunit_, GLenum target_)
{
  RESOLVE(PFNGLGENERATEMULTITEXMIPMAPEXTPROC, "glGenerateMultiTexMipmapEXT");
  RESOLVED_PROC(PFNGLGENERATEMULTITEXMIPMAPEXTPROC)( texunit_, target_ );
}

void glFramebufferDrawBufferEXTWrapper(GLuint framebuffer_, GLenum mode_)
{
  RESOLVE(PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC, "glFramebufferDrawBufferEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)( framebuffer_, mode_ );
}

void glFramebufferDrawBuffersEXTWrapper(GLuint framebuffer_, GLsizei n_, const GLenum* bufs_)
{
  RESOLVE(PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC, "glFramebufferDrawBuffersEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)( framebuffer_, n_, bufs_ );
}

void glFramebufferReadBufferEXTWrapper(GLuint framebuffer_, GLenum mode_)
{
  RESOLVE(PFNGLFRAMEBUFFERREADBUFFEREXTPROC, "glFramebufferReadBufferEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERREADBUFFEREXTPROC)( framebuffer_, mode_ );
}

void glGetFramebufferParameterivEXTWrapper(GLuint framebuffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC, "glGetFramebufferParameterivEXT");
  RESOLVED_PROC(PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)( framebuffer_, pname_, params_ );
}

void glNamedCopyBufferSubDataEXTWrapper(GLuint readBuffer_, GLuint writeBuffer_, GLintptr readOffset_, GLintptr writeOffset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC, "glNamedCopyBufferSubDataEXT");
  RESOLVED_PROC(PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)( readBuffer_, writeBuffer_, readOffset_, writeOffset_, size_ );
}

void glNamedFramebufferTextureEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC, "glNamedFramebufferTextureEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)( framebuffer_, attachment_, texture_, level_ );
}

void glNamedFramebufferTextureLayerEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLuint texture_, GLint level_, GLint layer_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC, "glNamedFramebufferTextureLayerEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)( framebuffer_, attachment_, texture_, level_, layer_ );
}

void glNamedFramebufferTextureFaceEXTWrapper(GLuint framebuffer_, GLenum attachment_, GLuint texture_, GLint level_, GLenum face_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC, "glNamedFramebufferTextureFaceEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)( framebuffer_, attachment_, texture_, level_, face_ );
}

void glTextureRenderbufferEXTWrapper(GLuint texture_, GLenum target_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLTEXTURERENDERBUFFEREXTPROC, "glTextureRenderbufferEXT");
  RESOLVED_PROC(PFNGLTEXTURERENDERBUFFEREXTPROC)( texture_, target_, renderbuffer_ );
}

void glMultiTexRenderbufferEXTWrapper(GLenum texunit_, GLenum target_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLMULTITEXRENDERBUFFEREXTPROC, "glMultiTexRenderbufferEXT");
  RESOLVED_PROC(PFNGLMULTITEXRENDERBUFFEREXTPROC)( texunit_, target_, renderbuffer_ );
}

void glVertexArrayVertexOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC, "glVertexArrayVertexOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)( vaobj_, buffer_, size_, type_, stride_, offset_ );
}

void glVertexArrayColorOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYCOLOROFFSETEXTPROC, "glVertexArrayColorOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)( vaobj_, buffer_, size_, type_, stride_, offset_ );
}

void glVertexArrayEdgeFlagOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC, "glVertexArrayEdgeFlagOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)( vaobj_, buffer_, stride_, offset_ );
}

void glVertexArrayIndexOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYINDEXOFFSETEXTPROC, "glVertexArrayIndexOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)( vaobj_, buffer_, type_, stride_, offset_ );
}

void glVertexArrayNormalOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYNORMALOFFSETEXTPROC, "glVertexArrayNormalOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)( vaobj_, buffer_, type_, stride_, offset_ );
}

void glVertexArrayTexCoordOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC, "glVertexArrayTexCoordOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)( vaobj_, buffer_, size_, type_, stride_, offset_ );
}

void glVertexArrayMultiTexCoordOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLenum texunit_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC, "glVertexArrayMultiTexCoordOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)( vaobj_, buffer_, texunit_, size_, type_, stride_, offset_ );
}

void glVertexArrayFogCoordOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC, "glVertexArrayFogCoordOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)( vaobj_, buffer_, type_, stride_, offset_ );
}

void glVertexArraySecondaryColorOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC, "glVertexArraySecondaryColorOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)( vaobj_, buffer_, size_, type_, stride_, offset_ );
}

void glVertexArrayVertexAttribOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLuint index_, GLint size_, GLenum type_, GLboolean normalized_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC, "glVertexArrayVertexAttribOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)( vaobj_, buffer_, index_, size_, type_, normalized_, stride_, offset_ );
}

void glVertexArrayVertexAttribIOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLuint index_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC, "glVertexArrayVertexAttribIOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)( vaobj_, buffer_, index_, size_, type_, stride_, offset_ );
}

void glEnableVertexArrayEXTWrapper(GLuint vaobj_, GLenum array_)
{
  RESOLVE(PFNGLENABLEVERTEXARRAYEXTPROC, "glEnableVertexArrayEXT");
  RESOLVED_PROC(PFNGLENABLEVERTEXARRAYEXTPROC)( vaobj_, array_ );
}

void glDisableVertexArrayEXTWrapper(GLuint vaobj_, GLenum array_)
{
  RESOLVE(PFNGLDISABLEVERTEXARRAYEXTPROC, "glDisableVertexArrayEXT");
  RESOLVED_PROC(PFNGLDISABLEVERTEXARRAYEXTPROC)( vaobj_, array_ );
}

void glEnableVertexArrayAttribEXTWrapper(GLuint vaobj_, GLuint index_)
{
  RESOLVE(PFNGLENABLEVERTEXARRAYATTRIBEXTPROC, "glEnableVertexArrayAttribEXT");
  RESOLVED_PROC(PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)( vaobj_, index_ );
}

void glDisableVertexArrayAttribEXTWrapper(GLuint vaobj_, GLuint index_)
{
  RESOLVE(PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC, "glDisableVertexArrayAttribEXT");
  RESOLVED_PROC(PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)( vaobj_, index_ );
}

void glGetVertexArrayIntegervEXTWrapper(GLuint vaobj_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYINTEGERVEXTPROC, "glGetVertexArrayIntegervEXT");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYINTEGERVEXTPROC)( vaobj_, pname_, param_ );
}

void glGetVertexArrayPointervEXTWrapper(GLuint vaobj_, GLenum pname_, void ** param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYPOINTERVEXTPROC, "glGetVertexArrayPointervEXT");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYPOINTERVEXTPROC)( vaobj_, pname_, param_ );
}

void glGetVertexArrayIntegeri_vEXTWrapper(GLuint vaobj_, GLuint index_, GLenum pname_, GLint* param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC, "glGetVertexArrayIntegeri_vEXT");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)( vaobj_, index_, pname_, param_ );
}

void glGetVertexArrayPointeri_vEXTWrapper(GLuint vaobj_, GLuint index_, GLenum pname_, void ** param_)
{
  RESOLVE(PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC, "glGetVertexArrayPointeri_vEXT");
  RESOLVED_PROC(PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)( vaobj_, index_, pname_, param_ );
}

void * glMapNamedBufferRangeEXTWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr length_, GLbitfield access_)
{
  RESOLVE_RET(PFNGLMAPNAMEDBUFFERRANGEEXTPROC, "glMapNamedBufferRangeEXT", FALSE);
  return RESOLVED_PROC(PFNGLMAPNAMEDBUFFERRANGEEXTPROC)(buffer_, offset_, length_, access_ );
}

void glFlushMappedNamedBufferRangeEXTWrapper(GLuint buffer_, GLintptr offset_, GLsizeiptr length_)
{
  RESOLVE(PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC, "glFlushMappedNamedBufferRangeEXT");
  RESOLVED_PROC(PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)( buffer_, offset_, length_ );
}

void glNamedBufferStorageEXTWrapper(GLuint buffer_, GLsizeiptr size_, const void * data_, GLbitfield flags_)
{
  RESOLVE(PFNGLNAMEDBUFFERSTORAGEEXTPROC, "glNamedBufferStorageEXT");
  RESOLVED_PROC(PFNGLNAMEDBUFFERSTORAGEEXTPROC)( buffer_, size_, data_, flags_ );
}

void glClearNamedBufferDataEXTWrapper(GLuint buffer_, GLenum internalformat_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARNAMEDBUFFERDATAEXTPROC, "glClearNamedBufferDataEXT");
  RESOLVED_PROC(PFNGLCLEARNAMEDBUFFERDATAEXTPROC)( buffer_, internalformat_, format_, type_, data_ );
}

void glClearNamedBufferSubDataEXTWrapper(GLuint buffer_, GLenum internalformat_, GLsizeiptr offset_, GLsizeiptr size_, GLenum format_, GLenum type_, const void * data_)
{
  RESOLVE(PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC, "glClearNamedBufferSubDataEXT");
  RESOLVED_PROC(PFNGLCLEARNAMEDBUFFERSUBDATAEXTPROC)( buffer_, internalformat_, offset_, size_, format_, type_, data_ );
}

void glNamedFramebufferParameteriEXTWrapper(GLuint framebuffer_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC, "glNamedFramebufferParameteriEXT");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERPARAMETERIEXTPROC)( framebuffer_, pname_, param_ );
}

void glGetNamedFramebufferParameterivEXTWrapper(GLuint framebuffer_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC, "glGetNamedFramebufferParameterivEXT");
  RESOLVED_PROC(PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC)( framebuffer_, pname_, params_ );
}

void glProgramUniform1dEXTWrapper(GLuint program_, GLint location_, GLdouble x_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1DEXTPROC, "glProgramUniform1dEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1DEXTPROC)( program_, location_, x_ );
}

void glProgramUniform2dEXTWrapper(GLuint program_, GLint location_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2DEXTPROC, "glProgramUniform2dEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2DEXTPROC)( program_, location_, x_, y_ );
}

void glProgramUniform3dEXTWrapper(GLuint program_, GLint location_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3DEXTPROC, "glProgramUniform3dEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3DEXTPROC)( program_, location_, x_, y_, z_ );
}

void glProgramUniform4dEXTWrapper(GLuint program_, GLint location_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4DEXTPROC, "glProgramUniform4dEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4DEXTPROC)( program_, location_, x_, y_, z_, w_ );
}

void glProgramUniform1dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM1DVEXTPROC, "glProgramUniform1dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM1DVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform2dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM2DVEXTPROC, "glProgramUniform2dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM2DVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform3dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM3DVEXTPROC, "glProgramUniform3dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM3DVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniform4dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORM4DVEXTPROC, "glProgramUniform4dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORM4DVEXTPROC)( program_, location_, count_, value_ );
}

void glProgramUniformMatrix2dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC, "glProgramUniformMatrix2dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC, "glProgramUniformMatrix3dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC, "glProgramUniformMatrix4dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x3dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC, "glProgramUniformMatrix2x3dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix2x4dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC, "glProgramUniformMatrix2x4dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x2dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC, "glProgramUniformMatrix3x2dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix3x4dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC, "glProgramUniformMatrix3x4dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x2dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC, "glProgramUniformMatrix4x2dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glProgramUniformMatrix4x3dvEXTWrapper(GLuint program_, GLint location_, GLsizei count_, GLboolean transpose_, const GLdouble* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC, "glProgramUniformMatrix4x3dvEXT");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC)( program_, location_, count_, transpose_, value_ );
}

void glTextureBufferRangeEXTWrapper(GLuint texture_, GLenum target_, GLenum internalformat_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLTEXTUREBUFFERRANGEEXTPROC, "glTextureBufferRangeEXT");
  RESOLVED_PROC(PFNGLTEXTUREBUFFERRANGEEXTPROC)( texture_, target_, internalformat_, buffer_, offset_, size_ );
}

void glTextureStorage1DEXTWrapper(GLuint texture_, GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_)
{
  RESOLVE(PFNGLTEXTURESTORAGE1DEXTPROC, "glTextureStorage1DEXT");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE1DEXTPROC)( texture_, target_, levels_, internalformat_, width_ );
}

void glTextureStorage2DEXTWrapper(GLuint texture_, GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLTEXTURESTORAGE2DEXTPROC, "glTextureStorage2DEXT");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE2DEXTPROC)( texture_, target_, levels_, internalformat_, width_, height_ );
}

void glTextureStorage3DEXTWrapper(GLuint texture_, GLenum target_, GLsizei levels_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_)
{
  RESOLVE(PFNGLTEXTURESTORAGE3DEXTPROC, "glTextureStorage3DEXT");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE3DEXTPROC)( texture_, target_, levels_, internalformat_, width_, height_, depth_ );
}

void glTextureStorage2DMultisampleEXTWrapper(GLuint texture_, GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC, "glTextureStorage2DMultisampleEXT");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE2DMULTISAMPLEEXTPROC)( texture_, target_, samples_, internalformat_, width_, height_, fixedsamplelocations_ );
}

void glTextureStorage3DMultisampleEXTWrapper(GLuint texture_, GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC, "glTextureStorage3DMultisampleEXT");
  RESOLVED_PROC(PFNGLTEXTURESTORAGE3DMULTISAMPLEEXTPROC)( texture_, target_, samples_, internalformat_, width_, height_, depth_, fixedsamplelocations_ );
}

void glVertexArrayBindVertexBufferEXTWrapper(GLuint vaobj_, GLuint bindingindex_, GLuint buffer_, GLintptr offset_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC, "glVertexArrayBindVertexBufferEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYBINDVERTEXBUFFEREXTPROC)( vaobj_, bindingindex_, buffer_, offset_, stride_ );
}

void glVertexArrayVertexAttribFormatEXTWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLboolean normalized_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC, "glVertexArrayVertexAttribFormatEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBFORMATEXTPROC)( vaobj_, attribindex_, size_, type_, normalized_, relativeoffset_ );
}

void glVertexArrayVertexAttribIFormatEXTWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC, "glVertexArrayVertexAttribIFormatEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC)( vaobj_, attribindex_, size_, type_, relativeoffset_ );
}

void glVertexArrayVertexAttribLFormatEXTWrapper(GLuint vaobj_, GLuint attribindex_, GLint size_, GLenum type_, GLuint relativeoffset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC, "glVertexArrayVertexAttribLFormatEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC)( vaobj_, attribindex_, size_, type_, relativeoffset_ );
}

void glVertexArrayVertexAttribBindingEXTWrapper(GLuint vaobj_, GLuint attribindex_, GLuint bindingindex_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC, "glVertexArrayVertexAttribBindingEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC)( vaobj_, attribindex_, bindingindex_ );
}

void glVertexArrayVertexBindingDivisorEXTWrapper(GLuint vaobj_, GLuint bindingindex_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC, "glVertexArrayVertexBindingDivisorEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC)( vaobj_, bindingindex_, divisor_ );
}

void glVertexArrayVertexAttribLOffsetEXTWrapper(GLuint vaobj_, GLuint buffer_, GLuint index_, GLint size_, GLenum type_, GLsizei stride_, GLintptr offset_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC, "glVertexArrayVertexAttribLOffsetEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)( vaobj_, buffer_, index_, size_, type_, stride_, offset_ );
}

void glTexturePageCommitmentEXTWrapper(GLuint texture_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean commit_)
{
  RESOLVE(PFNGLTEXTUREPAGECOMMITMENTEXTPROC, "glTexturePageCommitmentEXT");
  RESOLVED_PROC(PFNGLTEXTUREPAGECOMMITMENTEXTPROC)( texture_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, commit_ );
}

void glVertexArrayVertexAttribDivisorEXTWrapper(GLuint vaobj_, GLuint index_, GLuint divisor_)
{
  RESOLVE(PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC, "glVertexArrayVertexAttribDivisorEXT");
  RESOLVED_PROC(PFNGLVERTEXARRAYVERTEXATTRIBDIVISOREXTPROC)( vaobj_, index_, divisor_ );
}

void glColorMaskIndexedEXTWrapper(GLuint index_, GLboolean r_, GLboolean g_, GLboolean b_, GLboolean a_)
{
  RESOLVE(PFNGLCOLORMASKINDEXEDEXTPROC, "glColorMaskIndexedEXT");
  RESOLVED_PROC(PFNGLCOLORMASKINDEXEDEXTPROC)( index_, r_, g_, b_, a_ );
}

void glDrawArraysInstancedEXTWrapper(GLenum mode_, GLint start_, GLsizei count_, GLsizei primcount_)
{
  RESOLVE(PFNGLDRAWARRAYSINSTANCEDEXTPROC, "glDrawArraysInstancedEXT");
  RESOLVED_PROC(PFNGLDRAWARRAYSINSTANCEDEXTPROC)( mode_, start_, count_, primcount_ );
}

void glDrawElementsInstancedEXTWrapper(GLenum mode_, GLsizei count_, GLenum type_, const void * indices_, GLsizei primcount_)
{
  RESOLVE(PFNGLDRAWELEMENTSINSTANCEDEXTPROC, "glDrawElementsInstancedEXT");
  RESOLVED_PROC(PFNGLDRAWELEMENTSINSTANCEDEXTPROC)( mode_, count_, type_, indices_, primcount_ );
}

void glDrawRangeElementsEXTWrapper(GLenum mode_, GLuint start_, GLuint end_, GLsizei count_, GLenum type_, const void * indices_)
{
  RESOLVE(PFNGLDRAWRANGEELEMENTSEXTPROC, "glDrawRangeElementsEXT");
  RESOLVED_PROC(PFNGLDRAWRANGEELEMENTSEXTPROC)( mode_, start_, end_, count_, type_, indices_ );
}

void glFogCoordfEXTWrapper(GLfloat coord_)
{
  RESOLVE(PFNGLFOGCOORDFEXTPROC, "glFogCoordfEXT");
  RESOLVED_PROC(PFNGLFOGCOORDFEXTPROC)( coord_ );
}

void glFogCoordfvEXTWrapper(const GLfloat* coord_)
{
  RESOLVE(PFNGLFOGCOORDFVEXTPROC, "glFogCoordfvEXT");
  RESOLVED_PROC(PFNGLFOGCOORDFVEXTPROC)( coord_ );
}

void glFogCoorddEXTWrapper(GLdouble coord_)
{
  RESOLVE(PFNGLFOGCOORDDEXTPROC, "glFogCoorddEXT");
  RESOLVED_PROC(PFNGLFOGCOORDDEXTPROC)( coord_ );
}

void glFogCoorddvEXTWrapper(const GLdouble* coord_)
{
  RESOLVE(PFNGLFOGCOORDDVEXTPROC, "glFogCoorddvEXT");
  RESOLVED_PROC(PFNGLFOGCOORDDVEXTPROC)( coord_ );
}

void glFogCoordPointerEXTWrapper(GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLFOGCOORDPOINTEREXTPROC, "glFogCoordPointerEXT");
  RESOLVED_PROC(PFNGLFOGCOORDPOINTEREXTPROC)( type_, stride_, pointer_ );
}

void glBlitFramebufferEXTWrapper(GLint srcX0_, GLint srcY0_, GLint srcX1_, GLint srcY1_, GLint dstX0_, GLint dstY0_, GLint dstX1_, GLint dstY1_, GLbitfield mask_, GLenum filter_)
{
  RESOLVE(PFNGLBLITFRAMEBUFFEREXTPROC, "glBlitFramebufferEXT");
  RESOLVED_PROC(PFNGLBLITFRAMEBUFFEREXTPROC)( srcX0_, srcY0_, srcX1_, srcY1_, dstX0_, dstY0_, dstX1_, dstY1_, mask_, filter_ );
}

void glRenderbufferStorageMultisampleEXTWrapper(GLenum target_, GLsizei samples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC, "glRenderbufferStorageMultisampleEXT");
  RESOLVED_PROC(PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)( target_, samples_, internalformat_, width_, height_ );
}

GLboolean glIsRenderbufferEXTWrapper(GLuint renderbuffer_)
{
  RESOLVE_RET(PFNGLISRENDERBUFFEREXTPROC, "glIsRenderbufferEXT", FALSE);
  return RESOLVED_PROC(PFNGLISRENDERBUFFEREXTPROC)(renderbuffer_ );
}

void glBindRenderbufferEXTWrapper(GLenum target_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLBINDRENDERBUFFEREXTPROC, "glBindRenderbufferEXT");
  RESOLVED_PROC(PFNGLBINDRENDERBUFFEREXTPROC)( target_, renderbuffer_ );
}

void glDeleteRenderbuffersEXTWrapper(GLsizei n_, const GLuint* renderbuffers_)
{
  RESOLVE(PFNGLDELETERENDERBUFFERSEXTPROC, "glDeleteRenderbuffersEXT");
  RESOLVED_PROC(PFNGLDELETERENDERBUFFERSEXTPROC)( n_, renderbuffers_ );
}

void glGenRenderbuffersEXTWrapper(GLsizei n_, GLuint* renderbuffers_)
{
  RESOLVE(PFNGLGENRENDERBUFFERSEXTPROC, "glGenRenderbuffersEXT");
  RESOLVED_PROC(PFNGLGENRENDERBUFFERSEXTPROC)( n_, renderbuffers_ );
}

void glRenderbufferStorageEXTWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLRENDERBUFFERSTORAGEEXTPROC, "glRenderbufferStorageEXT");
  RESOLVED_PROC(PFNGLRENDERBUFFERSTORAGEEXTPROC)( target_, internalformat_, width_, height_ );
}

void glGetRenderbufferParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC, "glGetRenderbufferParameterivEXT");
  RESOLVED_PROC(PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

GLboolean glIsFramebufferEXTWrapper(GLuint framebuffer_)
{
  RESOLVE_RET(PFNGLISFRAMEBUFFEREXTPROC, "glIsFramebufferEXT", FALSE);
  return RESOLVED_PROC(PFNGLISFRAMEBUFFEREXTPROC)(framebuffer_ );
}

void glBindFramebufferEXTWrapper(GLenum target_, GLuint framebuffer_)
{
  RESOLVE(PFNGLBINDFRAMEBUFFEREXTPROC, "glBindFramebufferEXT");
  RESOLVED_PROC(PFNGLBINDFRAMEBUFFEREXTPROC)( target_, framebuffer_ );
}

void glDeleteFramebuffersEXTWrapper(GLsizei n_, const GLuint* framebuffers_)
{
  RESOLVE(PFNGLDELETEFRAMEBUFFERSEXTPROC, "glDeleteFramebuffersEXT");
  RESOLVED_PROC(PFNGLDELETEFRAMEBUFFERSEXTPROC)( n_, framebuffers_ );
}

void glGenFramebuffersEXTWrapper(GLsizei n_, GLuint* framebuffers_)
{
  RESOLVE(PFNGLGENFRAMEBUFFERSEXTPROC, "glGenFramebuffersEXT");
  RESOLVED_PROC(PFNGLGENFRAMEBUFFERSEXTPROC)( n_, framebuffers_ );
}

GLenum glCheckFramebufferStatusEXTWrapper(GLenum target_)
{
  RESOLVE_RET(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC, "glCheckFramebufferStatusEXT", FALSE);
  return RESOLVED_PROC(PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)(target_ );
}

void glFramebufferTexture1DEXTWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE1DEXTPROC, "glFramebufferTexture1DEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)( target_, attachment_, textarget_, texture_, level_ );
}

void glFramebufferTexture2DEXTWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE2DEXTPROC, "glFramebufferTexture2DEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)( target_, attachment_, textarget_, texture_, level_ );
}

void glFramebufferTexture3DEXTWrapper(GLenum target_, GLenum attachment_, GLenum textarget_, GLuint texture_, GLint level_, GLint zoffset_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURE3DEXTPROC, "glFramebufferTexture3DEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)( target_, attachment_, textarget_, texture_, level_, zoffset_ );
}

void glFramebufferRenderbufferEXTWrapper(GLenum target_, GLenum attachment_, GLenum renderbuffertarget_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC, "glFramebufferRenderbufferEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)( target_, attachment_, renderbuffertarget_, renderbuffer_ );
}

void glGetFramebufferAttachmentParameterivEXTWrapper(GLenum target_, GLenum attachment_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC, "glGetFramebufferAttachmentParameterivEXT");
  RESOLVED_PROC(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)( target_, attachment_, pname_, params_ );
}

void glGenerateMipmapEXTWrapper(GLenum target_)
{
  RESOLVE(PFNGLGENERATEMIPMAPEXTPROC, "glGenerateMipmapEXT");
  RESOLVED_PROC(PFNGLGENERATEMIPMAPEXTPROC)( target_ );
}

void glProgramParameteriEXTWrapper(GLuint program_, GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLPROGRAMPARAMETERIEXTPROC, "glProgramParameteriEXT");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETERIEXTPROC)( program_, pname_, value_ );
}

void glProgramEnvParameters4fvEXTWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLfloat* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERS4FVEXTPROC, "glProgramEnvParameters4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)( target_, index_, count_, params_ );
}

void glProgramLocalParameters4fvEXTWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLfloat* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC, "glProgramLocalParameters4fvEXT");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)( target_, index_, count_, params_ );
}

void glGetUniformuivEXTWrapper(GLuint program_, GLint location_, GLuint* params_)
{
  RESOLVE(PFNGLGETUNIFORMUIVEXTPROC, "glGetUniformuivEXT");
  RESOLVED_PROC(PFNGLGETUNIFORMUIVEXTPROC)( program_, location_, params_ );
}

void glBindFragDataLocationEXTWrapper(GLuint program_, GLuint color_, const GLchar* name_)
{
  RESOLVE(PFNGLBINDFRAGDATALOCATIONEXTPROC, "glBindFragDataLocationEXT");
  RESOLVED_PROC(PFNGLBINDFRAGDATALOCATIONEXTPROC)( program_, color_, name_ );
}

GLint glGetFragDataLocationEXTWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETFRAGDATALOCATIONEXTPROC, "glGetFragDataLocationEXT", FALSE);
  return RESOLVED_PROC(PFNGLGETFRAGDATALOCATIONEXTPROC)(program_, name_ );
}

void glUniform1uiEXTWrapper(GLint location_, GLuint v0_)
{
  RESOLVE(PFNGLUNIFORM1UIEXTPROC, "glUniform1uiEXT");
  RESOLVED_PROC(PFNGLUNIFORM1UIEXTPROC)( location_, v0_ );
}

void glUniform2uiEXTWrapper(GLint location_, GLuint v0_, GLuint v1_)
{
  RESOLVE(PFNGLUNIFORM2UIEXTPROC, "glUniform2uiEXT");
  RESOLVED_PROC(PFNGLUNIFORM2UIEXTPROC)( location_, v0_, v1_ );
}

void glUniform3uiEXTWrapper(GLint location_, GLuint v0_, GLuint v1_, GLuint v2_)
{
  RESOLVE(PFNGLUNIFORM3UIEXTPROC, "glUniform3uiEXT");
  RESOLVED_PROC(PFNGLUNIFORM3UIEXTPROC)( location_, v0_, v1_, v2_ );
}

void glUniform4uiEXTWrapper(GLint location_, GLuint v0_, GLuint v1_, GLuint v2_, GLuint v3_)
{
  RESOLVE(PFNGLUNIFORM4UIEXTPROC, "glUniform4uiEXT");
  RESOLVED_PROC(PFNGLUNIFORM4UIEXTPROC)( location_, v0_, v1_, v2_, v3_ );
}

void glUniform1uivEXTWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM1UIVEXTPROC, "glUniform1uivEXT");
  RESOLVED_PROC(PFNGLUNIFORM1UIVEXTPROC)( location_, count_, value_ );
}

void glUniform2uivEXTWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM2UIVEXTPROC, "glUniform2uivEXT");
  RESOLVED_PROC(PFNGLUNIFORM2UIVEXTPROC)( location_, count_, value_ );
}

void glUniform3uivEXTWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM3UIVEXTPROC, "glUniform3uivEXT");
  RESOLVED_PROC(PFNGLUNIFORM3UIVEXTPROC)( location_, count_, value_ );
}

void glUniform4uivEXTWrapper(GLint location_, GLsizei count_, const GLuint* value_)
{
  RESOLVE(PFNGLUNIFORM4UIVEXTPROC, "glUniform4uivEXT");
  RESOLVED_PROC(PFNGLUNIFORM4UIVEXTPROC)( location_, count_, value_ );
}

void glGetHistogramEXTWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, void * values_)
{
  RESOLVE(PFNGLGETHISTOGRAMEXTPROC, "glGetHistogramEXT");
  RESOLVED_PROC(PFNGLGETHISTOGRAMEXTPROC)( target_, reset_, format_, type_, values_ );
}

void glGetHistogramParameterfvEXTWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETHISTOGRAMPARAMETERFVEXTPROC, "glGetHistogramParameterfvEXT");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glGetHistogramParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETHISTOGRAMPARAMETERIVEXTPROC, "glGetHistogramParameterivEXT");
  RESOLVED_PROC(PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glGetMinmaxEXTWrapper(GLenum target_, GLboolean reset_, GLenum format_, GLenum type_, void * values_)
{
  RESOLVE(PFNGLGETMINMAXEXTPROC, "glGetMinmaxEXT");
  RESOLVED_PROC(PFNGLGETMINMAXEXTPROC)( target_, reset_, format_, type_, values_ );
}

void glGetMinmaxParameterfvEXTWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMINMAXPARAMETERFVEXTPROC, "glGetMinmaxParameterfvEXT");
  RESOLVED_PROC(PFNGLGETMINMAXPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glGetMinmaxParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMINMAXPARAMETERIVEXTPROC, "glGetMinmaxParameterivEXT");
  RESOLVED_PROC(PFNGLGETMINMAXPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glHistogramEXTWrapper(GLenum target_, GLsizei width_, GLenum internalformat_, GLboolean sink_)
{
  RESOLVE(PFNGLHISTOGRAMEXTPROC, "glHistogramEXT");
  RESOLVED_PROC(PFNGLHISTOGRAMEXTPROC)( target_, width_, internalformat_, sink_ );
}

void glMinmaxEXTWrapper(GLenum target_, GLenum internalformat_, GLboolean sink_)
{
  RESOLVE(PFNGLMINMAXEXTPROC, "glMinmaxEXT");
  RESOLVED_PROC(PFNGLMINMAXEXTPROC)( target_, internalformat_, sink_ );
}

void glResetHistogramEXTWrapper(GLenum target_)
{
  RESOLVE(PFNGLRESETHISTOGRAMEXTPROC, "glResetHistogramEXT");
  RESOLVED_PROC(PFNGLRESETHISTOGRAMEXTPROC)( target_ );
}

void glResetMinmaxEXTWrapper(GLenum target_)
{
  RESOLVE(PFNGLRESETMINMAXEXTPROC, "glResetMinmaxEXT");
  RESOLVED_PROC(PFNGLRESETMINMAXEXTPROC)( target_ );
}

void glIndexFuncEXTWrapper(GLenum func_, GLclampf ref_)
{
  RESOLVE(PFNGLINDEXFUNCEXTPROC, "glIndexFuncEXT");
  RESOLVED_PROC(PFNGLINDEXFUNCEXTPROC)( func_, ref_ );
}

void glIndexMaterialEXTWrapper(GLenum face_, GLenum mode_)
{
  RESOLVE(PFNGLINDEXMATERIALEXTPROC, "glIndexMaterialEXT");
  RESOLVED_PROC(PFNGLINDEXMATERIALEXTPROC)( face_, mode_ );
}

void glApplyTextureEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLAPPLYTEXTUREEXTPROC, "glApplyTextureEXT");
  RESOLVED_PROC(PFNGLAPPLYTEXTUREEXTPROC)( mode_ );
}

void glTextureLightEXTWrapper(GLenum pname_)
{
  RESOLVE(PFNGLTEXTURELIGHTEXTPROC, "glTextureLightEXT");
  RESOLVED_PROC(PFNGLTEXTURELIGHTEXTPROC)( pname_ );
}

void glTextureMaterialEXTWrapper(GLenum face_, GLenum mode_)
{
  RESOLVE(PFNGLTEXTUREMATERIALEXTPROC, "glTextureMaterialEXT");
  RESOLVED_PROC(PFNGLTEXTUREMATERIALEXTPROC)( face_, mode_ );
}

void glMultiDrawArraysEXTWrapper(GLenum mode_, const GLint* first_, const GLsizei* count_, GLsizei primcount_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSEXTPROC, "glMultiDrawArraysEXT");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSEXTPROC)( mode_, first_, count_, primcount_ );
}

void glMultiDrawElementsEXTWrapper(GLenum mode_, const GLsizei* count_, GLenum type_, const void *const* indices_, GLsizei primcount_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSEXTPROC, "glMultiDrawElementsEXT");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSEXTPROC)( mode_, count_, type_, indices_, primcount_ );
}

void glSampleMaskEXTWrapper(GLclampf value_, GLboolean invert_)
{
  RESOLVE(PFNGLSAMPLEMASKEXTPROC, "glSampleMaskEXT");
  RESOLVED_PROC(PFNGLSAMPLEMASKEXTPROC)( value_, invert_ );
}

void glSamplePatternEXTWrapper(GLenum pattern_)
{
  RESOLVE(PFNGLSAMPLEPATTERNEXTPROC, "glSamplePatternEXT");
  RESOLVED_PROC(PFNGLSAMPLEPATTERNEXTPROC)( pattern_ );
}

void glColorTableEXTWrapper(GLenum target_, GLenum internalFormat_, GLsizei width_, GLenum format_, GLenum type_, const void * table_)
{
  RESOLVE(PFNGLCOLORTABLEEXTPROC, "glColorTableEXT");
  RESOLVED_PROC(PFNGLCOLORTABLEEXTPROC)( target_, internalFormat_, width_, format_, type_, table_ );
}

void glGetColorTableEXTWrapper(GLenum target_, GLenum format_, GLenum type_, void * data_)
{
  RESOLVE(PFNGLGETCOLORTABLEEXTPROC, "glGetColorTableEXT");
  RESOLVED_PROC(PFNGLGETCOLORTABLEEXTPROC)( target_, format_, type_, data_ );
}

void glGetColorTableParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERIVEXTPROC, "glGetColorTableParameterivEXT");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glGetColorTableParameterfvEXTWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERFVEXTPROC, "glGetColorTableParameterfvEXT");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glPixelTransformParameteriEXTWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLPIXELTRANSFORMPARAMETERIEXTPROC, "glPixelTransformParameteriEXT");
  RESOLVED_PROC(PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)( target_, pname_, param_ );
}

void glPixelTransformParameterfEXTWrapper(GLenum target_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPIXELTRANSFORMPARAMETERFEXTPROC, "glPixelTransformParameterfEXT");
  RESOLVED_PROC(PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)( target_, pname_, param_ );
}

void glPixelTransformParameterivEXTWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC, "glPixelTransformParameterivEXT");
  RESOLVED_PROC(PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glPixelTransformParameterfvEXTWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC, "glPixelTransformParameterfvEXT");
  RESOLVED_PROC(PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glGetPixelTransformParameterivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC, "glGetPixelTransformParameterivEXT");
  RESOLVED_PROC(PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)( target_, pname_, params_ );
}

void glGetPixelTransformParameterfvEXTWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC, "glGetPixelTransformParameterfvEXT");
  RESOLVED_PROC(PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)( target_, pname_, params_ );
}

void glPointParameterfEXTWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPOINTPARAMETERFEXTPROC, "glPointParameterfEXT");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFEXTPROC)( pname_, param_ );
}

void glPointParameterfvEXTWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERFVEXTPROC, "glPointParameterfvEXT");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFVEXTPROC)( pname_, params_ );
}

void glPolygonOffsetEXTWrapper(GLfloat factor_, GLfloat bias_)
{
  RESOLVE(PFNGLPOLYGONOFFSETEXTPROC, "glPolygonOffsetEXT");
  RESOLVED_PROC(PFNGLPOLYGONOFFSETEXTPROC)( factor_, bias_ );
}

void glPolygonOffsetClampEXTWrapper(GLfloat factor_, GLfloat units_, GLfloat clamp_)
{
  RESOLVE(PFNGLPOLYGONOFFSETCLAMPEXTPROC, "glPolygonOffsetClampEXT");
  RESOLVED_PROC(PFNGLPOLYGONOFFSETCLAMPEXTPROC)( factor_, units_, clamp_ );
}

void glProvokingVertexEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLPROVOKINGVERTEXEXTPROC, "glProvokingVertexEXT");
  RESOLVED_PROC(PFNGLPROVOKINGVERTEXEXTPROC)( mode_ );
}

void glRasterSamplesEXTWrapper(GLuint samples_, GLboolean fixedsamplelocations_)
{
  RESOLVE(PFNGLRASTERSAMPLESEXTPROC, "glRasterSamplesEXT");
  RESOLVED_PROC(PFNGLRASTERSAMPLESEXTPROC)( samples_, fixedsamplelocations_ );
}

void glSecondaryColor3bEXTWrapper(GLbyte red_, GLbyte green_, GLbyte blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3BEXTPROC, "glSecondaryColor3bEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3BEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3bvEXTWrapper(const GLbyte* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3BVEXTPROC, "glSecondaryColor3bvEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3BVEXTPROC)( v_ );
}

void glSecondaryColor3dEXTWrapper(GLdouble red_, GLdouble green_, GLdouble blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3DEXTPROC, "glSecondaryColor3dEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3DEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3dvEXTWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3DVEXTPROC, "glSecondaryColor3dvEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3DVEXTPROC)( v_ );
}

void glSecondaryColor3fEXTWrapper(GLfloat red_, GLfloat green_, GLfloat blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3FEXTPROC, "glSecondaryColor3fEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3FEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3fvEXTWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3FVEXTPROC, "glSecondaryColor3fvEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3FVEXTPROC)( v_ );
}

void glSecondaryColor3iEXTWrapper(GLint red_, GLint green_, GLint blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3IEXTPROC, "glSecondaryColor3iEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3IEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3ivEXTWrapper(const GLint* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3IVEXTPROC, "glSecondaryColor3ivEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3IVEXTPROC)( v_ );
}

void glSecondaryColor3sEXTWrapper(GLshort red_, GLshort green_, GLshort blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3SEXTPROC, "glSecondaryColor3sEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3SEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3svEXTWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3SVEXTPROC, "glSecondaryColor3svEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3SVEXTPROC)( v_ );
}

void glSecondaryColor3ubEXTWrapper(GLubyte red_, GLubyte green_, GLubyte blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UBEXTPROC, "glSecondaryColor3ubEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UBEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3ubvEXTWrapper(const GLubyte* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UBVEXTPROC, "glSecondaryColor3ubvEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UBVEXTPROC)( v_ );
}

void glSecondaryColor3uiEXTWrapper(GLuint red_, GLuint green_, GLuint blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UIEXTPROC, "glSecondaryColor3uiEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UIEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3uivEXTWrapper(const GLuint* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3UIVEXTPROC, "glSecondaryColor3uivEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3UIVEXTPROC)( v_ );
}

void glSecondaryColor3usEXTWrapper(GLushort red_, GLushort green_, GLushort blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3USEXTPROC, "glSecondaryColor3usEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3USEXTPROC)( red_, green_, blue_ );
}

void glSecondaryColor3usvEXTWrapper(const GLushort* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3USVEXTPROC, "glSecondaryColor3usvEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3USVEXTPROC)( v_ );
}

void glSecondaryColorPointerEXTWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLSECONDARYCOLORPOINTEREXTPROC, "glSecondaryColorPointerEXT");
  RESOLVED_PROC(PFNGLSECONDARYCOLORPOINTEREXTPROC)( size_, type_, stride_, pointer_ );
}

void glUseShaderProgramEXTWrapper(GLenum type_, GLuint program_)
{
  RESOLVE(PFNGLUSESHADERPROGRAMEXTPROC, "glUseShaderProgramEXT");
  RESOLVED_PROC(PFNGLUSESHADERPROGRAMEXTPROC)( type_, program_ );
}

void glActiveProgramEXTWrapper(GLuint program_)
{
  RESOLVE(PFNGLACTIVEPROGRAMEXTPROC, "glActiveProgramEXT");
  RESOLVED_PROC(PFNGLACTIVEPROGRAMEXTPROC)( program_ );
}

GLuint glCreateShaderProgramEXTWrapper(GLenum type_, const GLchar* string_)
{
  RESOLVE_RET(PFNGLCREATESHADERPROGRAMEXTPROC, "glCreateShaderProgramEXT", FALSE);
  return RESOLVED_PROC(PFNGLCREATESHADERPROGRAMEXTPROC)(type_, string_ );
}

void glBindImageTextureEXTWrapper(GLuint index_, GLuint texture_, GLint level_, GLboolean layered_, GLint layer_, GLenum access_, GLint format_)
{
  RESOLVE(PFNGLBINDIMAGETEXTUREEXTPROC, "glBindImageTextureEXT");
  RESOLVED_PROC(PFNGLBINDIMAGETEXTUREEXTPROC)( index_, texture_, level_, layered_, layer_, access_, format_ );
}

void glMemoryBarrierEXTWrapper(GLbitfield barriers_)
{
  RESOLVE(PFNGLMEMORYBARRIEREXTPROC, "glMemoryBarrierEXT");
  RESOLVED_PROC(PFNGLMEMORYBARRIEREXTPROC)( barriers_ );
}

void glStencilClearTagEXTWrapper(GLsizei stencilTagBits_, GLuint stencilClearTag_)
{
  RESOLVE(PFNGLSTENCILCLEARTAGEXTPROC, "glStencilClearTagEXT");
  RESOLVED_PROC(PFNGLSTENCILCLEARTAGEXTPROC)( stencilTagBits_, stencilClearTag_ );
}

void glActiveStencilFaceEXTWrapper(GLenum face_)
{
  RESOLVE(PFNGLACTIVESTENCILFACEEXTPROC, "glActiveStencilFaceEXT");
  RESOLVED_PROC(PFNGLACTIVESTENCILFACEEXTPROC)( face_ );
}

void glTexSubImage1DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLsizei width_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXSUBIMAGE1DEXTPROC, "glTexSubImage1DEXT");
  RESOLVED_PROC(PFNGLTEXSUBIMAGE1DEXTPROC)( target_, level_, xoffset_, width_, format_, type_, pixels_ );
}

void glTexSubImage2DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLsizei width_, GLsizei height_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXSUBIMAGE2DEXTPROC, "glTexSubImage2DEXT");
  RESOLVED_PROC(PFNGLTEXSUBIMAGE2DEXTPROC)( target_, level_, xoffset_, yoffset_, width_, height_, format_, type_, pixels_ );
}

void glTexImage3DEXTWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXIMAGE3DEXTPROC, "glTexImage3DEXT");
  RESOLVED_PROC(PFNGLTEXIMAGE3DEXTPROC)( target_, level_, internalformat_, width_, height_, depth_, border_, format_, type_, pixels_ );
}

void glTexSubImage3DEXTWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXSUBIMAGE3DEXTPROC, "glTexSubImage3DEXT");
  RESOLVED_PROC(PFNGLTEXSUBIMAGE3DEXTPROC)( target_, level_, xoffset_, yoffset_, zoffset_, width_, height_, depth_, format_, type_, pixels_ );
}

void glFramebufferTextureLayerEXTWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLint layer_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC, "glFramebufferTextureLayerEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)( target_, attachment_, texture_, level_, layer_ );
}

void glTexBufferEXTWrapper(GLenum target_, GLenum internalformat_, GLuint buffer_)
{
  RESOLVE(PFNGLTEXBUFFEREXTPROC, "glTexBufferEXT");
  RESOLVED_PROC(PFNGLTEXBUFFEREXTPROC)( target_, internalformat_, buffer_ );
}

void glTexParameterIivEXTWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLTEXPARAMETERIIVEXTPROC, "glTexParameterIivEXT");
  RESOLVED_PROC(PFNGLTEXPARAMETERIIVEXTPROC)( target_, pname_, params_ );
}

void glTexParameterIuivEXTWrapper(GLenum target_, GLenum pname_, const GLuint* params_)
{
  RESOLVE(PFNGLTEXPARAMETERIUIVEXTPROC, "glTexParameterIuivEXT");
  RESOLVED_PROC(PFNGLTEXPARAMETERIUIVEXTPROC)( target_, pname_, params_ );
}

void glGetTexParameterIivEXTWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERIIVEXTPROC, "glGetTexParameterIivEXT");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERIIVEXTPROC)( target_, pname_, params_ );
}

void glGetTexParameterIuivEXTWrapper(GLenum target_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETTEXPARAMETERIUIVEXTPROC, "glGetTexParameterIuivEXT");
  RESOLVED_PROC(PFNGLGETTEXPARAMETERIUIVEXTPROC)( target_, pname_, params_ );
}

void glClearColorIiEXTWrapper(GLint red_, GLint green_, GLint blue_, GLint alpha_)
{
  RESOLVE(PFNGLCLEARCOLORIIEXTPROC, "glClearColorIiEXT");
  RESOLVED_PROC(PFNGLCLEARCOLORIIEXTPROC)( red_, green_, blue_, alpha_ );
}

void glClearColorIuiEXTWrapper(GLuint red_, GLuint green_, GLuint blue_, GLuint alpha_)
{
  RESOLVE(PFNGLCLEARCOLORIUIEXTPROC, "glClearColorIuiEXT");
  RESOLVED_PROC(PFNGLCLEARCOLORIUIEXTPROC)( red_, green_, blue_, alpha_ );
}

GLboolean glAreTexturesResidentEXTWrapper(GLsizei n_, const GLuint* textures_, GLboolean* residences_)
{
  RESOLVE_RET(PFNGLARETEXTURESRESIDENTEXTPROC, "glAreTexturesResidentEXT", FALSE);
  return RESOLVED_PROC(PFNGLARETEXTURESRESIDENTEXTPROC)(n_, textures_, residences_ );
}

void glBindTextureEXTWrapper(GLenum target_, GLuint texture_)
{
  RESOLVE(PFNGLBINDTEXTUREEXTPROC, "glBindTextureEXT");
  RESOLVED_PROC(PFNGLBINDTEXTUREEXTPROC)( target_, texture_ );
}

void glDeleteTexturesEXTWrapper(GLsizei n_, const GLuint* textures_)
{
  RESOLVE(PFNGLDELETETEXTURESEXTPROC, "glDeleteTexturesEXT");
  RESOLVED_PROC(PFNGLDELETETEXTURESEXTPROC)( n_, textures_ );
}

void glGenTexturesEXTWrapper(GLsizei n_, GLuint* textures_)
{
  RESOLVE(PFNGLGENTEXTURESEXTPROC, "glGenTexturesEXT");
  RESOLVED_PROC(PFNGLGENTEXTURESEXTPROC)( n_, textures_ );
}

GLboolean glIsTextureEXTWrapper(GLuint texture_)
{
  RESOLVE_RET(PFNGLISTEXTUREEXTPROC, "glIsTextureEXT", FALSE);
  return RESOLVED_PROC(PFNGLISTEXTUREEXTPROC)(texture_ );
}

void glPrioritizeTexturesEXTWrapper(GLsizei n_, const GLuint* textures_, const GLclampf* priorities_)
{
  RESOLVE(PFNGLPRIORITIZETEXTURESEXTPROC, "glPrioritizeTexturesEXT");
  RESOLVED_PROC(PFNGLPRIORITIZETEXTURESEXTPROC)( n_, textures_, priorities_ );
}

void glTextureNormalEXTWrapper(GLenum mode_)
{
  RESOLVE(PFNGLTEXTURENORMALEXTPROC, "glTextureNormalEXT");
  RESOLVED_PROC(PFNGLTEXTURENORMALEXTPROC)( mode_ );
}

void glGetQueryObjecti64vEXTWrapper(GLuint id_, GLenum pname_, GLint64* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTI64VEXTPROC, "glGetQueryObjecti64vEXT");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTI64VEXTPROC)( id_, pname_, params_ );
}

void glGetQueryObjectui64vEXTWrapper(GLuint id_, GLenum pname_, GLuint64* params_)
{
  RESOLVE(PFNGLGETQUERYOBJECTUI64VEXTPROC, "glGetQueryObjectui64vEXT");
  RESOLVED_PROC(PFNGLGETQUERYOBJECTUI64VEXTPROC)( id_, pname_, params_ );
}

void glBeginTransformFeedbackEXTWrapper(GLenum primitiveMode_)
{
  RESOLVE(PFNGLBEGINTRANSFORMFEEDBACKEXTPROC, "glBeginTransformFeedbackEXT");
  RESOLVED_PROC(PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)( primitiveMode_ );
}

void glEndTransformFeedbackEXTWrapper(void)
{
  RESOLVE(PFNGLENDTRANSFORMFEEDBACKEXTPROC, "glEndTransformFeedbackEXT");
  RESOLVED_PROC(PFNGLENDTRANSFORMFEEDBACKEXTPROC)(  );
}

void glBindBufferRangeEXTWrapper(GLenum target_, GLuint index_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLBINDBUFFERRANGEEXTPROC, "glBindBufferRangeEXT");
  RESOLVED_PROC(PFNGLBINDBUFFERRANGEEXTPROC)( target_, index_, buffer_, offset_, size_ );
}

void glBindBufferOffsetEXTWrapper(GLenum target_, GLuint index_, GLuint buffer_, GLintptr offset_)
{
  RESOLVE(PFNGLBINDBUFFEROFFSETEXTPROC, "glBindBufferOffsetEXT");
  RESOLVED_PROC(PFNGLBINDBUFFEROFFSETEXTPROC)( target_, index_, buffer_, offset_ );
}

void glBindBufferBaseEXTWrapper(GLenum target_, GLuint index_, GLuint buffer_)
{
  RESOLVE(PFNGLBINDBUFFERBASEEXTPROC, "glBindBufferBaseEXT");
  RESOLVED_PROC(PFNGLBINDBUFFERBASEEXTPROC)( target_, index_, buffer_ );
}

void glTransformFeedbackVaryingsEXTWrapper(GLuint program_, GLsizei count_, const GLchar*const* varyings_, GLenum bufferMode_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC, "glTransformFeedbackVaryingsEXT");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)( program_, count_, varyings_, bufferMode_ );
}

void glGetTransformFeedbackVaryingEXTWrapper(GLuint program_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLsizei* size_, GLenum* type_, GLchar* name_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC, "glGetTransformFeedbackVaryingEXT");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)( program_, index_, bufSize_, length_, size_, type_, name_ );
}

void glArrayElementEXTWrapper(GLint i_)
{
  RESOLVE(PFNGLARRAYELEMENTEXTPROC, "glArrayElementEXT");
  RESOLVED_PROC(PFNGLARRAYELEMENTEXTPROC)( i_ );
}

void glColorPointerEXTWrapper(GLint size_, GLenum type_, GLsizei stride_, GLsizei count_, const void * pointer_)
{
  RESOLVE(PFNGLCOLORPOINTEREXTPROC, "glColorPointerEXT");
  RESOLVED_PROC(PFNGLCOLORPOINTEREXTPROC)( size_, type_, stride_, count_, pointer_ );
}

void glDrawArraysEXTWrapper(GLenum mode_, GLint first_, GLsizei count_)
{
  RESOLVE(PFNGLDRAWARRAYSEXTPROC, "glDrawArraysEXT");
  RESOLVED_PROC(PFNGLDRAWARRAYSEXTPROC)( mode_, first_, count_ );
}

void glEdgeFlagPointerEXTWrapper(GLsizei stride_, GLsizei count_, const GLboolean* pointer_)
{
  RESOLVE(PFNGLEDGEFLAGPOINTEREXTPROC, "glEdgeFlagPointerEXT");
  RESOLVED_PROC(PFNGLEDGEFLAGPOINTEREXTPROC)( stride_, count_, pointer_ );
}

void glGetPointervEXTWrapper(GLenum pname_, void ** params_)
{
  RESOLVE(PFNGLGETPOINTERVEXTPROC, "glGetPointervEXT");
  RESOLVED_PROC(PFNGLGETPOINTERVEXTPROC)( pname_, params_ );
}

void glIndexPointerEXTWrapper(GLenum type_, GLsizei stride_, GLsizei count_, const void * pointer_)
{
  RESOLVE(PFNGLINDEXPOINTEREXTPROC, "glIndexPointerEXT");
  RESOLVED_PROC(PFNGLINDEXPOINTEREXTPROC)( type_, stride_, count_, pointer_ );
}

void glNormalPointerEXTWrapper(GLenum type_, GLsizei stride_, GLsizei count_, const void * pointer_)
{
  RESOLVE(PFNGLNORMALPOINTEREXTPROC, "glNormalPointerEXT");
  RESOLVED_PROC(PFNGLNORMALPOINTEREXTPROC)( type_, stride_, count_, pointer_ );
}

void glTexCoordPointerEXTWrapper(GLint size_, GLenum type_, GLsizei stride_, GLsizei count_, const void * pointer_)
{
  RESOLVE(PFNGLTEXCOORDPOINTEREXTPROC, "glTexCoordPointerEXT");
  RESOLVED_PROC(PFNGLTEXCOORDPOINTEREXTPROC)( size_, type_, stride_, count_, pointer_ );
}

void glVertexPointerEXTWrapper(GLint size_, GLenum type_, GLsizei stride_, GLsizei count_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXPOINTEREXTPROC, "glVertexPointerEXT");
  RESOLVED_PROC(PFNGLVERTEXPOINTEREXTPROC)( size_, type_, stride_, count_, pointer_ );
}

void glVertexAttribL1dEXTWrapper(GLuint index_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1DEXTPROC, "glVertexAttribL1dEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1DEXTPROC)( index_, x_ );
}

void glVertexAttribL2dEXTWrapper(GLuint index_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2DEXTPROC, "glVertexAttribL2dEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2DEXTPROC)( index_, x_, y_ );
}

void glVertexAttribL3dEXTWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3DEXTPROC, "glVertexAttribL3dEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3DEXTPROC)( index_, x_, y_, z_ );
}

void glVertexAttribL4dEXTWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4DEXTPROC, "glVertexAttribL4dEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4DEXTPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribL1dvEXTWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1DVEXTPROC, "glVertexAttribL1dvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1DVEXTPROC)( index_, v_ );
}

void glVertexAttribL2dvEXTWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2DVEXTPROC, "glVertexAttribL2dvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2DVEXTPROC)( index_, v_ );
}

void glVertexAttribL3dvEXTWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3DVEXTPROC, "glVertexAttribL3dvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3DVEXTPROC)( index_, v_ );
}

void glVertexAttribL4dvEXTWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4DVEXTPROC, "glVertexAttribL4dvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4DVEXTPROC)( index_, v_ );
}

void glVertexAttribLPointerEXTWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBLPOINTEREXTPROC, "glVertexAttribLPointerEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBLPOINTEREXTPROC)( index_, size_, type_, stride_, pointer_ );
}

void glGetVertexAttribLdvEXTWrapper(GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBLDVEXTPROC, "glGetVertexAttribLdvEXT");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBLDVEXTPROC)( index_, pname_, params_ );
}

void glBeginVertexShaderEXTWrapper(void)
{
  RESOLVE(PFNGLBEGINVERTEXSHADEREXTPROC, "glBeginVertexShaderEXT");
  RESOLVED_PROC(PFNGLBEGINVERTEXSHADEREXTPROC)(  );
}

void glEndVertexShaderEXTWrapper(void)
{
  RESOLVE(PFNGLENDVERTEXSHADEREXTPROC, "glEndVertexShaderEXT");
  RESOLVED_PROC(PFNGLENDVERTEXSHADEREXTPROC)(  );
}

void glBindVertexShaderEXTWrapper(GLuint id_)
{
  RESOLVE(PFNGLBINDVERTEXSHADEREXTPROC, "glBindVertexShaderEXT");
  RESOLVED_PROC(PFNGLBINDVERTEXSHADEREXTPROC)( id_ );
}

GLuint glGenVertexShadersEXTWrapper(GLuint range_)
{
  RESOLVE_RET(PFNGLGENVERTEXSHADERSEXTPROC, "glGenVertexShadersEXT", FALSE);
  return RESOLVED_PROC(PFNGLGENVERTEXSHADERSEXTPROC)(range_ );
}

void glDeleteVertexShaderEXTWrapper(GLuint id_)
{
  RESOLVE(PFNGLDELETEVERTEXSHADEREXTPROC, "glDeleteVertexShaderEXT");
  RESOLVED_PROC(PFNGLDELETEVERTEXSHADEREXTPROC)( id_ );
}

void glShaderOp1EXTWrapper(GLenum op_, GLuint res_, GLuint arg1_)
{
  RESOLVE(PFNGLSHADEROP1EXTPROC, "glShaderOp1EXT");
  RESOLVED_PROC(PFNGLSHADEROP1EXTPROC)( op_, res_, arg1_ );
}

void glShaderOp2EXTWrapper(GLenum op_, GLuint res_, GLuint arg1_, GLuint arg2_)
{
  RESOLVE(PFNGLSHADEROP2EXTPROC, "glShaderOp2EXT");
  RESOLVED_PROC(PFNGLSHADEROP2EXTPROC)( op_, res_, arg1_, arg2_ );
}

void glShaderOp3EXTWrapper(GLenum op_, GLuint res_, GLuint arg1_, GLuint arg2_, GLuint arg3_)
{
  RESOLVE(PFNGLSHADEROP3EXTPROC, "glShaderOp3EXT");
  RESOLVED_PROC(PFNGLSHADEROP3EXTPROC)( op_, res_, arg1_, arg2_, arg3_ );
}

void glSwizzleEXTWrapper(GLuint res_, GLuint in_, GLenum outX_, GLenum outY_, GLenum outZ_, GLenum outW_)
{
  RESOLVE(PFNGLSWIZZLEEXTPROC, "glSwizzleEXT");
  RESOLVED_PROC(PFNGLSWIZZLEEXTPROC)( res_, in_, outX_, outY_, outZ_, outW_ );
}

void glWriteMaskEXTWrapper(GLuint res_, GLuint in_, GLenum outX_, GLenum outY_, GLenum outZ_, GLenum outW_)
{
  RESOLVE(PFNGLWRITEMASKEXTPROC, "glWriteMaskEXT");
  RESOLVED_PROC(PFNGLWRITEMASKEXTPROC)( res_, in_, outX_, outY_, outZ_, outW_ );
}

void glInsertComponentEXTWrapper(GLuint res_, GLuint src_, GLuint num_)
{
  RESOLVE(PFNGLINSERTCOMPONENTEXTPROC, "glInsertComponentEXT");
  RESOLVED_PROC(PFNGLINSERTCOMPONENTEXTPROC)( res_, src_, num_ );
}

void glExtractComponentEXTWrapper(GLuint res_, GLuint src_, GLuint num_)
{
  RESOLVE(PFNGLEXTRACTCOMPONENTEXTPROC, "glExtractComponentEXT");
  RESOLVED_PROC(PFNGLEXTRACTCOMPONENTEXTPROC)( res_, src_, num_ );
}

GLuint glGenSymbolsEXTWrapper(GLenum datatype_, GLenum storagetype_, GLenum range_, GLuint components_)
{
  RESOLVE_RET(PFNGLGENSYMBOLSEXTPROC, "glGenSymbolsEXT", FALSE);
  return RESOLVED_PROC(PFNGLGENSYMBOLSEXTPROC)(datatype_, storagetype_, range_, components_ );
}

void glSetInvariantEXTWrapper(GLuint id_, GLenum type_, const void * addr_)
{
  RESOLVE(PFNGLSETINVARIANTEXTPROC, "glSetInvariantEXT");
  RESOLVED_PROC(PFNGLSETINVARIANTEXTPROC)( id_, type_, addr_ );
}

void glSetLocalConstantEXTWrapper(GLuint id_, GLenum type_, const void * addr_)
{
  RESOLVE(PFNGLSETLOCALCONSTANTEXTPROC, "glSetLocalConstantEXT");
  RESOLVED_PROC(PFNGLSETLOCALCONSTANTEXTPROC)( id_, type_, addr_ );
}

void glVariantbvEXTWrapper(GLuint id_, const GLbyte* addr_)
{
  RESOLVE(PFNGLVARIANTBVEXTPROC, "glVariantbvEXT");
  RESOLVED_PROC(PFNGLVARIANTBVEXTPROC)( id_, addr_ );
}

void glVariantsvEXTWrapper(GLuint id_, const GLshort* addr_)
{
  RESOLVE(PFNGLVARIANTSVEXTPROC, "glVariantsvEXT");
  RESOLVED_PROC(PFNGLVARIANTSVEXTPROC)( id_, addr_ );
}

void glVariantivEXTWrapper(GLuint id_, const GLint* addr_)
{
  RESOLVE(PFNGLVARIANTIVEXTPROC, "glVariantivEXT");
  RESOLVED_PROC(PFNGLVARIANTIVEXTPROC)( id_, addr_ );
}

void glVariantfvEXTWrapper(GLuint id_, const GLfloat* addr_)
{
  RESOLVE(PFNGLVARIANTFVEXTPROC, "glVariantfvEXT");
  RESOLVED_PROC(PFNGLVARIANTFVEXTPROC)( id_, addr_ );
}

void glVariantdvEXTWrapper(GLuint id_, const GLdouble* addr_)
{
  RESOLVE(PFNGLVARIANTDVEXTPROC, "glVariantdvEXT");
  RESOLVED_PROC(PFNGLVARIANTDVEXTPROC)( id_, addr_ );
}

void glVariantubvEXTWrapper(GLuint id_, const GLubyte* addr_)
{
  RESOLVE(PFNGLVARIANTUBVEXTPROC, "glVariantubvEXT");
  RESOLVED_PROC(PFNGLVARIANTUBVEXTPROC)( id_, addr_ );
}

void glVariantusvEXTWrapper(GLuint id_, const GLushort* addr_)
{
  RESOLVE(PFNGLVARIANTUSVEXTPROC, "glVariantusvEXT");
  RESOLVED_PROC(PFNGLVARIANTUSVEXTPROC)( id_, addr_ );
}

void glVariantuivEXTWrapper(GLuint id_, const GLuint* addr_)
{
  RESOLVE(PFNGLVARIANTUIVEXTPROC, "glVariantuivEXT");
  RESOLVED_PROC(PFNGLVARIANTUIVEXTPROC)( id_, addr_ );
}

void glVariantPointerEXTWrapper(GLuint id_, GLenum type_, GLuint stride_, const void * addr_)
{
  RESOLVE(PFNGLVARIANTPOINTEREXTPROC, "glVariantPointerEXT");
  RESOLVED_PROC(PFNGLVARIANTPOINTEREXTPROC)( id_, type_, stride_, addr_ );
}

void glEnableVariantClientStateEXTWrapper(GLuint id_)
{
  RESOLVE(PFNGLENABLEVARIANTCLIENTSTATEEXTPROC, "glEnableVariantClientStateEXT");
  RESOLVED_PROC(PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)( id_ );
}

void glDisableVariantClientStateEXTWrapper(GLuint id_)
{
  RESOLVE(PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC, "glDisableVariantClientStateEXT");
  RESOLVED_PROC(PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)( id_ );
}

GLuint glBindLightParameterEXTWrapper(GLenum light_, GLenum value_)
{
  RESOLVE_RET(PFNGLBINDLIGHTPARAMETEREXTPROC, "glBindLightParameterEXT", FALSE);
  return RESOLVED_PROC(PFNGLBINDLIGHTPARAMETEREXTPROC)(light_, value_ );
}

GLuint glBindMaterialParameterEXTWrapper(GLenum face_, GLenum value_)
{
  RESOLVE_RET(PFNGLBINDMATERIALPARAMETEREXTPROC, "glBindMaterialParameterEXT", FALSE);
  return RESOLVED_PROC(PFNGLBINDMATERIALPARAMETEREXTPROC)(face_, value_ );
}

GLuint glBindTexGenParameterEXTWrapper(GLenum unit_, GLenum coord_, GLenum value_)
{
  RESOLVE_RET(PFNGLBINDTEXGENPARAMETEREXTPROC, "glBindTexGenParameterEXT", FALSE);
  return RESOLVED_PROC(PFNGLBINDTEXGENPARAMETEREXTPROC)(unit_, coord_, value_ );
}

GLuint glBindTextureUnitParameterEXTWrapper(GLenum unit_, GLenum value_)
{
  RESOLVE_RET(PFNGLBINDTEXTUREUNITPARAMETEREXTPROC, "glBindTextureUnitParameterEXT", FALSE);
  return RESOLVED_PROC(PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)(unit_, value_ );
}

GLuint glBindParameterEXTWrapper(GLenum value_)
{
  RESOLVE_RET(PFNGLBINDPARAMETEREXTPROC, "glBindParameterEXT", FALSE);
  return RESOLVED_PROC(PFNGLBINDPARAMETEREXTPROC)(value_ );
}

GLboolean glIsVariantEnabledEXTWrapper(GLuint id_, GLenum cap_)
{
  RESOLVE_RET(PFNGLISVARIANTENABLEDEXTPROC, "glIsVariantEnabledEXT", FALSE);
  return RESOLVED_PROC(PFNGLISVARIANTENABLEDEXTPROC)(id_, cap_ );
}

void glGetVariantBooleanvEXTWrapper(GLuint id_, GLenum value_, GLboolean* data_)
{
  RESOLVE(PFNGLGETVARIANTBOOLEANVEXTPROC, "glGetVariantBooleanvEXT");
  RESOLVED_PROC(PFNGLGETVARIANTBOOLEANVEXTPROC)( id_, value_, data_ );
}

void glGetVariantIntegervEXTWrapper(GLuint id_, GLenum value_, GLint* data_)
{
  RESOLVE(PFNGLGETVARIANTINTEGERVEXTPROC, "glGetVariantIntegervEXT");
  RESOLVED_PROC(PFNGLGETVARIANTINTEGERVEXTPROC)( id_, value_, data_ );
}

void glGetVariantFloatvEXTWrapper(GLuint id_, GLenum value_, GLfloat* data_)
{
  RESOLVE(PFNGLGETVARIANTFLOATVEXTPROC, "glGetVariantFloatvEXT");
  RESOLVED_PROC(PFNGLGETVARIANTFLOATVEXTPROC)( id_, value_, data_ );
}

void glGetVariantPointervEXTWrapper(GLuint id_, GLenum value_, void ** data_)
{
  RESOLVE(PFNGLGETVARIANTPOINTERVEXTPROC, "glGetVariantPointervEXT");
  RESOLVED_PROC(PFNGLGETVARIANTPOINTERVEXTPROC)( id_, value_, data_ );
}

void glGetInvariantBooleanvEXTWrapper(GLuint id_, GLenum value_, GLboolean* data_)
{
  RESOLVE(PFNGLGETINVARIANTBOOLEANVEXTPROC, "glGetInvariantBooleanvEXT");
  RESOLVED_PROC(PFNGLGETINVARIANTBOOLEANVEXTPROC)( id_, value_, data_ );
}

void glGetInvariantIntegervEXTWrapper(GLuint id_, GLenum value_, GLint* data_)
{
  RESOLVE(PFNGLGETINVARIANTINTEGERVEXTPROC, "glGetInvariantIntegervEXT");
  RESOLVED_PROC(PFNGLGETINVARIANTINTEGERVEXTPROC)( id_, value_, data_ );
}

void glGetInvariantFloatvEXTWrapper(GLuint id_, GLenum value_, GLfloat* data_)
{
  RESOLVE(PFNGLGETINVARIANTFLOATVEXTPROC, "glGetInvariantFloatvEXT");
  RESOLVED_PROC(PFNGLGETINVARIANTFLOATVEXTPROC)( id_, value_, data_ );
}

void glGetLocalConstantBooleanvEXTWrapper(GLuint id_, GLenum value_, GLboolean* data_)
{
  RESOLVE(PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC, "glGetLocalConstantBooleanvEXT");
  RESOLVED_PROC(PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)( id_, value_, data_ );
}

void glGetLocalConstantIntegervEXTWrapper(GLuint id_, GLenum value_, GLint* data_)
{
  RESOLVE(PFNGLGETLOCALCONSTANTINTEGERVEXTPROC, "glGetLocalConstantIntegervEXT");
  RESOLVED_PROC(PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)( id_, value_, data_ );
}

void glGetLocalConstantFloatvEXTWrapper(GLuint id_, GLenum value_, GLfloat* data_)
{
  RESOLVE(PFNGLGETLOCALCONSTANTFLOATVEXTPROC, "glGetLocalConstantFloatvEXT");
  RESOLVED_PROC(PFNGLGETLOCALCONSTANTFLOATVEXTPROC)( id_, value_, data_ );
}

void glVertexWeightfEXTWrapper(GLfloat weight_)
{
  RESOLVE(PFNGLVERTEXWEIGHTFEXTPROC, "glVertexWeightfEXT");
  RESOLVED_PROC(PFNGLVERTEXWEIGHTFEXTPROC)( weight_ );
}

void glVertexWeightfvEXTWrapper(const GLfloat* weight_)
{
  RESOLVE(PFNGLVERTEXWEIGHTFVEXTPROC, "glVertexWeightfvEXT");
  RESOLVED_PROC(PFNGLVERTEXWEIGHTFVEXTPROC)( weight_ );
}

void glVertexWeightPointerEXTWrapper(GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXWEIGHTPOINTEREXTPROC, "glVertexWeightPointerEXT");
  RESOLVED_PROC(PFNGLVERTEXWEIGHTPOINTEREXTPROC)( size_, type_, stride_, pointer_ );
}

GLsync glImportSyncEXTWrapper(GLenum external_sync_type_, GLintptr external_sync_, GLbitfield flags_)
{
  RESOLVE_RET(PFNGLIMPORTSYNCEXTPROC, "glImportSyncEXT", FALSE);
  return RESOLVED_PROC(PFNGLIMPORTSYNCEXTPROC)(external_sync_type_, external_sync_, flags_ );
}

void glFrameTerminatorGREMEDYWrapper(void)
{
  RESOLVE(PFNGLFRAMETERMINATORGREMEDYPROC, "glFrameTerminatorGREMEDY");
  RESOLVED_PROC(PFNGLFRAMETERMINATORGREMEDYPROC)(  );
}

void glStringMarkerGREMEDYWrapper(GLsizei len_, const void * string_)
{
  RESOLVE(PFNGLSTRINGMARKERGREMEDYPROC, "glStringMarkerGREMEDY");
  RESOLVED_PROC(PFNGLSTRINGMARKERGREMEDYPROC)( len_, string_ );
}

void glImageTransformParameteriHPWrapper(GLenum target_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLIMAGETRANSFORMPARAMETERIHPPROC, "glImageTransformParameteriHP");
  RESOLVED_PROC(PFNGLIMAGETRANSFORMPARAMETERIHPPROC)( target_, pname_, param_ );
}

void glImageTransformParameterfHPWrapper(GLenum target_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLIMAGETRANSFORMPARAMETERFHPPROC, "glImageTransformParameterfHP");
  RESOLVED_PROC(PFNGLIMAGETRANSFORMPARAMETERFHPPROC)( target_, pname_, param_ );
}

void glImageTransformParameterivHPWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLIMAGETRANSFORMPARAMETERIVHPPROC, "glImageTransformParameterivHP");
  RESOLVED_PROC(PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)( target_, pname_, params_ );
}

void glImageTransformParameterfvHPWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLIMAGETRANSFORMPARAMETERFVHPPROC, "glImageTransformParameterfvHP");
  RESOLVED_PROC(PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)( target_, pname_, params_ );
}

void glGetImageTransformParameterivHPWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC, "glGetImageTransformParameterivHP");
  RESOLVED_PROC(PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)( target_, pname_, params_ );
}

void glGetImageTransformParameterfvHPWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC, "glGetImageTransformParameterfvHP");
  RESOLVED_PROC(PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)( target_, pname_, params_ );
}

void glMultiModeDrawArraysIBMWrapper(const GLenum* mode_, const GLint* first_, const GLsizei* count_, GLsizei primcount_, GLint modestride_)
{
  RESOLVE(PFNGLMULTIMODEDRAWARRAYSIBMPROC, "glMultiModeDrawArraysIBM");
  RESOLVED_PROC(PFNGLMULTIMODEDRAWARRAYSIBMPROC)( mode_, first_, count_, primcount_, modestride_ );
}

void glMultiModeDrawElementsIBMWrapper(const GLenum* mode_, const GLsizei* count_, GLenum type_, const void *const* indices_, GLsizei primcount_, GLint modestride_)
{
  RESOLVE(PFNGLMULTIMODEDRAWELEMENTSIBMPROC, "glMultiModeDrawElementsIBM");
  RESOLVED_PROC(PFNGLMULTIMODEDRAWELEMENTSIBMPROC)( mode_, count_, type_, indices_, primcount_, modestride_ );
}

void glFlushStaticDataIBMWrapper(GLenum target_)
{
  RESOLVE(PFNGLFLUSHSTATICDATAIBMPROC, "glFlushStaticDataIBM");
  RESOLVED_PROC(PFNGLFLUSHSTATICDATAIBMPROC)( target_ );
}

void glColorPointerListIBMWrapper(GLint size_, GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLCOLORPOINTERLISTIBMPROC, "glColorPointerListIBM");
  RESOLVED_PROC(PFNGLCOLORPOINTERLISTIBMPROC)( size_, type_, stride_, pointer_, ptrstride_ );
}

void glSecondaryColorPointerListIBMWrapper(GLint size_, GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLSECONDARYCOLORPOINTERLISTIBMPROC, "glSecondaryColorPointerListIBM");
  RESOLVED_PROC(PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)( size_, type_, stride_, pointer_, ptrstride_ );
}

void glEdgeFlagPointerListIBMWrapper(GLint stride_, const GLboolean** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLEDGEFLAGPOINTERLISTIBMPROC, "glEdgeFlagPointerListIBM");
  RESOLVED_PROC(PFNGLEDGEFLAGPOINTERLISTIBMPROC)( stride_, pointer_, ptrstride_ );
}

void glFogCoordPointerListIBMWrapper(GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLFOGCOORDPOINTERLISTIBMPROC, "glFogCoordPointerListIBM");
  RESOLVED_PROC(PFNGLFOGCOORDPOINTERLISTIBMPROC)( type_, stride_, pointer_, ptrstride_ );
}

void glIndexPointerListIBMWrapper(GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLINDEXPOINTERLISTIBMPROC, "glIndexPointerListIBM");
  RESOLVED_PROC(PFNGLINDEXPOINTERLISTIBMPROC)( type_, stride_, pointer_, ptrstride_ );
}

void glNormalPointerListIBMWrapper(GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLNORMALPOINTERLISTIBMPROC, "glNormalPointerListIBM");
  RESOLVED_PROC(PFNGLNORMALPOINTERLISTIBMPROC)( type_, stride_, pointer_, ptrstride_ );
}

void glTexCoordPointerListIBMWrapper(GLint size_, GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLTEXCOORDPOINTERLISTIBMPROC, "glTexCoordPointerListIBM");
  RESOLVED_PROC(PFNGLTEXCOORDPOINTERLISTIBMPROC)( size_, type_, stride_, pointer_, ptrstride_ );
}

void glVertexPointerListIBMWrapper(GLint size_, GLenum type_, GLint stride_, const void ** pointer_, GLint ptrstride_)
{
  RESOLVE(PFNGLVERTEXPOINTERLISTIBMPROC, "glVertexPointerListIBM");
  RESOLVED_PROC(PFNGLVERTEXPOINTERLISTIBMPROC)( size_, type_, stride_, pointer_, ptrstride_ );
}

void glBlendFuncSeparateINGRWrapper(GLenum sfactorRGB_, GLenum dfactorRGB_, GLenum sfactorAlpha_, GLenum dfactorAlpha_)
{
  RESOLVE(PFNGLBLENDFUNCSEPARATEINGRPROC, "glBlendFuncSeparateINGR");
  RESOLVED_PROC(PFNGLBLENDFUNCSEPARATEINGRPROC)( sfactorRGB_, dfactorRGB_, sfactorAlpha_, dfactorAlpha_ );
}

void glApplyFramebufferAttachmentCMAAINTELWrapper(void)
{
  RESOLVE(PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC, "glApplyFramebufferAttachmentCMAAINTEL");
  RESOLVED_PROC(PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTELPROC)(  );
}

void glSyncTextureINTELWrapper(GLuint texture_)
{
  RESOLVE(PFNGLSYNCTEXTUREINTELPROC, "glSyncTextureINTEL");
  RESOLVED_PROC(PFNGLSYNCTEXTUREINTELPROC)( texture_ );
}

void glUnmapTexture2DINTELWrapper(GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLUNMAPTEXTURE2DINTELPROC, "glUnmapTexture2DINTEL");
  RESOLVED_PROC(PFNGLUNMAPTEXTURE2DINTELPROC)( texture_, level_ );
}

void * glMapTexture2DINTELWrapper(GLuint texture_, GLint level_, GLbitfield access_, GLint* stride_, GLenum* layout_)
{
  RESOLVE_RET(PFNGLMAPTEXTURE2DINTELPROC, "glMapTexture2DINTEL", FALSE);
  return RESOLVED_PROC(PFNGLMAPTEXTURE2DINTELPROC)(texture_, level_, access_, stride_, layout_ );
}

void glVertexPointervINTELWrapper(GLint size_, GLenum type_, const void ** pointer_)
{
  RESOLVE(PFNGLVERTEXPOINTERVINTELPROC, "glVertexPointervINTEL");
  RESOLVED_PROC(PFNGLVERTEXPOINTERVINTELPROC)( size_, type_, pointer_ );
}

void glNormalPointervINTELWrapper(GLenum type_, const void ** pointer_)
{
  RESOLVE(PFNGLNORMALPOINTERVINTELPROC, "glNormalPointervINTEL");
  RESOLVED_PROC(PFNGLNORMALPOINTERVINTELPROC)( type_, pointer_ );
}

void glColorPointervINTELWrapper(GLint size_, GLenum type_, const void ** pointer_)
{
  RESOLVE(PFNGLCOLORPOINTERVINTELPROC, "glColorPointervINTEL");
  RESOLVED_PROC(PFNGLCOLORPOINTERVINTELPROC)( size_, type_, pointer_ );
}

void glTexCoordPointervINTELWrapper(GLint size_, GLenum type_, const void ** pointer_)
{
  RESOLVE(PFNGLTEXCOORDPOINTERVINTELPROC, "glTexCoordPointervINTEL");
  RESOLVED_PROC(PFNGLTEXCOORDPOINTERVINTELPROC)( size_, type_, pointer_ );
}

void glBeginPerfQueryINTELWrapper(GLuint queryHandle_)
{
  RESOLVE(PFNGLBEGINPERFQUERYINTELPROC, "glBeginPerfQueryINTEL");
  RESOLVED_PROC(PFNGLBEGINPERFQUERYINTELPROC)( queryHandle_ );
}

void glCreatePerfQueryINTELWrapper(GLuint queryId_, GLuint* queryHandle_)
{
  RESOLVE(PFNGLCREATEPERFQUERYINTELPROC, "glCreatePerfQueryINTEL");
  RESOLVED_PROC(PFNGLCREATEPERFQUERYINTELPROC)( queryId_, queryHandle_ );
}

void glDeletePerfQueryINTELWrapper(GLuint queryHandle_)
{
  RESOLVE(PFNGLDELETEPERFQUERYINTELPROC, "glDeletePerfQueryINTEL");
  RESOLVED_PROC(PFNGLDELETEPERFQUERYINTELPROC)( queryHandle_ );
}

void glEndPerfQueryINTELWrapper(GLuint queryHandle_)
{
  RESOLVE(PFNGLENDPERFQUERYINTELPROC, "glEndPerfQueryINTEL");
  RESOLVED_PROC(PFNGLENDPERFQUERYINTELPROC)( queryHandle_ );
}

void glGetFirstPerfQueryIdINTELWrapper(GLuint* queryId_)
{
  RESOLVE(PFNGLGETFIRSTPERFQUERYIDINTELPROC, "glGetFirstPerfQueryIdINTEL");
  RESOLVED_PROC(PFNGLGETFIRSTPERFQUERYIDINTELPROC)( queryId_ );
}

void glGetNextPerfQueryIdINTELWrapper(GLuint queryId_, GLuint* nextQueryId_)
{
  RESOLVE(PFNGLGETNEXTPERFQUERYIDINTELPROC, "glGetNextPerfQueryIdINTEL");
  RESOLVED_PROC(PFNGLGETNEXTPERFQUERYIDINTELPROC)( queryId_, nextQueryId_ );
}

void glGetPerfCounterInfoINTELWrapper(GLuint queryId_, GLuint counterId_, GLuint counterNameLength_, GLchar* counterName_, GLuint counterDescLength_, GLchar* counterDesc_, GLuint* counterOffset_, GLuint* counterDataSize_, GLuint* counterTypeEnum_, GLuint* counterDataTypeEnum_, GLuint64* rawCounterMaxValue_)
{
  RESOLVE(PFNGLGETPERFCOUNTERINFOINTELPROC, "glGetPerfCounterInfoINTEL");
  RESOLVED_PROC(PFNGLGETPERFCOUNTERINFOINTELPROC)( queryId_, counterId_, counterNameLength_, counterName_, counterDescLength_, counterDesc_, counterOffset_, counterDataSize_, counterTypeEnum_, counterDataTypeEnum_, rawCounterMaxValue_ );
}

void glGetPerfQueryDataINTELWrapper(GLuint queryHandle_, GLuint flags_, GLsizei dataSize_, GLvoid* data_, GLuint* bytesWritten_)
{
  RESOLVE(PFNGLGETPERFQUERYDATAINTELPROC, "glGetPerfQueryDataINTEL");
  RESOLVED_PROC(PFNGLGETPERFQUERYDATAINTELPROC)( queryHandle_, flags_, dataSize_, data_, bytesWritten_ );
}

void glGetPerfQueryIdByNameINTELWrapper(GLchar* queryName_, GLuint* queryId_)
{
  RESOLVE(PFNGLGETPERFQUERYIDBYNAMEINTELPROC, "glGetPerfQueryIdByNameINTEL");
  RESOLVED_PROC(PFNGLGETPERFQUERYIDBYNAMEINTELPROC)( queryName_, queryId_ );
}

void glGetPerfQueryInfoINTELWrapper(GLuint queryId_, GLuint queryNameLength_, GLchar* queryName_, GLuint* dataSize_, GLuint* noCounters_, GLuint* noInstances_, GLuint* capsMask_)
{
  RESOLVE(PFNGLGETPERFQUERYINFOINTELPROC, "glGetPerfQueryInfoINTEL");
  RESOLVED_PROC(PFNGLGETPERFQUERYINFOINTELPROC)( queryId_, queryNameLength_, queryName_, dataSize_, noCounters_, noInstances_, capsMask_ );
}

void glResizeBuffersMESAWrapper(void)
{
  RESOLVE(PFNGLRESIZEBUFFERSMESAPROC, "glResizeBuffersMESA");
  RESOLVED_PROC(PFNGLRESIZEBUFFERSMESAPROC)(  );
}

void glWindowPos2dMESAWrapper(GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLWINDOWPOS2DMESAPROC, "glWindowPos2dMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2DMESAPROC)( x_, y_ );
}

void glWindowPos2dvMESAWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS2DVMESAPROC, "glWindowPos2dvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2DVMESAPROC)( v_ );
}

void glWindowPos2fMESAWrapper(GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLWINDOWPOS2FMESAPROC, "glWindowPos2fMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2FMESAPROC)( x_, y_ );
}

void glWindowPos2fvMESAWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS2FVMESAPROC, "glWindowPos2fvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2FVMESAPROC)( v_ );
}

void glWindowPos2iMESAWrapper(GLint x_, GLint y_)
{
  RESOLVE(PFNGLWINDOWPOS2IMESAPROC, "glWindowPos2iMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2IMESAPROC)( x_, y_ );
}

void glWindowPos2ivMESAWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS2IVMESAPROC, "glWindowPos2ivMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2IVMESAPROC)( v_ );
}

void glWindowPos2sMESAWrapper(GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLWINDOWPOS2SMESAPROC, "glWindowPos2sMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2SMESAPROC)( x_, y_ );
}

void glWindowPos2svMESAWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS2SVMESAPROC, "glWindowPos2svMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS2SVMESAPROC)( v_ );
}

void glWindowPos3dMESAWrapper(GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLWINDOWPOS3DMESAPROC, "glWindowPos3dMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3DMESAPROC)( x_, y_, z_ );
}

void glWindowPos3dvMESAWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS3DVMESAPROC, "glWindowPos3dvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3DVMESAPROC)( v_ );
}

void glWindowPos3fMESAWrapper(GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLWINDOWPOS3FMESAPROC, "glWindowPos3fMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3FMESAPROC)( x_, y_, z_ );
}

void glWindowPos3fvMESAWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS3FVMESAPROC, "glWindowPos3fvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3FVMESAPROC)( v_ );
}

void glWindowPos3iMESAWrapper(GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLWINDOWPOS3IMESAPROC, "glWindowPos3iMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3IMESAPROC)( x_, y_, z_ );
}

void glWindowPos3ivMESAWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS3IVMESAPROC, "glWindowPos3ivMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3IVMESAPROC)( v_ );
}

void glWindowPos3sMESAWrapper(GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLWINDOWPOS3SMESAPROC, "glWindowPos3sMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3SMESAPROC)( x_, y_, z_ );
}

void glWindowPos3svMESAWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS3SVMESAPROC, "glWindowPos3svMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS3SVMESAPROC)( v_ );
}

void glWindowPos4dMESAWrapper(GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLWINDOWPOS4DMESAPROC, "glWindowPos4dMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4DMESAPROC)( x_, y_, z_, w_ );
}

void glWindowPos4dvMESAWrapper(const GLdouble* v_)
{
  RESOLVE(PFNGLWINDOWPOS4DVMESAPROC, "glWindowPos4dvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4DVMESAPROC)( v_ );
}

void glWindowPos4fMESAWrapper(GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLWINDOWPOS4FMESAPROC, "glWindowPos4fMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4FMESAPROC)( x_, y_, z_, w_ );
}

void glWindowPos4fvMESAWrapper(const GLfloat* v_)
{
  RESOLVE(PFNGLWINDOWPOS4FVMESAPROC, "glWindowPos4fvMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4FVMESAPROC)( v_ );
}

void glWindowPos4iMESAWrapper(GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLWINDOWPOS4IMESAPROC, "glWindowPos4iMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4IMESAPROC)( x_, y_, z_, w_ );
}

void glWindowPos4ivMESAWrapper(const GLint* v_)
{
  RESOLVE(PFNGLWINDOWPOS4IVMESAPROC, "glWindowPos4ivMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4IVMESAPROC)( v_ );
}

void glWindowPos4sMESAWrapper(GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  RESOLVE(PFNGLWINDOWPOS4SMESAPROC, "glWindowPos4sMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4SMESAPROC)( x_, y_, z_, w_ );
}

void glWindowPos4svMESAWrapper(const GLshort* v_)
{
  RESOLVE(PFNGLWINDOWPOS4SVMESAPROC, "glWindowPos4svMESA");
  RESOLVED_PROC(PFNGLWINDOWPOS4SVMESAPROC)( v_ );
}

void glBeginConditionalRenderNVXWrapper(GLuint id_)
{
  RESOLVE(PFNGLBEGINCONDITIONALRENDERNVXPROC, "glBeginConditionalRenderNVX");
  RESOLVED_PROC(PFNGLBEGINCONDITIONALRENDERNVXPROC)( id_ );
}

void glEndConditionalRenderNVXWrapper(void)
{
  RESOLVE(PFNGLENDCONDITIONALRENDERNVXPROC, "glEndConditionalRenderNVX");
  RESOLVED_PROC(PFNGLENDCONDITIONALRENDERNVXPROC)(  );
}

void glMultiDrawArraysIndirectBindlessNVWrapper(GLenum mode_, const void * indirect_, GLsizei drawCount_, GLsizei stride_, GLint vertexBufferCount_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC, "glMultiDrawArraysIndirectBindlessNV");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC)( mode_, indirect_, drawCount_, stride_, vertexBufferCount_ );
}

void glMultiDrawElementsIndirectBindlessNVWrapper(GLenum mode_, GLenum type_, const void * indirect_, GLsizei drawCount_, GLsizei stride_, GLint vertexBufferCount_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC, "glMultiDrawElementsIndirectBindlessNV");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC)( mode_, type_, indirect_, drawCount_, stride_, vertexBufferCount_ );
}

void glMultiDrawArraysIndirectBindlessCountNVWrapper(GLenum mode_, const void * indirect_, GLsizei drawCount_, GLsizei maxDrawCount_, GLsizei stride_, GLint vertexBufferCount_)
{
  RESOLVE(PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC, "glMultiDrawArraysIndirectBindlessCountNV");
  RESOLVED_PROC(PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNVPROC)( mode_, indirect_, drawCount_, maxDrawCount_, stride_, vertexBufferCount_ );
}

void glMultiDrawElementsIndirectBindlessCountNVWrapper(GLenum mode_, GLenum type_, const void * indirect_, GLsizei drawCount_, GLsizei maxDrawCount_, GLsizei stride_, GLint vertexBufferCount_)
{
  RESOLVE(PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC, "glMultiDrawElementsIndirectBindlessCountNV");
  RESOLVED_PROC(PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNVPROC)( mode_, type_, indirect_, drawCount_, maxDrawCount_, stride_, vertexBufferCount_ );
}

GLuint64 glGetTextureHandleNVWrapper(GLuint texture_)
{
  RESOLVE_RET(PFNGLGETTEXTUREHANDLENVPROC, "glGetTextureHandleNV", FALSE);
  return RESOLVED_PROC(PFNGLGETTEXTUREHANDLENVPROC)(texture_ );
}

GLuint64 glGetTextureSamplerHandleNVWrapper(GLuint texture_, GLuint sampler_)
{
  RESOLVE_RET(PFNGLGETTEXTURESAMPLERHANDLENVPROC, "glGetTextureSamplerHandleNV", FALSE);
  return RESOLVED_PROC(PFNGLGETTEXTURESAMPLERHANDLENVPROC)(texture_, sampler_ );
}

void glMakeTextureHandleResidentNVWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKETEXTUREHANDLERESIDENTNVPROC, "glMakeTextureHandleResidentNV");
  RESOLVED_PROC(PFNGLMAKETEXTUREHANDLERESIDENTNVPROC)( handle_ );
}

void glMakeTextureHandleNonResidentNVWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC, "glMakeTextureHandleNonResidentNV");
  RESOLVED_PROC(PFNGLMAKETEXTUREHANDLENONRESIDENTNVPROC)( handle_ );
}

GLuint64 glGetImageHandleNVWrapper(GLuint texture_, GLint level_, GLboolean layered_, GLint layer_, GLenum format_)
{
  RESOLVE_RET(PFNGLGETIMAGEHANDLENVPROC, "glGetImageHandleNV", FALSE);
  return RESOLVED_PROC(PFNGLGETIMAGEHANDLENVPROC)(texture_, level_, layered_, layer_, format_ );
}

void glMakeImageHandleResidentNVWrapper(GLuint64 handle_, GLenum access_)
{
  RESOLVE(PFNGLMAKEIMAGEHANDLERESIDENTNVPROC, "glMakeImageHandleResidentNV");
  RESOLVED_PROC(PFNGLMAKEIMAGEHANDLERESIDENTNVPROC)( handle_, access_ );
}

void glMakeImageHandleNonResidentNVWrapper(GLuint64 handle_)
{
  RESOLVE(PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC, "glMakeImageHandleNonResidentNV");
  RESOLVED_PROC(PFNGLMAKEIMAGEHANDLENONRESIDENTNVPROC)( handle_ );
}

void glUniformHandleui64NVWrapper(GLint location_, GLuint64 value_)
{
  RESOLVE(PFNGLUNIFORMHANDLEUI64NVPROC, "glUniformHandleui64NV");
  RESOLVED_PROC(PFNGLUNIFORMHANDLEUI64NVPROC)( location_, value_ );
}

void glUniformHandleui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64* value_)
{
  RESOLVE(PFNGLUNIFORMHANDLEUI64VNVPROC, "glUniformHandleui64vNV");
  RESOLVED_PROC(PFNGLUNIFORMHANDLEUI64VNVPROC)( location_, count_, value_ );
}

void glProgramUniformHandleui64NVWrapper(GLuint program_, GLint location_, GLuint64 value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC, "glProgramUniformHandleui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMHANDLEUI64NVPROC)( program_, location_, value_ );
}

void glProgramUniformHandleui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64* values_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC, "glProgramUniformHandleui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMHANDLEUI64VNVPROC)( program_, location_, count_, values_ );
}

GLboolean glIsTextureHandleResidentNVWrapper(GLuint64 handle_)
{
  RESOLVE_RET(PFNGLISTEXTUREHANDLERESIDENTNVPROC, "glIsTextureHandleResidentNV", FALSE);
  return RESOLVED_PROC(PFNGLISTEXTUREHANDLERESIDENTNVPROC)(handle_ );
}

GLboolean glIsImageHandleResidentNVWrapper(GLuint64 handle_)
{
  RESOLVE_RET(PFNGLISIMAGEHANDLERESIDENTNVPROC, "glIsImageHandleResidentNV", FALSE);
  return RESOLVED_PROC(PFNGLISIMAGEHANDLERESIDENTNVPROC)(handle_ );
}

void glBlendParameteriNVWrapper(GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLBLENDPARAMETERINVPROC, "glBlendParameteriNV");
  RESOLVED_PROC(PFNGLBLENDPARAMETERINVPROC)( pname_, value_ );
}

void glBlendBarrierNVWrapper(void)
{
  RESOLVE(PFNGLBLENDBARRIERNVPROC, "glBlendBarrierNV");
  RESOLVED_PROC(PFNGLBLENDBARRIERNVPROC)(  );
}

void glCreateStatesNVWrapper(GLsizei n_, GLuint* states_)
{
  RESOLVE(PFNGLCREATESTATESNVPROC, "glCreateStatesNV");
  RESOLVED_PROC(PFNGLCREATESTATESNVPROC)( n_, states_ );
}

void glDeleteStatesNVWrapper(GLsizei n_, const GLuint* states_)
{
  RESOLVE(PFNGLDELETESTATESNVPROC, "glDeleteStatesNV");
  RESOLVED_PROC(PFNGLDELETESTATESNVPROC)( n_, states_ );
}

GLboolean glIsStateNVWrapper(GLuint state_)
{
  RESOLVE_RET(PFNGLISSTATENVPROC, "glIsStateNV", FALSE);
  return RESOLVED_PROC(PFNGLISSTATENVPROC)(state_ );
}

void glStateCaptureNVWrapper(GLuint state_, GLenum mode_)
{
  RESOLVE(PFNGLSTATECAPTURENVPROC, "glStateCaptureNV");
  RESOLVED_PROC(PFNGLSTATECAPTURENVPROC)( state_, mode_ );
}

GLuint glGetCommandHeaderNVWrapper(GLenum tokenID_, GLuint size_)
{
  RESOLVE_RET(PFNGLGETCOMMANDHEADERNVPROC, "glGetCommandHeaderNV", FALSE);
  return RESOLVED_PROC(PFNGLGETCOMMANDHEADERNVPROC)(tokenID_, size_ );
}

GLushort glGetStageIndexNVWrapper(GLenum shadertype_)
{
  RESOLVE_RET(PFNGLGETSTAGEINDEXNVPROC, "glGetStageIndexNV", FALSE);
  return RESOLVED_PROC(PFNGLGETSTAGEINDEXNVPROC)(shadertype_ );
}

void glDrawCommandsNVWrapper(GLenum primitiveMode_, GLuint buffer_, const GLintptr* indirects_, const GLsizei* sizes_, GLuint count_)
{
  RESOLVE(PFNGLDRAWCOMMANDSNVPROC, "glDrawCommandsNV");
  RESOLVED_PROC(PFNGLDRAWCOMMANDSNVPROC)( primitiveMode_, buffer_, indirects_, sizes_, count_ );
}

void glDrawCommandsAddressNVWrapper(GLenum primitiveMode_, const GLuint64* indirects_, const GLsizei* sizes_, GLuint count_)
{
  RESOLVE(PFNGLDRAWCOMMANDSADDRESSNVPROC, "glDrawCommandsAddressNV");
  RESOLVED_PROC(PFNGLDRAWCOMMANDSADDRESSNVPROC)( primitiveMode_, indirects_, sizes_, count_ );
}

void glDrawCommandsStatesNVWrapper(GLuint buffer_, const GLintptr* indirects_, const GLsizei* sizes_, const GLuint* states_, const GLuint* fbos_, GLuint count_)
{
  RESOLVE(PFNGLDRAWCOMMANDSSTATESNVPROC, "glDrawCommandsStatesNV");
  RESOLVED_PROC(PFNGLDRAWCOMMANDSSTATESNVPROC)( buffer_, indirects_, sizes_, states_, fbos_, count_ );
}

void glDrawCommandsStatesAddressNVWrapper(const GLuint64* indirects_, const GLsizei* sizes_, const GLuint* states_, const GLuint* fbos_, GLuint count_)
{
  RESOLVE(PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC, "glDrawCommandsStatesAddressNV");
  RESOLVED_PROC(PFNGLDRAWCOMMANDSSTATESADDRESSNVPROC)( indirects_, sizes_, states_, fbos_, count_ );
}

void glCreateCommandListsNVWrapper(GLsizei n_, GLuint* lists_)
{
  RESOLVE(PFNGLCREATECOMMANDLISTSNVPROC, "glCreateCommandListsNV");
  RESOLVED_PROC(PFNGLCREATECOMMANDLISTSNVPROC)( n_, lists_ );
}

void glDeleteCommandListsNVWrapper(GLsizei n_, const GLuint* lists_)
{
  RESOLVE(PFNGLDELETECOMMANDLISTSNVPROC, "glDeleteCommandListsNV");
  RESOLVED_PROC(PFNGLDELETECOMMANDLISTSNVPROC)( n_, lists_ );
}

GLboolean glIsCommandListNVWrapper(GLuint list_)
{
  RESOLVE_RET(PFNGLISCOMMANDLISTNVPROC, "glIsCommandListNV", FALSE);
  return RESOLVED_PROC(PFNGLISCOMMANDLISTNVPROC)(list_ );
}

void glListDrawCommandsStatesClientNVWrapper(GLuint list_, GLuint segment_, const void ** indirects_, const GLsizei* sizes_, const GLuint* states_, const GLuint* fbos_, GLuint count_)
{
  RESOLVE(PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC, "glListDrawCommandsStatesClientNV");
  RESOLVED_PROC(PFNGLLISTDRAWCOMMANDSSTATESCLIENTNVPROC)( list_, segment_, indirects_, sizes_, states_, fbos_, count_ );
}

void glCommandListSegmentsNVWrapper(GLuint list_, GLuint segments_)
{
  RESOLVE(PFNGLCOMMANDLISTSEGMENTSNVPROC, "glCommandListSegmentsNV");
  RESOLVED_PROC(PFNGLCOMMANDLISTSEGMENTSNVPROC)( list_, segments_ );
}

void glCompileCommandListNVWrapper(GLuint list_)
{
  RESOLVE(PFNGLCOMPILECOMMANDLISTNVPROC, "glCompileCommandListNV");
  RESOLVED_PROC(PFNGLCOMPILECOMMANDLISTNVPROC)( list_ );
}

void glCallCommandListNVWrapper(GLuint list_)
{
  RESOLVE(PFNGLCALLCOMMANDLISTNVPROC, "glCallCommandListNV");
  RESOLVED_PROC(PFNGLCALLCOMMANDLISTNVPROC)( list_ );
}

void glBeginConditionalRenderNVWrapper(GLuint id_, GLenum mode_)
{
  RESOLVE(PFNGLBEGINCONDITIONALRENDERNVPROC, "glBeginConditionalRenderNV");
  RESOLVED_PROC(PFNGLBEGINCONDITIONALRENDERNVPROC)( id_, mode_ );
}

void glEndConditionalRenderNVWrapper(void)
{
  RESOLVE(PFNGLENDCONDITIONALRENDERNVPROC, "glEndConditionalRenderNV");
  RESOLVED_PROC(PFNGLENDCONDITIONALRENDERNVPROC)(  );
}

void glSubpixelPrecisionBiasNVWrapper(GLuint xbits_, GLuint ybits_)
{
  RESOLVE(PFNGLSUBPIXELPRECISIONBIASNVPROC, "glSubpixelPrecisionBiasNV");
  RESOLVED_PROC(PFNGLSUBPIXELPRECISIONBIASNVPROC)( xbits_, ybits_ );
}

void glConservativeRasterParameterfNVWrapper(GLenum pname_, GLfloat value_)
{
  RESOLVE(PFNGLCONSERVATIVERASTERPARAMETERFNVPROC, "glConservativeRasterParameterfNV");
  RESOLVED_PROC(PFNGLCONSERVATIVERASTERPARAMETERFNVPROC)( pname_, value_ );
}

void glCopyImageSubDataNVWrapper(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 width_, GLsizei height_, GLsizei depth_)
{
  RESOLVE(PFNGLCOPYIMAGESUBDATANVPROC, "glCopyImageSubDataNV");
  RESOLVED_PROC(PFNGLCOPYIMAGESUBDATANVPROC)( srcName_, srcTarget_, srcLevel_, srcX_, srcY_, srcZ_, dstName_, dstTarget_, dstLevel_, dstX_, dstY_, dstZ_, width_, height_, depth_ );
}

void glDepthRangedNVWrapper(GLdouble zNear_, GLdouble zFar_)
{
  RESOLVE(PFNGLDEPTHRANGEDNVPROC, "glDepthRangedNV");
  RESOLVED_PROC(PFNGLDEPTHRANGEDNVPROC)( zNear_, zFar_ );
}

void glClearDepthdNVWrapper(GLdouble depth_)
{
  RESOLVE(PFNGLCLEARDEPTHDNVPROC, "glClearDepthdNV");
  RESOLVED_PROC(PFNGLCLEARDEPTHDNVPROC)( depth_ );
}

void glDepthBoundsdNVWrapper(GLdouble zmin_, GLdouble zmax_)
{
  RESOLVE(PFNGLDEPTHBOUNDSDNVPROC, "glDepthBoundsdNV");
  RESOLVED_PROC(PFNGLDEPTHBOUNDSDNVPROC)( zmin_, zmax_ );
}

void glDrawTextureNVWrapper(GLuint texture_, GLuint sampler_, GLfloat x0_, GLfloat y0_, GLfloat x1_, GLfloat y1_, GLfloat z_, GLfloat s0_, GLfloat t0_, GLfloat s1_, GLfloat t1_)
{
  RESOLVE(PFNGLDRAWTEXTURENVPROC, "glDrawTextureNV");
  RESOLVED_PROC(PFNGLDRAWTEXTURENVPROC)( texture_, sampler_, x0_, y0_, x1_, y1_, z_, s0_, t0_, s1_, t1_ );
}

void glMapControlPointsNVWrapper(GLenum target_, GLuint index_, GLenum type_, GLsizei ustride_, GLsizei vstride_, GLint uorder_, GLint vorder_, GLboolean packed_, const void * points_)
{
  RESOLVE(PFNGLMAPCONTROLPOINTSNVPROC, "glMapControlPointsNV");
  RESOLVED_PROC(PFNGLMAPCONTROLPOINTSNVPROC)( target_, index_, type_, ustride_, vstride_, uorder_, vorder_, packed_, points_ );
}

void glMapParameterivNVWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLMAPPARAMETERIVNVPROC, "glMapParameterivNV");
  RESOLVED_PROC(PFNGLMAPPARAMETERIVNVPROC)( target_, pname_, params_ );
}

void glMapParameterfvNVWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLMAPPARAMETERFVNVPROC, "glMapParameterfvNV");
  RESOLVED_PROC(PFNGLMAPPARAMETERFVNVPROC)( target_, pname_, params_ );
}

void glGetMapControlPointsNVWrapper(GLenum target_, GLuint index_, GLenum type_, GLsizei ustride_, GLsizei vstride_, GLboolean packed_, void * points_)
{
  RESOLVE(PFNGLGETMAPCONTROLPOINTSNVPROC, "glGetMapControlPointsNV");
  RESOLVED_PROC(PFNGLGETMAPCONTROLPOINTSNVPROC)( target_, index_, type_, ustride_, vstride_, packed_, points_ );
}

void glGetMapParameterivNVWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMAPPARAMETERIVNVPROC, "glGetMapParameterivNV");
  RESOLVED_PROC(PFNGLGETMAPPARAMETERIVNVPROC)( target_, pname_, params_ );
}

void glGetMapParameterfvNVWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMAPPARAMETERFVNVPROC, "glGetMapParameterfvNV");
  RESOLVED_PROC(PFNGLGETMAPPARAMETERFVNVPROC)( target_, pname_, params_ );
}

void glGetMapAttribParameterivNVWrapper(GLenum target_, GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETMAPATTRIBPARAMETERIVNVPROC, "glGetMapAttribParameterivNV");
  RESOLVED_PROC(PFNGLGETMAPATTRIBPARAMETERIVNVPROC)( target_, index_, pname_, params_ );
}

void glGetMapAttribParameterfvNVWrapper(GLenum target_, GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETMAPATTRIBPARAMETERFVNVPROC, "glGetMapAttribParameterfvNV");
  RESOLVED_PROC(PFNGLGETMAPATTRIBPARAMETERFVNVPROC)( target_, index_, pname_, params_ );
}

void glEvalMapsNVWrapper(GLenum target_, GLenum mode_)
{
  RESOLVE(PFNGLEVALMAPSNVPROC, "glEvalMapsNV");
  RESOLVED_PROC(PFNGLEVALMAPSNVPROC)( target_, mode_ );
}

void glGetMultisamplefvNVWrapper(GLenum pname_, GLuint index_, GLfloat* val_)
{
  RESOLVE(PFNGLGETMULTISAMPLEFVNVPROC, "glGetMultisamplefvNV");
  RESOLVED_PROC(PFNGLGETMULTISAMPLEFVNVPROC)( pname_, index_, val_ );
}

void glSampleMaskIndexedNVWrapper(GLuint index_, GLbitfield mask_)
{
  RESOLVE(PFNGLSAMPLEMASKINDEXEDNVPROC, "glSampleMaskIndexedNV");
  RESOLVED_PROC(PFNGLSAMPLEMASKINDEXEDNVPROC)( index_, mask_ );
}

void glTexRenderbufferNVWrapper(GLenum target_, GLuint renderbuffer_)
{
  RESOLVE(PFNGLTEXRENDERBUFFERNVPROC, "glTexRenderbufferNV");
  RESOLVED_PROC(PFNGLTEXRENDERBUFFERNVPROC)( target_, renderbuffer_ );
}

void glDeleteFencesNVWrapper(GLsizei n_, const GLuint* fences_)
{
  RESOLVE(PFNGLDELETEFENCESNVPROC, "glDeleteFencesNV");
  RESOLVED_PROC(PFNGLDELETEFENCESNVPROC)( n_, fences_ );
}

void glGenFencesNVWrapper(GLsizei n_, GLuint* fences_)
{
  RESOLVE(PFNGLGENFENCESNVPROC, "glGenFencesNV");
  RESOLVED_PROC(PFNGLGENFENCESNVPROC)( n_, fences_ );
}

GLboolean glIsFenceNVWrapper(GLuint fence_)
{
  RESOLVE_RET(PFNGLISFENCENVPROC, "glIsFenceNV", FALSE);
  return RESOLVED_PROC(PFNGLISFENCENVPROC)(fence_ );
}

GLboolean glTestFenceNVWrapper(GLuint fence_)
{
  RESOLVE_RET(PFNGLTESTFENCENVPROC, "glTestFenceNV", FALSE);
  return RESOLVED_PROC(PFNGLTESTFENCENVPROC)(fence_ );
}

void glGetFenceivNVWrapper(GLuint fence_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFENCEIVNVPROC, "glGetFenceivNV");
  RESOLVED_PROC(PFNGLGETFENCEIVNVPROC)( fence_, pname_, params_ );
}

void glFinishFenceNVWrapper(GLuint fence_)
{
  RESOLVE(PFNGLFINISHFENCENVPROC, "glFinishFenceNV");
  RESOLVED_PROC(PFNGLFINISHFENCENVPROC)( fence_ );
}

void glSetFenceNVWrapper(GLuint fence_, GLenum condition_)
{
  RESOLVE(PFNGLSETFENCENVPROC, "glSetFenceNV");
  RESOLVED_PROC(PFNGLSETFENCENVPROC)( fence_, condition_ );
}

void glFragmentCoverageColorNVWrapper(GLuint color_)
{
  RESOLVE(PFNGLFRAGMENTCOVERAGECOLORNVPROC, "glFragmentCoverageColorNV");
  RESOLVED_PROC(PFNGLFRAGMENTCOVERAGECOLORNVPROC)( color_ );
}

void glProgramNamedParameter4fNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLPROGRAMNAMEDPARAMETER4FNVPROC, "glProgramNamedParameter4fNV");
  RESOLVED_PROC(PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)( id_, len_, name_, x_, y_, z_, w_ );
}

void glProgramNamedParameter4fvNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, const GLfloat* v_)
{
  RESOLVE(PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC, "glProgramNamedParameter4fvNV");
  RESOLVED_PROC(PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)( id_, len_, name_, v_ );
}

void glProgramNamedParameter4dNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLPROGRAMNAMEDPARAMETER4DNVPROC, "glProgramNamedParameter4dNV");
  RESOLVED_PROC(PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)( id_, len_, name_, x_, y_, z_, w_ );
}

void glProgramNamedParameter4dvNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, const GLdouble* v_)
{
  RESOLVE(PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC, "glProgramNamedParameter4dvNV");
  RESOLVED_PROC(PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)( id_, len_, name_, v_ );
}

void glGetProgramNamedParameterfvNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC, "glGetProgramNamedParameterfvNV");
  RESOLVED_PROC(PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)( id_, len_, name_, params_ );
}

void glGetProgramNamedParameterdvNVWrapper(GLuint id_, GLsizei len_, const GLubyte* name_, GLdouble* params_)
{
  RESOLVE(PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC, "glGetProgramNamedParameterdvNV");
  RESOLVED_PROC(PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)( id_, len_, name_, params_ );
}

void glCoverageModulationTableNVWrapper(GLsizei n_, const GLfloat* v_)
{
  RESOLVE(PFNGLCOVERAGEMODULATIONTABLENVPROC, "glCoverageModulationTableNV");
  RESOLVED_PROC(PFNGLCOVERAGEMODULATIONTABLENVPROC)( n_, v_ );
}

void glGetCoverageModulationTableNVWrapper(GLsizei bufsize_, GLfloat* v_)
{
  RESOLVE(PFNGLGETCOVERAGEMODULATIONTABLENVPROC, "glGetCoverageModulationTableNV");
  RESOLVED_PROC(PFNGLGETCOVERAGEMODULATIONTABLENVPROC)( bufsize_, v_ );
}

void glCoverageModulationNVWrapper(GLenum components_)
{
  RESOLVE(PFNGLCOVERAGEMODULATIONNVPROC, "glCoverageModulationNV");
  RESOLVED_PROC(PFNGLCOVERAGEMODULATIONNVPROC)( components_ );
}

void glRenderbufferStorageMultisampleCoverageNVWrapper(GLenum target_, GLsizei coverageSamples_, GLsizei colorSamples_, GLenum internalformat_, GLsizei width_, GLsizei height_)
{
  RESOLVE(PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC, "glRenderbufferStorageMultisampleCoverageNV");
  RESOLVED_PROC(PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)( target_, coverageSamples_, colorSamples_, internalformat_, width_, height_ );
}

void glProgramVertexLimitNVWrapper(GLenum target_, GLint limit_)
{
  RESOLVE(PFNGLPROGRAMVERTEXLIMITNVPROC, "glProgramVertexLimitNV");
  RESOLVED_PROC(PFNGLPROGRAMVERTEXLIMITNVPROC)( target_, limit_ );
}

void glFramebufferTextureEXTWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREEXTPROC, "glFramebufferTextureEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREEXTPROC)( target_, attachment_, texture_, level_ );
}

void glFramebufferTextureFaceEXTWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLenum face_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC, "glFramebufferTextureFaceEXT");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)( target_, attachment_, texture_, level_, face_ );
}

void glProgramLocalParameterI4iNVWrapper(GLenum target_, GLuint index_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERI4INVPROC, "glProgramLocalParameterI4iNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERI4INVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramLocalParameterI4ivNVWrapper(GLenum target_, GLuint index_, const GLint* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC, "glProgramLocalParameterI4ivNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)( target_, index_, params_ );
}

void glProgramLocalParametersI4ivNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLint* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC, "glProgramLocalParametersI4ivNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)( target_, index_, count_, params_ );
}

void glProgramLocalParameterI4uiNVWrapper(GLenum target_, GLuint index_, GLuint x_, GLuint y_, GLuint z_, GLuint w_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERI4UINVPROC, "glProgramLocalParameterI4uiNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramLocalParameterI4uivNVWrapper(GLenum target_, GLuint index_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC, "glProgramLocalParameterI4uivNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)( target_, index_, params_ );
}

void glProgramLocalParametersI4uivNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC, "glProgramLocalParametersI4uivNV");
  RESOLVED_PROC(PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)( target_, index_, count_, params_ );
}

void glProgramEnvParameterI4iNVWrapper(GLenum target_, GLuint index_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERI4INVPROC, "glProgramEnvParameterI4iNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERI4INVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramEnvParameterI4ivNVWrapper(GLenum target_, GLuint index_, const GLint* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERI4IVNVPROC, "glProgramEnvParameterI4ivNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERI4IVNVPROC)( target_, index_, params_ );
}

void glProgramEnvParametersI4ivNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLint* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERSI4IVNVPROC, "glProgramEnvParametersI4ivNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)( target_, index_, count_, params_ );
}

void glProgramEnvParameterI4uiNVWrapper(GLenum target_, GLuint index_, GLuint x_, GLuint y_, GLuint z_, GLuint w_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERI4UINVPROC, "glProgramEnvParameterI4uiNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERI4UINVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramEnvParameterI4uivNVWrapper(GLenum target_, GLuint index_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERI4UIVNVPROC, "glProgramEnvParameterI4uivNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)( target_, index_, params_ );
}

void glProgramEnvParametersI4uivNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC, "glProgramEnvParametersI4uivNV");
  RESOLVED_PROC(PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)( target_, index_, count_, params_ );
}

void glGetProgramLocalParameterIivNVWrapper(GLenum target_, GLuint index_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC, "glGetProgramLocalParameterIivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC)( target_, index_, params_ );
}

void glGetProgramLocalParameterIuivNVWrapper(GLenum target_, GLuint index_, GLuint* params_)
{
  RESOLVE(PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC, "glGetProgramLocalParameterIuivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC)( target_, index_, params_ );
}

void glGetProgramEnvParameterIivNVWrapper(GLenum target_, GLuint index_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMENVPARAMETERIIVNVPROC, "glGetProgramEnvParameterIivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMENVPARAMETERIIVNVPROC)( target_, index_, params_ );
}

void glGetProgramEnvParameterIuivNVWrapper(GLenum target_, GLuint index_, GLuint* params_)
{
  RESOLVE(PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC, "glGetProgramEnvParameterIuivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC)( target_, index_, params_ );
}

void glProgramSubroutineParametersuivNVWrapper(GLenum target_, GLsizei count_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC, "glProgramSubroutineParametersuivNV");
  RESOLVED_PROC(PFNGLPROGRAMSUBROUTINEPARAMETERSUIVNVPROC)( target_, count_, params_ );
}

void glGetProgramSubroutineParameteruivNVWrapper(GLenum target_, GLuint index_, GLuint* param_)
{
  RESOLVE(PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC, "glGetProgramSubroutineParameteruivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC)( target_, index_, param_ );
}

void glVertex2hNVWrapper(GLhalfNV x_, GLhalfNV y_)
{
  RESOLVE(PFNGLVERTEX2HNVPROC, "glVertex2hNV");
  RESOLVED_PROC(PFNGLVERTEX2HNVPROC)( x_, y_ );
}

void glVertex2hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEX2HVNVPROC, "glVertex2hvNV");
  RESOLVED_PROC(PFNGLVERTEX2HVNVPROC)( v_ );
}

void glVertex3hNVWrapper(GLhalfNV x_, GLhalfNV y_, GLhalfNV z_)
{
  RESOLVE(PFNGLVERTEX3HNVPROC, "glVertex3hNV");
  RESOLVED_PROC(PFNGLVERTEX3HNVPROC)( x_, y_, z_ );
}

void glVertex3hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEX3HVNVPROC, "glVertex3hvNV");
  RESOLVED_PROC(PFNGLVERTEX3HVNVPROC)( v_ );
}

void glVertex4hNVWrapper(GLhalfNV x_, GLhalfNV y_, GLhalfNV z_, GLhalfNV w_)
{
  RESOLVE(PFNGLVERTEX4HNVPROC, "glVertex4hNV");
  RESOLVED_PROC(PFNGLVERTEX4HNVPROC)( x_, y_, z_, w_ );
}

void glVertex4hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEX4HVNVPROC, "glVertex4hvNV");
  RESOLVED_PROC(PFNGLVERTEX4HVNVPROC)( v_ );
}

void glNormal3hNVWrapper(GLhalfNV nx_, GLhalfNV ny_, GLhalfNV nz_)
{
  RESOLVE(PFNGLNORMAL3HNVPROC, "glNormal3hNV");
  RESOLVED_PROC(PFNGLNORMAL3HNVPROC)( nx_, ny_, nz_ );
}

void glNormal3hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLNORMAL3HVNVPROC, "glNormal3hvNV");
  RESOLVED_PROC(PFNGLNORMAL3HVNVPROC)( v_ );
}

void glColor3hNVWrapper(GLhalfNV red_, GLhalfNV green_, GLhalfNV blue_)
{
  RESOLVE(PFNGLCOLOR3HNVPROC, "glColor3hNV");
  RESOLVED_PROC(PFNGLCOLOR3HNVPROC)( red_, green_, blue_ );
}

void glColor3hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLCOLOR3HVNVPROC, "glColor3hvNV");
  RESOLVED_PROC(PFNGLCOLOR3HVNVPROC)( v_ );
}

void glColor4hNVWrapper(GLhalfNV red_, GLhalfNV green_, GLhalfNV blue_, GLhalfNV alpha_)
{
  RESOLVE(PFNGLCOLOR4HNVPROC, "glColor4hNV");
  RESOLVED_PROC(PFNGLCOLOR4HNVPROC)( red_, green_, blue_, alpha_ );
}

void glColor4hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLCOLOR4HVNVPROC, "glColor4hvNV");
  RESOLVED_PROC(PFNGLCOLOR4HVNVPROC)( v_ );
}

void glTexCoord1hNVWrapper(GLhalfNV s_)
{
  RESOLVE(PFNGLTEXCOORD1HNVPROC, "glTexCoord1hNV");
  RESOLVED_PROC(PFNGLTEXCOORD1HNVPROC)( s_ );
}

void glTexCoord1hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLTEXCOORD1HVNVPROC, "glTexCoord1hvNV");
  RESOLVED_PROC(PFNGLTEXCOORD1HVNVPROC)( v_ );
}

void glTexCoord2hNVWrapper(GLhalfNV s_, GLhalfNV t_)
{
  RESOLVE(PFNGLTEXCOORD2HNVPROC, "glTexCoord2hNV");
  RESOLVED_PROC(PFNGLTEXCOORD2HNVPROC)( s_, t_ );
}

void glTexCoord2hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLTEXCOORD2HVNVPROC, "glTexCoord2hvNV");
  RESOLVED_PROC(PFNGLTEXCOORD2HVNVPROC)( v_ );
}

void glTexCoord3hNVWrapper(GLhalfNV s_, GLhalfNV t_, GLhalfNV r_)
{
  RESOLVE(PFNGLTEXCOORD3HNVPROC, "glTexCoord3hNV");
  RESOLVED_PROC(PFNGLTEXCOORD3HNVPROC)( s_, t_, r_ );
}

void glTexCoord3hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLTEXCOORD3HVNVPROC, "glTexCoord3hvNV");
  RESOLVED_PROC(PFNGLTEXCOORD3HVNVPROC)( v_ );
}

void glTexCoord4hNVWrapper(GLhalfNV s_, GLhalfNV t_, GLhalfNV r_, GLhalfNV q_)
{
  RESOLVE(PFNGLTEXCOORD4HNVPROC, "glTexCoord4hNV");
  RESOLVED_PROC(PFNGLTEXCOORD4HNVPROC)( s_, t_, r_, q_ );
}

void glTexCoord4hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLTEXCOORD4HVNVPROC, "glTexCoord4hvNV");
  RESOLVED_PROC(PFNGLTEXCOORD4HVNVPROC)( v_ );
}

void glMultiTexCoord1hNVWrapper(GLenum target_, GLhalfNV s_)
{
  RESOLVE(PFNGLMULTITEXCOORD1HNVPROC, "glMultiTexCoord1hNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1HNVPROC)( target_, s_ );
}

void glMultiTexCoord1hvNVWrapper(GLenum target_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD1HVNVPROC, "glMultiTexCoord1hvNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD1HVNVPROC)( target_, v_ );
}

void glMultiTexCoord2hNVWrapper(GLenum target_, GLhalfNV s_, GLhalfNV t_)
{
  RESOLVE(PFNGLMULTITEXCOORD2HNVPROC, "glMultiTexCoord2hNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2HNVPROC)( target_, s_, t_ );
}

void glMultiTexCoord2hvNVWrapper(GLenum target_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD2HVNVPROC, "glMultiTexCoord2hvNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD2HVNVPROC)( target_, v_ );
}

void glMultiTexCoord3hNVWrapper(GLenum target_, GLhalfNV s_, GLhalfNV t_, GLhalfNV r_)
{
  RESOLVE(PFNGLMULTITEXCOORD3HNVPROC, "glMultiTexCoord3hNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3HNVPROC)( target_, s_, t_, r_ );
}

void glMultiTexCoord3hvNVWrapper(GLenum target_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD3HVNVPROC, "glMultiTexCoord3hvNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD3HVNVPROC)( target_, v_ );
}

void glMultiTexCoord4hNVWrapper(GLenum target_, GLhalfNV s_, GLhalfNV t_, GLhalfNV r_, GLhalfNV q_)
{
  RESOLVE(PFNGLMULTITEXCOORD4HNVPROC, "glMultiTexCoord4hNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4HNVPROC)( target_, s_, t_, r_, q_ );
}

void glMultiTexCoord4hvNVWrapper(GLenum target_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLMULTITEXCOORD4HVNVPROC, "glMultiTexCoord4hvNV");
  RESOLVED_PROC(PFNGLMULTITEXCOORD4HVNVPROC)( target_, v_ );
}

void glFogCoordhNVWrapper(GLhalfNV fog_)
{
  RESOLVE(PFNGLFOGCOORDHNVPROC, "glFogCoordhNV");
  RESOLVED_PROC(PFNGLFOGCOORDHNVPROC)( fog_ );
}

void glFogCoordhvNVWrapper(const GLhalfNV* fog_)
{
  RESOLVE(PFNGLFOGCOORDHVNVPROC, "glFogCoordhvNV");
  RESOLVED_PROC(PFNGLFOGCOORDHVNVPROC)( fog_ );
}

void glSecondaryColor3hNVWrapper(GLhalfNV red_, GLhalfNV green_, GLhalfNV blue_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3HNVPROC, "glSecondaryColor3hNV");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3HNVPROC)( red_, green_, blue_ );
}

void glSecondaryColor3hvNVWrapper(const GLhalfNV* v_)
{
  RESOLVE(PFNGLSECONDARYCOLOR3HVNVPROC, "glSecondaryColor3hvNV");
  RESOLVED_PROC(PFNGLSECONDARYCOLOR3HVNVPROC)( v_ );
}

void glVertexWeighthNVWrapper(GLhalfNV weight_)
{
  RESOLVE(PFNGLVERTEXWEIGHTHNVPROC, "glVertexWeighthNV");
  RESOLVED_PROC(PFNGLVERTEXWEIGHTHNVPROC)( weight_ );
}

void glVertexWeighthvNVWrapper(const GLhalfNV* weight_)
{
  RESOLVE(PFNGLVERTEXWEIGHTHVNVPROC, "glVertexWeighthvNV");
  RESOLVED_PROC(PFNGLVERTEXWEIGHTHVNVPROC)( weight_ );
}

void glVertexAttrib1hNVWrapper(GLuint index_, GLhalfNV x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1HNVPROC, "glVertexAttrib1hNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1HNVPROC)( index_, x_ );
}

void glVertexAttrib1hvNVWrapper(GLuint index_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1HVNVPROC, "glVertexAttrib1hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1HVNVPROC)( index_, v_ );
}

void glVertexAttrib2hNVWrapper(GLuint index_, GLhalfNV x_, GLhalfNV y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2HNVPROC, "glVertexAttrib2hNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2HNVPROC)( index_, x_, y_ );
}

void glVertexAttrib2hvNVWrapper(GLuint index_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2HVNVPROC, "glVertexAttrib2hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2HVNVPROC)( index_, v_ );
}

void glVertexAttrib3hNVWrapper(GLuint index_, GLhalfNV x_, GLhalfNV y_, GLhalfNV z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3HNVPROC, "glVertexAttrib3hNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3HNVPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3hvNVWrapper(GLuint index_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3HVNVPROC, "glVertexAttrib3hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3HVNVPROC)( index_, v_ );
}

void glVertexAttrib4hNVWrapper(GLuint index_, GLhalfNV x_, GLhalfNV y_, GLhalfNV z_, GLhalfNV w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4HNVPROC, "glVertexAttrib4hNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4HNVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4hvNVWrapper(GLuint index_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4HVNVPROC, "glVertexAttrib4hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4HVNVPROC)( index_, v_ );
}

void glVertexAttribs1hvNVWrapper(GLuint index_, GLsizei n_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS1HVNVPROC, "glVertexAttribs1hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS1HVNVPROC)( index_, n_, v_ );
}

void glVertexAttribs2hvNVWrapper(GLuint index_, GLsizei n_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS2HVNVPROC, "glVertexAttribs2hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS2HVNVPROC)( index_, n_, v_ );
}

void glVertexAttribs3hvNVWrapper(GLuint index_, GLsizei n_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS3HVNVPROC, "glVertexAttribs3hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS3HVNVPROC)( index_, n_, v_ );
}

void glVertexAttribs4hvNVWrapper(GLuint index_, GLsizei n_, const GLhalfNV* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS4HVNVPROC, "glVertexAttribs4hvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS4HVNVPROC)( index_, n_, v_ );
}

void glGetInternalformatSampleivNVWrapper(GLenum target_, GLenum internalformat_, GLsizei samples_, GLenum pname_, GLsizei bufSize_, GLint* params_)
{
  RESOLVE(PFNGLGETINTERNALFORMATSAMPLEIVNVPROC, "glGetInternalformatSampleivNV");
  RESOLVED_PROC(PFNGLGETINTERNALFORMATSAMPLEIVNVPROC)( target_, internalformat_, samples_, pname_, bufSize_, params_ );
}

void glGenOcclusionQueriesNVWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLGENOCCLUSIONQUERIESNVPROC, "glGenOcclusionQueriesNV");
  RESOLVED_PROC(PFNGLGENOCCLUSIONQUERIESNVPROC)( n_, ids_ );
}

void glDeleteOcclusionQueriesNVWrapper(GLsizei n_, const GLuint* ids_)
{
  RESOLVE(PFNGLDELETEOCCLUSIONQUERIESNVPROC, "glDeleteOcclusionQueriesNV");
  RESOLVED_PROC(PFNGLDELETEOCCLUSIONQUERIESNVPROC)( n_, ids_ );
}

GLboolean glIsOcclusionQueryNVWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISOCCLUSIONQUERYNVPROC, "glIsOcclusionQueryNV", FALSE);
  return RESOLVED_PROC(PFNGLISOCCLUSIONQUERYNVPROC)(id_ );
}

void glBeginOcclusionQueryNVWrapper(GLuint id_)
{
  RESOLVE(PFNGLBEGINOCCLUSIONQUERYNVPROC, "glBeginOcclusionQueryNV");
  RESOLVED_PROC(PFNGLBEGINOCCLUSIONQUERYNVPROC)( id_ );
}

void glEndOcclusionQueryNVWrapper(void)
{
  RESOLVE(PFNGLENDOCCLUSIONQUERYNVPROC, "glEndOcclusionQueryNV");
  RESOLVED_PROC(PFNGLENDOCCLUSIONQUERYNVPROC)(  );
}

void glGetOcclusionQueryivNVWrapper(GLuint id_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETOCCLUSIONQUERYIVNVPROC, "glGetOcclusionQueryivNV");
  RESOLVED_PROC(PFNGLGETOCCLUSIONQUERYIVNVPROC)( id_, pname_, params_ );
}

void glGetOcclusionQueryuivNVWrapper(GLuint id_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETOCCLUSIONQUERYUIVNVPROC, "glGetOcclusionQueryuivNV");
  RESOLVED_PROC(PFNGLGETOCCLUSIONQUERYUIVNVPROC)( id_, pname_, params_ );
}

void glProgramBufferParametersfvNVWrapper(GLenum target_, GLuint bindingIndex_, GLuint wordIndex_, GLsizei count_, const GLfloat* params_)
{
  RESOLVE(PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC, "glProgramBufferParametersfvNV");
  RESOLVED_PROC(PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)( target_, bindingIndex_, wordIndex_, count_, params_ );
}

void glProgramBufferParametersIivNVWrapper(GLenum target_, GLuint bindingIndex_, GLuint wordIndex_, GLsizei count_, const GLint* params_)
{
  RESOLVE(PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC, "glProgramBufferParametersIivNV");
  RESOLVED_PROC(PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)( target_, bindingIndex_, wordIndex_, count_, params_ );
}

void glProgramBufferParametersIuivNVWrapper(GLenum target_, GLuint bindingIndex_, GLuint wordIndex_, GLsizei count_, const GLuint* params_)
{
  RESOLVE(PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC, "glProgramBufferParametersIuivNV");
  RESOLVED_PROC(PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)( target_, bindingIndex_, wordIndex_, count_, params_ );
}

GLuint glGenPathsNVWrapper(GLsizei range_)
{
  RESOLVE_RET(PFNGLGENPATHSNVPROC, "glGenPathsNV", FALSE);
  return RESOLVED_PROC(PFNGLGENPATHSNVPROC)(range_ );
}

void glDeletePathsNVWrapper(GLuint path_, GLsizei range_)
{
  RESOLVE(PFNGLDELETEPATHSNVPROC, "glDeletePathsNV");
  RESOLVED_PROC(PFNGLDELETEPATHSNVPROC)( path_, range_ );
}

GLboolean glIsPathNVWrapper(GLuint path_)
{
  RESOLVE_RET(PFNGLISPATHNVPROC, "glIsPathNV", FALSE);
  return RESOLVED_PROC(PFNGLISPATHNVPROC)(path_ );
}

void glPathCommandsNVWrapper(GLuint path_, GLsizei numCommands_, const GLubyte* commands_, GLsizei numCoords_, GLenum coordType_, const void * coords_)
{
  RESOLVE(PFNGLPATHCOMMANDSNVPROC, "glPathCommandsNV");
  RESOLVED_PROC(PFNGLPATHCOMMANDSNVPROC)( path_, numCommands_, commands_, numCoords_, coordType_, coords_ );
}

void glPathCoordsNVWrapper(GLuint path_, GLsizei numCoords_, GLenum coordType_, const void * coords_)
{
  RESOLVE(PFNGLPATHCOORDSNVPROC, "glPathCoordsNV");
  RESOLVED_PROC(PFNGLPATHCOORDSNVPROC)( path_, numCoords_, coordType_, coords_ );
}

void glPathSubCommandsNVWrapper(GLuint path_, GLsizei commandStart_, GLsizei commandsToDelete_, GLsizei numCommands_, const GLubyte* commands_, GLsizei numCoords_, GLenum coordType_, const void * coords_)
{
  RESOLVE(PFNGLPATHSUBCOMMANDSNVPROC, "glPathSubCommandsNV");
  RESOLVED_PROC(PFNGLPATHSUBCOMMANDSNVPROC)( path_, commandStart_, commandsToDelete_, numCommands_, commands_, numCoords_, coordType_, coords_ );
}

void glPathSubCoordsNVWrapper(GLuint path_, GLsizei coordStart_, GLsizei numCoords_, GLenum coordType_, const void * coords_)
{
  RESOLVE(PFNGLPATHSUBCOORDSNVPROC, "glPathSubCoordsNV");
  RESOLVED_PROC(PFNGLPATHSUBCOORDSNVPROC)( path_, coordStart_, numCoords_, coordType_, coords_ );
}

void glPathStringNVWrapper(GLuint path_, GLenum format_, GLsizei length_, const void * pathString_)
{
  RESOLVE(PFNGLPATHSTRINGNVPROC, "glPathStringNV");
  RESOLVED_PROC(PFNGLPATHSTRINGNVPROC)( path_, format_, length_, pathString_ );
}

void glPathGlyphsNVWrapper(GLuint firstPathName_, GLenum fontTarget_, const void * fontName_, GLbitfield fontStyle_, GLsizei numGlyphs_, GLenum type_, const void * charcodes_, GLenum handleMissingGlyphs_, GLuint pathParameterTemplate_, GLfloat emScale_)
{
  RESOLVE(PFNGLPATHGLYPHSNVPROC, "glPathGlyphsNV");
  RESOLVED_PROC(PFNGLPATHGLYPHSNVPROC)( firstPathName_, fontTarget_, fontName_, fontStyle_, numGlyphs_, type_, charcodes_, handleMissingGlyphs_, pathParameterTemplate_, emScale_ );
}

void glPathGlyphRangeNVWrapper(GLuint firstPathName_, GLenum fontTarget_, const void * fontName_, GLbitfield fontStyle_, GLuint firstGlyph_, GLsizei numGlyphs_, GLenum handleMissingGlyphs_, GLuint pathParameterTemplate_, GLfloat emScale_)
{
  RESOLVE(PFNGLPATHGLYPHRANGENVPROC, "glPathGlyphRangeNV");
  RESOLVED_PROC(PFNGLPATHGLYPHRANGENVPROC)( firstPathName_, fontTarget_, fontName_, fontStyle_, firstGlyph_, numGlyphs_, handleMissingGlyphs_, pathParameterTemplate_, emScale_ );
}

void glWeightPathsNVWrapper(GLuint resultPath_, GLsizei numPaths_, const GLuint* paths_, const GLfloat* weights_)
{
  RESOLVE(PFNGLWEIGHTPATHSNVPROC, "glWeightPathsNV");
  RESOLVED_PROC(PFNGLWEIGHTPATHSNVPROC)( resultPath_, numPaths_, paths_, weights_ );
}

void glCopyPathNVWrapper(GLuint resultPath_, GLuint srcPath_)
{
  RESOLVE(PFNGLCOPYPATHNVPROC, "glCopyPathNV");
  RESOLVED_PROC(PFNGLCOPYPATHNVPROC)( resultPath_, srcPath_ );
}

void glInterpolatePathsNVWrapper(GLuint resultPath_, GLuint pathA_, GLuint pathB_, GLfloat weight_)
{
  RESOLVE(PFNGLINTERPOLATEPATHSNVPROC, "glInterpolatePathsNV");
  RESOLVED_PROC(PFNGLINTERPOLATEPATHSNVPROC)( resultPath_, pathA_, pathB_, weight_ );
}

void glTransformPathNVWrapper(GLuint resultPath_, GLuint srcPath_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLTRANSFORMPATHNVPROC, "glTransformPathNV");
  RESOLVED_PROC(PFNGLTRANSFORMPATHNVPROC)( resultPath_, srcPath_, transformType_, transformValues_ );
}

void glPathParameterivNVWrapper(GLuint path_, GLenum pname_, const GLint* value_)
{
  RESOLVE(PFNGLPATHPARAMETERIVNVPROC, "glPathParameterivNV");
  RESOLVED_PROC(PFNGLPATHPARAMETERIVNVPROC)( path_, pname_, value_ );
}

void glPathParameteriNVWrapper(GLuint path_, GLenum pname_, GLint value_)
{
  RESOLVE(PFNGLPATHPARAMETERINVPROC, "glPathParameteriNV");
  RESOLVED_PROC(PFNGLPATHPARAMETERINVPROC)( path_, pname_, value_ );
}

void glPathParameterfvNVWrapper(GLuint path_, GLenum pname_, const GLfloat* value_)
{
  RESOLVE(PFNGLPATHPARAMETERFVNVPROC, "glPathParameterfvNV");
  RESOLVED_PROC(PFNGLPATHPARAMETERFVNVPROC)( path_, pname_, value_ );
}

void glPathParameterfNVWrapper(GLuint path_, GLenum pname_, GLfloat value_)
{
  RESOLVE(PFNGLPATHPARAMETERFNVPROC, "glPathParameterfNV");
  RESOLVED_PROC(PFNGLPATHPARAMETERFNVPROC)( path_, pname_, value_ );
}

void glPathDashArrayNVWrapper(GLuint path_, GLsizei dashCount_, const GLfloat* dashArray_)
{
  RESOLVE(PFNGLPATHDASHARRAYNVPROC, "glPathDashArrayNV");
  RESOLVED_PROC(PFNGLPATHDASHARRAYNVPROC)( path_, dashCount_, dashArray_ );
}

void glPathStencilFuncNVWrapper(GLenum func_, GLint ref_, GLuint mask_)
{
  RESOLVE(PFNGLPATHSTENCILFUNCNVPROC, "glPathStencilFuncNV");
  RESOLVED_PROC(PFNGLPATHSTENCILFUNCNVPROC)( func_, ref_, mask_ );
}

void glPathStencilDepthOffsetNVWrapper(GLfloat factor_, GLfloat units_)
{
  RESOLVE(PFNGLPATHSTENCILDEPTHOFFSETNVPROC, "glPathStencilDepthOffsetNV");
  RESOLVED_PROC(PFNGLPATHSTENCILDEPTHOFFSETNVPROC)( factor_, units_ );
}

void glStencilFillPathNVWrapper(GLuint path_, GLenum fillMode_, GLuint mask_)
{
  RESOLVE(PFNGLSTENCILFILLPATHNVPROC, "glStencilFillPathNV");
  RESOLVED_PROC(PFNGLSTENCILFILLPATHNVPROC)( path_, fillMode_, mask_ );
}

void glStencilStrokePathNVWrapper(GLuint path_, GLint reference_, GLuint mask_)
{
  RESOLVE(PFNGLSTENCILSTROKEPATHNVPROC, "glStencilStrokePathNV");
  RESOLVED_PROC(PFNGLSTENCILSTROKEPATHNVPROC)( path_, reference_, mask_ );
}

void glStencilFillPathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLenum fillMode_, GLuint mask_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLSTENCILFILLPATHINSTANCEDNVPROC, "glStencilFillPathInstancedNV");
  RESOLVED_PROC(PFNGLSTENCILFILLPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, fillMode_, mask_, transformType_, transformValues_ );
}

void glStencilStrokePathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLint reference_, GLuint mask_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC, "glStencilStrokePathInstancedNV");
  RESOLVED_PROC(PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, reference_, mask_, transformType_, transformValues_ );
}

void glPathCoverDepthFuncNVWrapper(GLenum func_)
{
  RESOLVE(PFNGLPATHCOVERDEPTHFUNCNVPROC, "glPathCoverDepthFuncNV");
  RESOLVED_PROC(PFNGLPATHCOVERDEPTHFUNCNVPROC)( func_ );
}

void glCoverFillPathNVWrapper(GLuint path_, GLenum coverMode_)
{
  RESOLVE(PFNGLCOVERFILLPATHNVPROC, "glCoverFillPathNV");
  RESOLVED_PROC(PFNGLCOVERFILLPATHNVPROC)( path_, coverMode_ );
}

void glCoverStrokePathNVWrapper(GLuint path_, GLenum coverMode_)
{
  RESOLVE(PFNGLCOVERSTROKEPATHNVPROC, "glCoverStrokePathNV");
  RESOLVED_PROC(PFNGLCOVERSTROKEPATHNVPROC)( path_, coverMode_ );
}

void glCoverFillPathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLenum coverMode_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLCOVERFILLPATHINSTANCEDNVPROC, "glCoverFillPathInstancedNV");
  RESOLVED_PROC(PFNGLCOVERFILLPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, coverMode_, transformType_, transformValues_ );
}

void glCoverStrokePathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLenum coverMode_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLCOVERSTROKEPATHINSTANCEDNVPROC, "glCoverStrokePathInstancedNV");
  RESOLVED_PROC(PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, coverMode_, transformType_, transformValues_ );
}

void glGetPathParameterivNVWrapper(GLuint path_, GLenum pname_, GLint* value_)
{
  RESOLVE(PFNGLGETPATHPARAMETERIVNVPROC, "glGetPathParameterivNV");
  RESOLVED_PROC(PFNGLGETPATHPARAMETERIVNVPROC)( path_, pname_, value_ );
}

void glGetPathParameterfvNVWrapper(GLuint path_, GLenum pname_, GLfloat* value_)
{
  RESOLVE(PFNGLGETPATHPARAMETERFVNVPROC, "glGetPathParameterfvNV");
  RESOLVED_PROC(PFNGLGETPATHPARAMETERFVNVPROC)( path_, pname_, value_ );
}

void glGetPathCommandsNVWrapper(GLuint path_, GLubyte* commands_)
{
  RESOLVE(PFNGLGETPATHCOMMANDSNVPROC, "glGetPathCommandsNV");
  RESOLVED_PROC(PFNGLGETPATHCOMMANDSNVPROC)( path_, commands_ );
}

void glGetPathCoordsNVWrapper(GLuint path_, GLfloat* coords_)
{
  RESOLVE(PFNGLGETPATHCOORDSNVPROC, "glGetPathCoordsNV");
  RESOLVED_PROC(PFNGLGETPATHCOORDSNVPROC)( path_, coords_ );
}

void glGetPathDashArrayNVWrapper(GLuint path_, GLfloat* dashArray_)
{
  RESOLVE(PFNGLGETPATHDASHARRAYNVPROC, "glGetPathDashArrayNV");
  RESOLVED_PROC(PFNGLGETPATHDASHARRAYNVPROC)( path_, dashArray_ );
}

void glGetPathMetricsNVWrapper(GLbitfield metricQueryMask_, GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLsizei stride_, GLfloat* metrics_)
{
  RESOLVE(PFNGLGETPATHMETRICSNVPROC, "glGetPathMetricsNV");
  RESOLVED_PROC(PFNGLGETPATHMETRICSNVPROC)( metricQueryMask_, numPaths_, pathNameType_, paths_, pathBase_, stride_, metrics_ );
}

void glGetPathMetricRangeNVWrapper(GLbitfield metricQueryMask_, GLuint firstPathName_, GLsizei numPaths_, GLsizei stride_, GLfloat* metrics_)
{
  RESOLVE(PFNGLGETPATHMETRICRANGENVPROC, "glGetPathMetricRangeNV");
  RESOLVED_PROC(PFNGLGETPATHMETRICRANGENVPROC)( metricQueryMask_, firstPathName_, numPaths_, stride_, metrics_ );
}

void glGetPathSpacingNVWrapper(GLenum pathListMode_, GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLfloat advanceScale_, GLfloat kerningScale_, GLenum transformType_, GLfloat* returnedSpacing_)
{
  RESOLVE(PFNGLGETPATHSPACINGNVPROC, "glGetPathSpacingNV");
  RESOLVED_PROC(PFNGLGETPATHSPACINGNVPROC)( pathListMode_, numPaths_, pathNameType_, paths_, pathBase_, advanceScale_, kerningScale_, transformType_, returnedSpacing_ );
}

GLboolean glIsPointInFillPathNVWrapper(GLuint path_, GLuint mask_, GLfloat x_, GLfloat y_)
{
  RESOLVE_RET(PFNGLISPOINTINFILLPATHNVPROC, "glIsPointInFillPathNV", FALSE);
  return RESOLVED_PROC(PFNGLISPOINTINFILLPATHNVPROC)(path_, mask_, x_, y_ );
}

GLboolean glIsPointInStrokePathNVWrapper(GLuint path_, GLfloat x_, GLfloat y_)
{
  RESOLVE_RET(PFNGLISPOINTINSTROKEPATHNVPROC, "glIsPointInStrokePathNV", FALSE);
  return RESOLVED_PROC(PFNGLISPOINTINSTROKEPATHNVPROC)(path_, x_, y_ );
}

GLfloat glGetPathLengthNVWrapper(GLuint path_, GLsizei startSegment_, GLsizei numSegments_)
{
  RESOLVE_RET(PFNGLGETPATHLENGTHNVPROC, "glGetPathLengthNV", FALSE);
  return RESOLVED_PROC(PFNGLGETPATHLENGTHNVPROC)(path_, startSegment_, numSegments_ );
}

GLboolean glPointAlongPathNVWrapper(GLuint path_, GLsizei startSegment_, GLsizei numSegments_, GLfloat distance_, GLfloat* x_, GLfloat* y_, GLfloat* tangentX_, GLfloat* tangentY_)
{
  RESOLVE_RET(PFNGLPOINTALONGPATHNVPROC, "glPointAlongPathNV", FALSE);
  return RESOLVED_PROC(PFNGLPOINTALONGPATHNVPROC)(path_, startSegment_, numSegments_, distance_, x_, y_, tangentX_, tangentY_ );
}

void glMatrixLoad3x2fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXLOAD3X2FNVPROC, "glMatrixLoad3x2fNV");
  RESOLVED_PROC(PFNGLMATRIXLOAD3X2FNVPROC)( matrixMode_, m_ );
}

void glMatrixLoad3x3fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXLOAD3X3FNVPROC, "glMatrixLoad3x3fNV");
  RESOLVED_PROC(PFNGLMATRIXLOAD3X3FNVPROC)( matrixMode_, m_ );
}

void glMatrixLoadTranspose3x3fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC, "glMatrixLoadTranspose3x3fNV");
  RESOLVED_PROC(PFNGLMATRIXLOADTRANSPOSE3X3FNVPROC)( matrixMode_, m_ );
}

void glMatrixMult3x2fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXMULT3X2FNVPROC, "glMatrixMult3x2fNV");
  RESOLVED_PROC(PFNGLMATRIXMULT3X2FNVPROC)( matrixMode_, m_ );
}

void glMatrixMult3x3fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXMULT3X3FNVPROC, "glMatrixMult3x3fNV");
  RESOLVED_PROC(PFNGLMATRIXMULT3X3FNVPROC)( matrixMode_, m_ );
}

void glMatrixMultTranspose3x3fNVWrapper(GLenum matrixMode_, const GLfloat* m_)
{
  RESOLVE(PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC, "glMatrixMultTranspose3x3fNV");
  RESOLVED_PROC(PFNGLMATRIXMULTTRANSPOSE3X3FNVPROC)( matrixMode_, m_ );
}

void glStencilThenCoverFillPathNVWrapper(GLuint path_, GLenum fillMode_, GLuint mask_, GLenum coverMode_)
{
  RESOLVE(PFNGLSTENCILTHENCOVERFILLPATHNVPROC, "glStencilThenCoverFillPathNV");
  RESOLVED_PROC(PFNGLSTENCILTHENCOVERFILLPATHNVPROC)( path_, fillMode_, mask_, coverMode_ );
}

void glStencilThenCoverStrokePathNVWrapper(GLuint path_, GLint reference_, GLuint mask_, GLenum coverMode_)
{
  RESOLVE(PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC, "glStencilThenCoverStrokePathNV");
  RESOLVED_PROC(PFNGLSTENCILTHENCOVERSTROKEPATHNVPROC)( path_, reference_, mask_, coverMode_ );
}

void glStencilThenCoverFillPathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLenum fillMode_, GLuint mask_, GLenum coverMode_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC, "glStencilThenCoverFillPathInstancedNV");
  RESOLVED_PROC(PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, fillMode_, mask_, coverMode_, transformType_, transformValues_ );
}

void glStencilThenCoverStrokePathInstancedNVWrapper(GLsizei numPaths_, GLenum pathNameType_, const void * paths_, GLuint pathBase_, GLint reference_, GLuint mask_, GLenum coverMode_, GLenum transformType_, const GLfloat* transformValues_)
{
  RESOLVE(PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC, "glStencilThenCoverStrokePathInstancedNV");
  RESOLVED_PROC(PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNVPROC)( numPaths_, pathNameType_, paths_, pathBase_, reference_, mask_, coverMode_, transformType_, transformValues_ );
}

GLenum glPathGlyphIndexRangeNVWrapper(GLenum fontTarget_, const void * fontName_, GLbitfield fontStyle_, GLuint pathParameterTemplate_, GLfloat emScale_, GLuint baseAndCount_[2])
{
  RESOLVE_RET(PFNGLPATHGLYPHINDEXRANGENVPROC, "glPathGlyphIndexRangeNV", FALSE);
  return RESOLVED_PROC(PFNGLPATHGLYPHINDEXRANGENVPROC)(fontTarget_, fontName_, fontStyle_, pathParameterTemplate_, emScale_, baseAndCount_ );
}

GLenum glPathGlyphIndexArrayNVWrapper(GLuint firstPathName_, GLenum fontTarget_, const void * fontName_, GLbitfield fontStyle_, GLuint firstGlyphIndex_, GLsizei numGlyphs_, GLuint pathParameterTemplate_, GLfloat emScale_)
{
  RESOLVE_RET(PFNGLPATHGLYPHINDEXARRAYNVPROC, "glPathGlyphIndexArrayNV", FALSE);
  return RESOLVED_PROC(PFNGLPATHGLYPHINDEXARRAYNVPROC)(firstPathName_, fontTarget_, fontName_, fontStyle_, firstGlyphIndex_, numGlyphs_, pathParameterTemplate_, emScale_ );
}

GLenum glPathMemoryGlyphIndexArrayNVWrapper(GLuint firstPathName_, GLenum fontTarget_, GLsizeiptr fontSize_, const void * fontData_, GLsizei faceIndex_, GLuint firstGlyphIndex_, GLsizei numGlyphs_, GLuint pathParameterTemplate_, GLfloat emScale_)
{
  RESOLVE_RET(PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC, "glPathMemoryGlyphIndexArrayNV", FALSE);
  return RESOLVED_PROC(PFNGLPATHMEMORYGLYPHINDEXARRAYNVPROC)(firstPathName_, fontTarget_, fontSize_, fontData_, faceIndex_, firstGlyphIndex_, numGlyphs_, pathParameterTemplate_, emScale_ );
}

void glProgramPathFragmentInputGenNVWrapper(GLuint program_, GLint location_, GLenum genMode_, GLint components_, const GLfloat* coeffs_)
{
  RESOLVE(PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC, "glProgramPathFragmentInputGenNV");
  RESOLVED_PROC(PFNGLPROGRAMPATHFRAGMENTINPUTGENNVPROC)( program_, location_, genMode_, components_, coeffs_ );
}

void glGetProgramResourcefvNVWrapper(GLuint program_, GLenum programInterface_, GLuint index_, GLsizei propCount_, const GLenum* props_, GLsizei bufSize_, GLsizei* length_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPROGRAMRESOURCEFVNVPROC, "glGetProgramResourcefvNV");
  RESOLVED_PROC(PFNGLGETPROGRAMRESOURCEFVNVPROC)( program_, programInterface_, index_, propCount_, props_, bufSize_, length_, params_ );
}

void glPathColorGenNVWrapper(GLenum color_, GLenum genMode_, GLenum colorFormat_, const GLfloat* coeffs_)
{
  RESOLVE(PFNGLPATHCOLORGENNVPROC, "glPathColorGenNV");
  RESOLVED_PROC(PFNGLPATHCOLORGENNVPROC)( color_, genMode_, colorFormat_, coeffs_ );
}

void glPathTexGenNVWrapper(GLenum texCoordSet_, GLenum genMode_, GLint components_, const GLfloat* coeffs_)
{
  RESOLVE(PFNGLPATHTEXGENNVPROC, "glPathTexGenNV");
  RESOLVED_PROC(PFNGLPATHTEXGENNVPROC)( texCoordSet_, genMode_, components_, coeffs_ );
}

void glPathFogGenNVWrapper(GLenum genMode_)
{
  RESOLVE(PFNGLPATHFOGGENNVPROC, "glPathFogGenNV");
  RESOLVED_PROC(PFNGLPATHFOGGENNVPROC)( genMode_ );
}

void glGetPathColorGenivNVWrapper(GLenum color_, GLenum pname_, GLint* value_)
{
  RESOLVE(PFNGLGETPATHCOLORGENIVNVPROC, "glGetPathColorGenivNV");
  RESOLVED_PROC(PFNGLGETPATHCOLORGENIVNVPROC)( color_, pname_, value_ );
}

void glGetPathColorGenfvNVWrapper(GLenum color_, GLenum pname_, GLfloat* value_)
{
  RESOLVE(PFNGLGETPATHCOLORGENFVNVPROC, "glGetPathColorGenfvNV");
  RESOLVED_PROC(PFNGLGETPATHCOLORGENFVNVPROC)( color_, pname_, value_ );
}

void glGetPathTexGenivNVWrapper(GLenum texCoordSet_, GLenum pname_, GLint* value_)
{
  RESOLVE(PFNGLGETPATHTEXGENIVNVPROC, "glGetPathTexGenivNV");
  RESOLVED_PROC(PFNGLGETPATHTEXGENIVNVPROC)( texCoordSet_, pname_, value_ );
}

void glGetPathTexGenfvNVWrapper(GLenum texCoordSet_, GLenum pname_, GLfloat* value_)
{
  RESOLVE(PFNGLGETPATHTEXGENFVNVPROC, "glGetPathTexGenfvNV");
  RESOLVED_PROC(PFNGLGETPATHTEXGENFVNVPROC)( texCoordSet_, pname_, value_ );
}

void glPixelDataRangeNVWrapper(GLenum target_, GLsizei length_, const void * pointer_)
{
  RESOLVE(PFNGLPIXELDATARANGENVPROC, "glPixelDataRangeNV");
  RESOLVED_PROC(PFNGLPIXELDATARANGENVPROC)( target_, length_, pointer_ );
}

void glFlushPixelDataRangeNVWrapper(GLenum target_)
{
  RESOLVE(PFNGLFLUSHPIXELDATARANGENVPROC, "glFlushPixelDataRangeNV");
  RESOLVED_PROC(PFNGLFLUSHPIXELDATARANGENVPROC)( target_ );
}

void glPointParameteriNVWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLPOINTPARAMETERINVPROC, "glPointParameteriNV");
  RESOLVED_PROC(PFNGLPOINTPARAMETERINVPROC)( pname_, param_ );
}

void glPointParameterivNVWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERIVNVPROC, "glPointParameterivNV");
  RESOLVED_PROC(PFNGLPOINTPARAMETERIVNVPROC)( pname_, params_ );
}

void glPresentFrameKeyedNVWrapper(GLuint video_slot_, GLuint64EXT minPresentTime_, GLuint beginPresentTimeId_, GLuint presentDurationId_, GLenum type_, GLenum target0_, GLuint fill0_, GLuint key0_, GLenum target1_, GLuint fill1_, GLuint key1_)
{
  RESOLVE(PFNGLPRESENTFRAMEKEYEDNVPROC, "glPresentFrameKeyedNV");
  RESOLVED_PROC(PFNGLPRESENTFRAMEKEYEDNVPROC)( video_slot_, minPresentTime_, beginPresentTimeId_, presentDurationId_, type_, target0_, fill0_, key0_, target1_, fill1_, key1_ );
}

void glPresentFrameDualFillNVWrapper(GLuint video_slot_, GLuint64EXT minPresentTime_, GLuint beginPresentTimeId_, GLuint presentDurationId_, GLenum type_, GLenum target0_, GLuint fill0_, GLenum target1_, GLuint fill1_, GLenum target2_, GLuint fill2_, GLenum target3_, GLuint fill3_)
{
  RESOLVE(PFNGLPRESENTFRAMEDUALFILLNVPROC, "glPresentFrameDualFillNV");
  RESOLVED_PROC(PFNGLPRESENTFRAMEDUALFILLNVPROC)( video_slot_, minPresentTime_, beginPresentTimeId_, presentDurationId_, type_, target0_, fill0_, target1_, fill1_, target2_, fill2_, target3_, fill3_ );
}

void glGetVideoivNVWrapper(GLuint video_slot_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVIDEOIVNVPROC, "glGetVideoivNV");
  RESOLVED_PROC(PFNGLGETVIDEOIVNVPROC)( video_slot_, pname_, params_ );
}

void glGetVideouivNVWrapper(GLuint video_slot_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETVIDEOUIVNVPROC, "glGetVideouivNV");
  RESOLVED_PROC(PFNGLGETVIDEOUIVNVPROC)( video_slot_, pname_, params_ );
}

void glGetVideoi64vNVWrapper(GLuint video_slot_, GLenum pname_, GLint64EXT* params_)
{
  RESOLVE(PFNGLGETVIDEOI64VNVPROC, "glGetVideoi64vNV");
  RESOLVED_PROC(PFNGLGETVIDEOI64VNVPROC)( video_slot_, pname_, params_ );
}

void glGetVideoui64vNVWrapper(GLuint video_slot_, GLenum pname_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETVIDEOUI64VNVPROC, "glGetVideoui64vNV");
  RESOLVED_PROC(PFNGLGETVIDEOUI64VNVPROC)( video_slot_, pname_, params_ );
}

void glPrimitiveRestartNVWrapper(void)
{
  RESOLVE(PFNGLPRIMITIVERESTARTNVPROC, "glPrimitiveRestartNV");
  RESOLVED_PROC(PFNGLPRIMITIVERESTARTNVPROC)(  );
}

void glPrimitiveRestartIndexNVWrapper(GLuint index_)
{
  RESOLVE(PFNGLPRIMITIVERESTARTINDEXNVPROC, "glPrimitiveRestartIndexNV");
  RESOLVED_PROC(PFNGLPRIMITIVERESTARTINDEXNVPROC)( index_ );
}

void glCombinerParameterfvNVWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCOMBINERPARAMETERFVNVPROC, "glCombinerParameterfvNV");
  RESOLVED_PROC(PFNGLCOMBINERPARAMETERFVNVPROC)( pname_, params_ );
}

void glCombinerParameterfNVWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLCOMBINERPARAMETERFNVPROC, "glCombinerParameterfNV");
  RESOLVED_PROC(PFNGLCOMBINERPARAMETERFNVPROC)( pname_, param_ );
}

void glCombinerParameterivNVWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLCOMBINERPARAMETERIVNVPROC, "glCombinerParameterivNV");
  RESOLVED_PROC(PFNGLCOMBINERPARAMETERIVNVPROC)( pname_, params_ );
}

void glCombinerParameteriNVWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLCOMBINERPARAMETERINVPROC, "glCombinerParameteriNV");
  RESOLVED_PROC(PFNGLCOMBINERPARAMETERINVPROC)( pname_, param_ );
}

void glCombinerInputNVWrapper(GLenum stage_, GLenum portion_, GLenum variable_, GLenum input_, GLenum mapping_, GLenum componentUsage_)
{
  RESOLVE(PFNGLCOMBINERINPUTNVPROC, "glCombinerInputNV");
  RESOLVED_PROC(PFNGLCOMBINERINPUTNVPROC)( stage_, portion_, variable_, input_, mapping_, componentUsage_ );
}

void glCombinerOutputNVWrapper(GLenum stage_, GLenum portion_, GLenum abOutput_, GLenum cdOutput_, GLenum sumOutput_, GLenum scale_, GLenum bias_, GLboolean abDotProduct_, GLboolean cdDotProduct_, GLboolean muxSum_)
{
  RESOLVE(PFNGLCOMBINEROUTPUTNVPROC, "glCombinerOutputNV");
  RESOLVED_PROC(PFNGLCOMBINEROUTPUTNVPROC)( stage_, portion_, abOutput_, cdOutput_, sumOutput_, scale_, bias_, abDotProduct_, cdDotProduct_, muxSum_ );
}

void glFinalCombinerInputNVWrapper(GLenum variable_, GLenum input_, GLenum mapping_, GLenum componentUsage_)
{
  RESOLVE(PFNGLFINALCOMBINERINPUTNVPROC, "glFinalCombinerInputNV");
  RESOLVED_PROC(PFNGLFINALCOMBINERINPUTNVPROC)( variable_, input_, mapping_, componentUsage_ );
}

void glGetCombinerInputParameterfvNVWrapper(GLenum stage_, GLenum portion_, GLenum variable_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC, "glGetCombinerInputParameterfvNV");
  RESOLVED_PROC(PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)( stage_, portion_, variable_, pname_, params_ );
}

void glGetCombinerInputParameterivNVWrapper(GLenum stage_, GLenum portion_, GLenum variable_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC, "glGetCombinerInputParameterivNV");
  RESOLVED_PROC(PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)( stage_, portion_, variable_, pname_, params_ );
}

void glGetCombinerOutputParameterfvNVWrapper(GLenum stage_, GLenum portion_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC, "glGetCombinerOutputParameterfvNV");
  RESOLVED_PROC(PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)( stage_, portion_, pname_, params_ );
}

void glGetCombinerOutputParameterivNVWrapper(GLenum stage_, GLenum portion_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC, "glGetCombinerOutputParameterivNV");
  RESOLVED_PROC(PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)( stage_, portion_, pname_, params_ );
}

void glGetFinalCombinerInputParameterfvNVWrapper(GLenum variable_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC, "glGetFinalCombinerInputParameterfvNV");
  RESOLVED_PROC(PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)( variable_, pname_, params_ );
}

void glGetFinalCombinerInputParameterivNVWrapper(GLenum variable_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC, "glGetFinalCombinerInputParameterivNV");
  RESOLVED_PROC(PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)( variable_, pname_, params_ );
}

void glCombinerStageParameterfvNVWrapper(GLenum stage_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCOMBINERSTAGEPARAMETERFVNVPROC, "glCombinerStageParameterfvNV");
  RESOLVED_PROC(PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)( stage_, pname_, params_ );
}

void glGetCombinerStageParameterfvNVWrapper(GLenum stage_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC, "glGetCombinerStageParameterfvNV");
  RESOLVED_PROC(PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)( stage_, pname_, params_ );
}

void glFramebufferSampleLocationsfvNVWrapper(GLenum target_, GLuint start_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC, "glFramebufferSampleLocationsfvNV");
  RESOLVED_PROC(PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)( target_, start_, count_, v_ );
}

void glNamedFramebufferSampleLocationsfvNVWrapper(GLuint framebuffer_, GLuint start_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC, "glNamedFramebufferSampleLocationsfvNV");
  RESOLVED_PROC(PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)( framebuffer_, start_, count_, v_ );
}

void glResolveDepthValuesNVWrapper(void)
{
  RESOLVE(PFNGLRESOLVEDEPTHVALUESNVPROC, "glResolveDepthValuesNV");
  RESOLVED_PROC(PFNGLRESOLVEDEPTHVALUESNVPROC)(  );
}

void glMakeBufferResidentNVWrapper(GLenum target_, GLenum access_)
{
  RESOLVE(PFNGLMAKEBUFFERRESIDENTNVPROC, "glMakeBufferResidentNV");
  RESOLVED_PROC(PFNGLMAKEBUFFERRESIDENTNVPROC)( target_, access_ );
}

void glMakeBufferNonResidentNVWrapper(GLenum target_)
{
  RESOLVE(PFNGLMAKEBUFFERNONRESIDENTNVPROC, "glMakeBufferNonResidentNV");
  RESOLVED_PROC(PFNGLMAKEBUFFERNONRESIDENTNVPROC)( target_ );
}

GLboolean glIsBufferResidentNVWrapper(GLenum target_)
{
  RESOLVE_RET(PFNGLISBUFFERRESIDENTNVPROC, "glIsBufferResidentNV", FALSE);
  return RESOLVED_PROC(PFNGLISBUFFERRESIDENTNVPROC)(target_ );
}

void glMakeNamedBufferResidentNVWrapper(GLuint buffer_, GLenum access_)
{
  RESOLVE(PFNGLMAKENAMEDBUFFERRESIDENTNVPROC, "glMakeNamedBufferResidentNV");
  RESOLVED_PROC(PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)( buffer_, access_ );
}

void glMakeNamedBufferNonResidentNVWrapper(GLuint buffer_)
{
  RESOLVE(PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC, "glMakeNamedBufferNonResidentNV");
  RESOLVED_PROC(PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)( buffer_ );
}

GLboolean glIsNamedBufferResidentNVWrapper(GLuint buffer_)
{
  RESOLVE_RET(PFNGLISNAMEDBUFFERRESIDENTNVPROC, "glIsNamedBufferResidentNV", FALSE);
  return RESOLVED_PROC(PFNGLISNAMEDBUFFERRESIDENTNVPROC)(buffer_ );
}

void glGetBufferParameterui64vNVWrapper(GLenum target_, GLenum pname_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETBUFFERPARAMETERUI64VNVPROC, "glGetBufferParameterui64vNV");
  RESOLVED_PROC(PFNGLGETBUFFERPARAMETERUI64VNVPROC)( target_, pname_, params_ );
}

void glGetNamedBufferParameterui64vNVWrapper(GLuint buffer_, GLenum pname_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC, "glGetNamedBufferParameterui64vNV");
  RESOLVED_PROC(PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)( buffer_, pname_, params_ );
}

void glGetIntegerui64vNVWrapper(GLenum value_, GLuint64EXT* result_)
{
  RESOLVE(PFNGLGETINTEGERUI64VNVPROC, "glGetIntegerui64vNV");
  RESOLVED_PROC(PFNGLGETINTEGERUI64VNVPROC)( value_, result_ );
}

void glUniformui64NVWrapper(GLint location_, GLuint64EXT value_)
{
  RESOLVE(PFNGLUNIFORMUI64NVPROC, "glUniformui64NV");
  RESOLVED_PROC(PFNGLUNIFORMUI64NVPROC)( location_, value_ );
}

void glUniformui64vNVWrapper(GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLUNIFORMUI64VNVPROC, "glUniformui64vNV");
  RESOLVED_PROC(PFNGLUNIFORMUI64VNVPROC)( location_, count_, value_ );
}

void glProgramUniformui64NVWrapper(GLuint program_, GLint location_, GLuint64EXT value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMUI64NVPROC, "glProgramUniformui64NV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMUI64NVPROC)( program_, location_, value_ );
}

void glProgramUniformui64vNVWrapper(GLuint program_, GLint location_, GLsizei count_, const GLuint64EXT* value_)
{
  RESOLVE(PFNGLPROGRAMUNIFORMUI64VNVPROC, "glProgramUniformui64vNV");
  RESOLVED_PROC(PFNGLPROGRAMUNIFORMUI64VNVPROC)( program_, location_, count_, value_ );
}

void glTextureBarrierNVWrapper(void)
{
  RESOLVE(PFNGLTEXTUREBARRIERNVPROC, "glTextureBarrierNV");
  RESOLVED_PROC(PFNGLTEXTUREBARRIERNVPROC)(  );
}

void glTexImage2DMultisampleCoverageNVWrapper(GLenum target_, GLsizei coverageSamples_, GLsizei colorSamples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC, "glTexImage2DMultisampleCoverageNV");
  RESOLVED_PROC(PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)( target_, coverageSamples_, colorSamples_, internalFormat_, width_, height_, fixedSampleLocations_ );
}

void glTexImage3DMultisampleCoverageNVWrapper(GLenum target_, GLsizei coverageSamples_, GLsizei colorSamples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC, "glTexImage3DMultisampleCoverageNV");
  RESOLVED_PROC(PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)( target_, coverageSamples_, colorSamples_, internalFormat_, width_, height_, depth_, fixedSampleLocations_ );
}

void glTextureImage2DMultisampleNVWrapper(GLuint texture_, GLenum target_, GLsizei samples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC, "glTextureImage2DMultisampleNV");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)( texture_, target_, samples_, internalFormat_, width_, height_, fixedSampleLocations_ );
}

void glTextureImage3DMultisampleNVWrapper(GLuint texture_, GLenum target_, GLsizei samples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC, "glTextureImage3DMultisampleNV");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)( texture_, target_, samples_, internalFormat_, width_, height_, depth_, fixedSampleLocations_ );
}

void glTextureImage2DMultisampleCoverageNVWrapper(GLuint texture_, GLenum target_, GLsizei coverageSamples_, GLsizei colorSamples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC, "glTextureImage2DMultisampleCoverageNV");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)( texture_, target_, coverageSamples_, colorSamples_, internalFormat_, width_, height_, fixedSampleLocations_ );
}

void glTextureImage3DMultisampleCoverageNVWrapper(GLuint texture_, GLenum target_, GLsizei coverageSamples_, GLsizei colorSamples_, GLint internalFormat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLboolean fixedSampleLocations_)
{
  RESOLVE(PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC, "glTextureImage3DMultisampleCoverageNV");
  RESOLVED_PROC(PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)( texture_, target_, coverageSamples_, colorSamples_, internalFormat_, width_, height_, depth_, fixedSampleLocations_ );
}

void glBeginTransformFeedbackNVWrapper(GLenum primitiveMode_)
{
  RESOLVE(PFNGLBEGINTRANSFORMFEEDBACKNVPROC, "glBeginTransformFeedbackNV");
  RESOLVED_PROC(PFNGLBEGINTRANSFORMFEEDBACKNVPROC)( primitiveMode_ );
}

void glEndTransformFeedbackNVWrapper(void)
{
  RESOLVE(PFNGLENDTRANSFORMFEEDBACKNVPROC, "glEndTransformFeedbackNV");
  RESOLVED_PROC(PFNGLENDTRANSFORMFEEDBACKNVPROC)(  );
}

void glTransformFeedbackAttribsNVWrapper(GLsizei count_, const GLint* attribs_, GLenum bufferMode_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC, "glTransformFeedbackAttribsNV");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)( count_, attribs_, bufferMode_ );
}

void glBindBufferRangeNVWrapper(GLenum target_, GLuint index_, GLuint buffer_, GLintptr offset_, GLsizeiptr size_)
{
  RESOLVE(PFNGLBINDBUFFERRANGENVPROC, "glBindBufferRangeNV");
  RESOLVED_PROC(PFNGLBINDBUFFERRANGENVPROC)( target_, index_, buffer_, offset_, size_ );
}

void glBindBufferOffsetNVWrapper(GLenum target_, GLuint index_, GLuint buffer_, GLintptr offset_)
{
  RESOLVE(PFNGLBINDBUFFEROFFSETNVPROC, "glBindBufferOffsetNV");
  RESOLVED_PROC(PFNGLBINDBUFFEROFFSETNVPROC)( target_, index_, buffer_, offset_ );
}

void glBindBufferBaseNVWrapper(GLenum target_, GLuint index_, GLuint buffer_)
{
  RESOLVE(PFNGLBINDBUFFERBASENVPROC, "glBindBufferBaseNV");
  RESOLVED_PROC(PFNGLBINDBUFFERBASENVPROC)( target_, index_, buffer_ );
}

void glTransformFeedbackVaryingsNVWrapper(GLuint program_, GLsizei count_, const GLint* locations_, GLenum bufferMode_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC, "glTransformFeedbackVaryingsNV");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)( program_, count_, locations_, bufferMode_ );
}

void glActiveVaryingNVWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE(PFNGLACTIVEVARYINGNVPROC, "glActiveVaryingNV");
  RESOLVED_PROC(PFNGLACTIVEVARYINGNVPROC)( program_, name_ );
}

GLint glGetVaryingLocationNVWrapper(GLuint program_, const GLchar* name_)
{
  RESOLVE_RET(PFNGLGETVARYINGLOCATIONNVPROC, "glGetVaryingLocationNV", FALSE);
  return RESOLVED_PROC(PFNGLGETVARYINGLOCATIONNVPROC)(program_, name_ );
}

void glGetActiveVaryingNVWrapper(GLuint program_, GLuint index_, GLsizei bufSize_, GLsizei* length_, GLsizei* size_, GLenum* type_, GLchar* name_)
{
  RESOLVE(PFNGLGETACTIVEVARYINGNVPROC, "glGetActiveVaryingNV");
  RESOLVED_PROC(PFNGLGETACTIVEVARYINGNVPROC)( program_, index_, bufSize_, length_, size_, type_, name_ );
}

void glGetTransformFeedbackVaryingNVWrapper(GLuint program_, GLuint index_, GLint* location_)
{
  RESOLVE(PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC, "glGetTransformFeedbackVaryingNV");
  RESOLVED_PROC(PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)( program_, index_, location_ );
}

void glTransformFeedbackStreamAttribsNVWrapper(GLsizei count_, const GLint* attribs_, GLsizei nbuffers_, const GLint* bufstreams_, GLenum bufferMode_)
{
  RESOLVE(PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC, "glTransformFeedbackStreamAttribsNV");
  RESOLVED_PROC(PFNGLTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC)( count_, attribs_, nbuffers_, bufstreams_, bufferMode_ );
}

void glBindTransformFeedbackNVWrapper(GLenum target_, GLuint id_)
{
  RESOLVE(PFNGLBINDTRANSFORMFEEDBACKNVPROC, "glBindTransformFeedbackNV");
  RESOLVED_PROC(PFNGLBINDTRANSFORMFEEDBACKNVPROC)( target_, id_ );
}

void glDeleteTransformFeedbacksNVWrapper(GLsizei n_, const GLuint* ids_)
{
  RESOLVE(PFNGLDELETETRANSFORMFEEDBACKSNVPROC, "glDeleteTransformFeedbacksNV");
  RESOLVED_PROC(PFNGLDELETETRANSFORMFEEDBACKSNVPROC)( n_, ids_ );
}

void glGenTransformFeedbacksNVWrapper(GLsizei n_, GLuint* ids_)
{
  RESOLVE(PFNGLGENTRANSFORMFEEDBACKSNVPROC, "glGenTransformFeedbacksNV");
  RESOLVED_PROC(PFNGLGENTRANSFORMFEEDBACKSNVPROC)( n_, ids_ );
}

GLboolean glIsTransformFeedbackNVWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISTRANSFORMFEEDBACKNVPROC, "glIsTransformFeedbackNV", FALSE);
  return RESOLVED_PROC(PFNGLISTRANSFORMFEEDBACKNVPROC)(id_ );
}

void glPauseTransformFeedbackNVWrapper(void)
{
  RESOLVE(PFNGLPAUSETRANSFORMFEEDBACKNVPROC, "glPauseTransformFeedbackNV");
  RESOLVED_PROC(PFNGLPAUSETRANSFORMFEEDBACKNVPROC)(  );
}

void glResumeTransformFeedbackNVWrapper(void)
{
  RESOLVE(PFNGLRESUMETRANSFORMFEEDBACKNVPROC, "glResumeTransformFeedbackNV");
  RESOLVED_PROC(PFNGLRESUMETRANSFORMFEEDBACKNVPROC)(  );
}

void glDrawTransformFeedbackNVWrapper(GLenum mode_, GLuint id_)
{
  RESOLVE(PFNGLDRAWTRANSFORMFEEDBACKNVPROC, "glDrawTransformFeedbackNV");
  RESOLVED_PROC(PFNGLDRAWTRANSFORMFEEDBACKNVPROC)( mode_, id_ );
}

void glVDPAUInitNVWrapper(const void * vdpDevice_, const void * getProcAddress_)
{
  RESOLVE(PFNGLVDPAUINITNVPROC, "glVDPAUInitNV");
  RESOLVED_PROC(PFNGLVDPAUINITNVPROC)( vdpDevice_, getProcAddress_ );
}

void glVDPAUFiniNVWrapper(void)
{
  RESOLVE(PFNGLVDPAUFININVPROC, "glVDPAUFiniNV");
  RESOLVED_PROC(PFNGLVDPAUFININVPROC)(  );
}

GLvdpauSurfaceNV glVDPAURegisterVideoSurfaceNVWrapper(const void * vdpSurface_, GLenum target_, GLsizei numTextureNames_, const GLuint* textureNames_)
{
  RESOLVE_RET(PFNGLVDPAUREGISTERVIDEOSURFACENVPROC, "glVDPAURegisterVideoSurfaceNV", FALSE);
  return RESOLVED_PROC(PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)(vdpSurface_, target_, numTextureNames_, textureNames_ );
}

GLvdpauSurfaceNV glVDPAURegisterOutputSurfaceNVWrapper(const void * vdpSurface_, GLenum target_, GLsizei numTextureNames_, const GLuint* textureNames_)
{
  RESOLVE_RET(PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC, "glVDPAURegisterOutputSurfaceNV", FALSE);
  return RESOLVED_PROC(PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)(vdpSurface_, target_, numTextureNames_, textureNames_ );
}

GLboolean glVDPAUIsSurfaceNVWrapper(GLvdpauSurfaceNV surface_)
{
  RESOLVE_RET(PFNGLVDPAUISSURFACENVPROC, "glVDPAUIsSurfaceNV", FALSE);
  return RESOLVED_PROC(PFNGLVDPAUISSURFACENVPROC)(surface_ );
}

void glVDPAUUnregisterSurfaceNVWrapper(GLvdpauSurfaceNV surface_)
{
  RESOLVE(PFNGLVDPAUUNREGISTERSURFACENVPROC, "glVDPAUUnregisterSurfaceNV");
  RESOLVED_PROC(PFNGLVDPAUUNREGISTERSURFACENVPROC)( surface_ );
}

void glVDPAUGetSurfaceivNVWrapper(GLvdpauSurfaceNV surface_, GLenum pname_, GLsizei bufSize_, GLsizei* length_, GLint* values_)
{
  RESOLVE(PFNGLVDPAUGETSURFACEIVNVPROC, "glVDPAUGetSurfaceivNV");
  RESOLVED_PROC(PFNGLVDPAUGETSURFACEIVNVPROC)( surface_, pname_, bufSize_, length_, values_ );
}

void glVDPAUSurfaceAccessNVWrapper(GLvdpauSurfaceNV surface_, GLenum access_)
{
  RESOLVE(PFNGLVDPAUSURFACEACCESSNVPROC, "glVDPAUSurfaceAccessNV");
  RESOLVED_PROC(PFNGLVDPAUSURFACEACCESSNVPROC)( surface_, access_ );
}

void glVDPAUMapSurfacesNVWrapper(GLsizei numSurfaces_, const GLvdpauSurfaceNV* surfaces_)
{
  RESOLVE(PFNGLVDPAUMAPSURFACESNVPROC, "glVDPAUMapSurfacesNV");
  RESOLVED_PROC(PFNGLVDPAUMAPSURFACESNVPROC)( numSurfaces_, surfaces_ );
}

void glVDPAUUnmapSurfacesNVWrapper(GLsizei numSurface_, const GLvdpauSurfaceNV* surfaces_)
{
  RESOLVE(PFNGLVDPAUUNMAPSURFACESNVPROC, "glVDPAUUnmapSurfacesNV");
  RESOLVED_PROC(PFNGLVDPAUUNMAPSURFACESNVPROC)( numSurface_, surfaces_ );
}

void glFlushVertexArrayRangeNVWrapper(void)
{
  RESOLVE(PFNGLFLUSHVERTEXARRAYRANGENVPROC, "glFlushVertexArrayRangeNV");
  RESOLVED_PROC(PFNGLFLUSHVERTEXARRAYRANGENVPROC)(  );
}

void glVertexArrayRangeNVWrapper(GLsizei length_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXARRAYRANGENVPROC, "glVertexArrayRangeNV");
  RESOLVED_PROC(PFNGLVERTEXARRAYRANGENVPROC)( length_, pointer_ );
}

void glVertexAttribL1i64NVWrapper(GLuint index_, GLint64EXT x_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1I64NVPROC, "glVertexAttribL1i64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1I64NVPROC)( index_, x_ );
}

void glVertexAttribL2i64NVWrapper(GLuint index_, GLint64EXT x_, GLint64EXT y_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2I64NVPROC, "glVertexAttribL2i64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2I64NVPROC)( index_, x_, y_ );
}

void glVertexAttribL3i64NVWrapper(GLuint index_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3I64NVPROC, "glVertexAttribL3i64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3I64NVPROC)( index_, x_, y_, z_ );
}

void glVertexAttribL4i64NVWrapper(GLuint index_, GLint64EXT x_, GLint64EXT y_, GLint64EXT z_, GLint64EXT w_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4I64NVPROC, "glVertexAttribL4i64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4I64NVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribL1i64vNVWrapper(GLuint index_, const GLint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1I64VNVPROC, "glVertexAttribL1i64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1I64VNVPROC)( index_, v_ );
}

void glVertexAttribL2i64vNVWrapper(GLuint index_, const GLint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2I64VNVPROC, "glVertexAttribL2i64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2I64VNVPROC)( index_, v_ );
}

void glVertexAttribL3i64vNVWrapper(GLuint index_, const GLint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3I64VNVPROC, "glVertexAttribL3i64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3I64VNVPROC)( index_, v_ );
}

void glVertexAttribL4i64vNVWrapper(GLuint index_, const GLint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4I64VNVPROC, "glVertexAttribL4i64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4I64VNVPROC)( index_, v_ );
}

void glVertexAttribL1ui64NVWrapper(GLuint index_, GLuint64EXT x_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1UI64NVPROC, "glVertexAttribL1ui64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1UI64NVPROC)( index_, x_ );
}

void glVertexAttribL2ui64NVWrapper(GLuint index_, GLuint64EXT x_, GLuint64EXT y_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2UI64NVPROC, "glVertexAttribL2ui64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2UI64NVPROC)( index_, x_, y_ );
}

void glVertexAttribL3ui64NVWrapper(GLuint index_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3UI64NVPROC, "glVertexAttribL3ui64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3UI64NVPROC)( index_, x_, y_, z_ );
}

void glVertexAttribL4ui64NVWrapper(GLuint index_, GLuint64EXT x_, GLuint64EXT y_, GLuint64EXT z_, GLuint64EXT w_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4UI64NVPROC, "glVertexAttribL4ui64NV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4UI64NVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribL1ui64vNVWrapper(GLuint index_, const GLuint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL1UI64VNVPROC, "glVertexAttribL1ui64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL1UI64VNVPROC)( index_, v_ );
}

void glVertexAttribL2ui64vNVWrapper(GLuint index_, const GLuint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL2UI64VNVPROC, "glVertexAttribL2ui64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL2UI64VNVPROC)( index_, v_ );
}

void glVertexAttribL3ui64vNVWrapper(GLuint index_, const GLuint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL3UI64VNVPROC, "glVertexAttribL3ui64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL3UI64VNVPROC)( index_, v_ );
}

void glVertexAttribL4ui64vNVWrapper(GLuint index_, const GLuint64EXT* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBL4UI64VNVPROC, "glVertexAttribL4ui64vNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBL4UI64VNVPROC)( index_, v_ );
}

void glGetVertexAttribLi64vNVWrapper(GLuint index_, GLenum pname_, GLint64EXT* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBLI64VNVPROC, "glGetVertexAttribLi64vNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBLI64VNVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribLui64vNVWrapper(GLuint index_, GLenum pname_, GLuint64EXT* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBLUI64VNVPROC, "glGetVertexAttribLui64vNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBLUI64VNVPROC)( index_, pname_, params_ );
}

void glVertexAttribLFormatNVWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXATTRIBLFORMATNVPROC, "glVertexAttribLFormatNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBLFORMATNVPROC)( index_, size_, type_, stride_ );
}

void glBufferAddressRangeNVWrapper(GLenum pname_, GLuint index_, GLuint64EXT address_, GLsizeiptr length_)
{
  RESOLVE(PFNGLBUFFERADDRESSRANGENVPROC, "glBufferAddressRangeNV");
  RESOLVED_PROC(PFNGLBUFFERADDRESSRANGENVPROC)( pname_, index_, address_, length_ );
}

void glVertexFormatNVWrapper(GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXFORMATNVPROC, "glVertexFormatNV");
  RESOLVED_PROC(PFNGLVERTEXFORMATNVPROC)( size_, type_, stride_ );
}

void glNormalFormatNVWrapper(GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLNORMALFORMATNVPROC, "glNormalFormatNV");
  RESOLVED_PROC(PFNGLNORMALFORMATNVPROC)( type_, stride_ );
}

void glColorFormatNVWrapper(GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLCOLORFORMATNVPROC, "glColorFormatNV");
  RESOLVED_PROC(PFNGLCOLORFORMATNVPROC)( size_, type_, stride_ );
}

void glIndexFormatNVWrapper(GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLINDEXFORMATNVPROC, "glIndexFormatNV");
  RESOLVED_PROC(PFNGLINDEXFORMATNVPROC)( type_, stride_ );
}

void glTexCoordFormatNVWrapper(GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLTEXCOORDFORMATNVPROC, "glTexCoordFormatNV");
  RESOLVED_PROC(PFNGLTEXCOORDFORMATNVPROC)( size_, type_, stride_ );
}

void glEdgeFlagFormatNVWrapper(GLsizei stride_)
{
  RESOLVE(PFNGLEDGEFLAGFORMATNVPROC, "glEdgeFlagFormatNV");
  RESOLVED_PROC(PFNGLEDGEFLAGFORMATNVPROC)( stride_ );
}

void glSecondaryColorFormatNVWrapper(GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLSECONDARYCOLORFORMATNVPROC, "glSecondaryColorFormatNV");
  RESOLVED_PROC(PFNGLSECONDARYCOLORFORMATNVPROC)( size_, type_, stride_ );
}

void glFogCoordFormatNVWrapper(GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLFOGCOORDFORMATNVPROC, "glFogCoordFormatNV");
  RESOLVED_PROC(PFNGLFOGCOORDFORMATNVPROC)( type_, stride_ );
}

void glVertexAttribFormatNVWrapper(GLuint index_, GLint size_, GLenum type_, GLboolean normalized_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXATTRIBFORMATNVPROC, "glVertexAttribFormatNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBFORMATNVPROC)( index_, size_, type_, normalized_, stride_ );
}

void glVertexAttribIFormatNVWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_)
{
  RESOLVE(PFNGLVERTEXATTRIBIFORMATNVPROC, "glVertexAttribIFormatNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBIFORMATNVPROC)( index_, size_, type_, stride_ );
}

void glGetIntegerui64i_vNVWrapper(GLenum value_, GLuint index_, GLuint64EXT* result_)
{
  RESOLVE(PFNGLGETINTEGERUI64I_VNVPROC, "glGetIntegerui64i_vNV");
  RESOLVED_PROC(PFNGLGETINTEGERUI64I_VNVPROC)( value_, index_, result_ );
}

GLboolean glAreProgramsResidentNVWrapper(GLsizei n_, const GLuint* programs_, GLboolean* residences_)
{
  RESOLVE_RET(PFNGLAREPROGRAMSRESIDENTNVPROC, "glAreProgramsResidentNV", FALSE);
  return RESOLVED_PROC(PFNGLAREPROGRAMSRESIDENTNVPROC)(n_, programs_, residences_ );
}

void glBindProgramNVWrapper(GLenum target_, GLuint id_)
{
  RESOLVE(PFNGLBINDPROGRAMNVPROC, "glBindProgramNV");
  RESOLVED_PROC(PFNGLBINDPROGRAMNVPROC)( target_, id_ );
}

void glDeleteProgramsNVWrapper(GLsizei n_, const GLuint* programs_)
{
  RESOLVE(PFNGLDELETEPROGRAMSNVPROC, "glDeleteProgramsNV");
  RESOLVED_PROC(PFNGLDELETEPROGRAMSNVPROC)( n_, programs_ );
}

void glExecuteProgramNVWrapper(GLenum target_, GLuint id_, const GLfloat* params_)
{
  RESOLVE(PFNGLEXECUTEPROGRAMNVPROC, "glExecuteProgramNV");
  RESOLVED_PROC(PFNGLEXECUTEPROGRAMNVPROC)( target_, id_, params_ );
}

void glGenProgramsNVWrapper(GLsizei n_, GLuint* programs_)
{
  RESOLVE(PFNGLGENPROGRAMSNVPROC, "glGenProgramsNV");
  RESOLVED_PROC(PFNGLGENPROGRAMSNVPROC)( n_, programs_ );
}

void glGetProgramParameterdvNVWrapper(GLenum target_, GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETPROGRAMPARAMETERDVNVPROC, "glGetProgramParameterdvNV");
  RESOLVED_PROC(PFNGLGETPROGRAMPARAMETERDVNVPROC)( target_, index_, pname_, params_ );
}

void glGetProgramParameterfvNVWrapper(GLenum target_, GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPROGRAMPARAMETERFVNVPROC, "glGetProgramParameterfvNV");
  RESOLVED_PROC(PFNGLGETPROGRAMPARAMETERFVNVPROC)( target_, index_, pname_, params_ );
}

void glGetProgramivNVWrapper(GLuint id_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPROGRAMIVNVPROC, "glGetProgramivNV");
  RESOLVED_PROC(PFNGLGETPROGRAMIVNVPROC)( id_, pname_, params_ );
}

void glGetProgramStringNVWrapper(GLuint id_, GLenum pname_, GLubyte* program_)
{
  RESOLVE(PFNGLGETPROGRAMSTRINGNVPROC, "glGetProgramStringNV");
  RESOLVED_PROC(PFNGLGETPROGRAMSTRINGNVPROC)( id_, pname_, program_ );
}

void glGetTrackMatrixivNVWrapper(GLenum target_, GLuint address_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETTRACKMATRIXIVNVPROC, "glGetTrackMatrixivNV");
  RESOLVED_PROC(PFNGLGETTRACKMATRIXIVNVPROC)( target_, address_, pname_, params_ );
}

void glGetVertexAttribdvNVWrapper(GLuint index_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBDVNVPROC, "glGetVertexAttribdvNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBDVNVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribfvNVWrapper(GLuint index_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBFVNVPROC, "glGetVertexAttribfvNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBFVNVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribivNVWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIVNVPROC, "glGetVertexAttribivNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIVNVPROC)( index_, pname_, params_ );
}

void glGetVertexAttribPointervNVWrapper(GLuint index_, GLenum pname_, void ** pointer_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBPOINTERVNVPROC, "glGetVertexAttribPointervNV");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBPOINTERVNVPROC)( index_, pname_, pointer_ );
}

GLboolean glIsProgramNVWrapper(GLuint id_)
{
  RESOLVE_RET(PFNGLISPROGRAMNVPROC, "glIsProgramNV", FALSE);
  return RESOLVED_PROC(PFNGLISPROGRAMNVPROC)(id_ );
}

void glLoadProgramNVWrapper(GLenum target_, GLuint id_, GLsizei len_, const GLubyte* program_)
{
  RESOLVE(PFNGLLOADPROGRAMNVPROC, "glLoadProgramNV");
  RESOLVED_PROC(PFNGLLOADPROGRAMNVPROC)( target_, id_, len_, program_ );
}

void glProgramParameter4dNVWrapper(GLenum target_, GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLPROGRAMPARAMETER4DNVPROC, "glProgramParameter4dNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETER4DNVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramParameter4dvNVWrapper(GLenum target_, GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLPROGRAMPARAMETER4DVNVPROC, "glProgramParameter4dvNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETER4DVNVPROC)( target_, index_, v_ );
}

void glProgramParameter4fNVWrapper(GLenum target_, GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLPROGRAMPARAMETER4FNVPROC, "glProgramParameter4fNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETER4FNVPROC)( target_, index_, x_, y_, z_, w_ );
}

void glProgramParameter4fvNVWrapper(GLenum target_, GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLPROGRAMPARAMETER4FVNVPROC, "glProgramParameter4fvNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETER4FVNVPROC)( target_, index_, v_ );
}

void glProgramParameters4dvNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLPROGRAMPARAMETERS4DVNVPROC, "glProgramParameters4dvNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETERS4DVNVPROC)( target_, index_, count_, v_ );
}

void glProgramParameters4fvNVWrapper(GLenum target_, GLuint index_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLPROGRAMPARAMETERS4FVNVPROC, "glProgramParameters4fvNV");
  RESOLVED_PROC(PFNGLPROGRAMPARAMETERS4FVNVPROC)( target_, index_, count_, v_ );
}

void glRequestResidentProgramsNVWrapper(GLsizei n_, const GLuint* programs_)
{
  RESOLVE(PFNGLREQUESTRESIDENTPROGRAMSNVPROC, "glRequestResidentProgramsNV");
  RESOLVED_PROC(PFNGLREQUESTRESIDENTPROGRAMSNVPROC)( n_, programs_ );
}

void glTrackMatrixNVWrapper(GLenum target_, GLuint address_, GLenum matrix_, GLenum transform_)
{
  RESOLVE(PFNGLTRACKMATRIXNVPROC, "glTrackMatrixNV");
  RESOLVED_PROC(PFNGLTRACKMATRIXNVPROC)( target_, address_, matrix_, transform_ );
}

void glVertexAttribPointerNVWrapper(GLuint index_, GLint fsize_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBPOINTERNVPROC, "glVertexAttribPointerNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBPOINTERNVPROC)( index_, fsize_, type_, stride_, pointer_ );
}

void glVertexAttrib1dNVWrapper(GLuint index_, GLdouble x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DNVPROC, "glVertexAttrib1dNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DNVPROC)( index_, x_ );
}

void glVertexAttrib1dvNVWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1DVNVPROC, "glVertexAttrib1dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1DVNVPROC)( index_, v_ );
}

void glVertexAttrib1fNVWrapper(GLuint index_, GLfloat x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FNVPROC, "glVertexAttrib1fNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FNVPROC)( index_, x_ );
}

void glVertexAttrib1fvNVWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1FVNVPROC, "glVertexAttrib1fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1FVNVPROC)( index_, v_ );
}

void glVertexAttrib1sNVWrapper(GLuint index_, GLshort x_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SNVPROC, "glVertexAttrib1sNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SNVPROC)( index_, x_ );
}

void glVertexAttrib1svNVWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB1SVNVPROC, "glVertexAttrib1svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB1SVNVPROC)( index_, v_ );
}

void glVertexAttrib2dNVWrapper(GLuint index_, GLdouble x_, GLdouble y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DNVPROC, "glVertexAttrib2dNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DNVPROC)( index_, x_, y_ );
}

void glVertexAttrib2dvNVWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2DVNVPROC, "glVertexAttrib2dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2DVNVPROC)( index_, v_ );
}

void glVertexAttrib2fNVWrapper(GLuint index_, GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FNVPROC, "glVertexAttrib2fNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FNVPROC)( index_, x_, y_ );
}

void glVertexAttrib2fvNVWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2FVNVPROC, "glVertexAttrib2fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2FVNVPROC)( index_, v_ );
}

void glVertexAttrib2sNVWrapper(GLuint index_, GLshort x_, GLshort y_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SNVPROC, "glVertexAttrib2sNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SNVPROC)( index_, x_, y_ );
}

void glVertexAttrib2svNVWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB2SVNVPROC, "glVertexAttrib2svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB2SVNVPROC)( index_, v_ );
}

void glVertexAttrib3dNVWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DNVPROC, "glVertexAttrib3dNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DNVPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3dvNVWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3DVNVPROC, "glVertexAttrib3dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3DVNVPROC)( index_, v_ );
}

void glVertexAttrib3fNVWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FNVPROC, "glVertexAttrib3fNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FNVPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3fvNVWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3FVNVPROC, "glVertexAttrib3fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3FVNVPROC)( index_, v_ );
}

void glVertexAttrib3sNVWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SNVPROC, "glVertexAttrib3sNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SNVPROC)( index_, x_, y_, z_ );
}

void glVertexAttrib3svNVWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB3SVNVPROC, "glVertexAttrib3svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB3SVNVPROC)( index_, v_ );
}

void glVertexAttrib4dNVWrapper(GLuint index_, GLdouble x_, GLdouble y_, GLdouble z_, GLdouble w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DNVPROC, "glVertexAttrib4dNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DNVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4dvNVWrapper(GLuint index_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4DVNVPROC, "glVertexAttrib4dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4DVNVPROC)( index_, v_ );
}

void glVertexAttrib4fNVWrapper(GLuint index_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FNVPROC, "glVertexAttrib4fNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FNVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4fvNVWrapper(GLuint index_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4FVNVPROC, "glVertexAttrib4fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4FVNVPROC)( index_, v_ );
}

void glVertexAttrib4sNVWrapper(GLuint index_, GLshort x_, GLshort y_, GLshort z_, GLshort w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SNVPROC, "glVertexAttrib4sNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SNVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4svNVWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4SVNVPROC, "glVertexAttrib4svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4SVNVPROC)( index_, v_ );
}

void glVertexAttrib4ubNVWrapper(GLuint index_, GLubyte x_, GLubyte y_, GLubyte z_, GLubyte w_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UBNVPROC, "glVertexAttrib4ubNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UBNVPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttrib4ubvNVWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIB4UBVNVPROC, "glVertexAttrib4ubvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIB4UBVNVPROC)( index_, v_ );
}

void glVertexAttribs1dvNVWrapper(GLuint index_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS1DVNVPROC, "glVertexAttribs1dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS1DVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs1fvNVWrapper(GLuint index_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS1FVNVPROC, "glVertexAttribs1fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS1FVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs1svNVWrapper(GLuint index_, GLsizei count_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS1SVNVPROC, "glVertexAttribs1svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS1SVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs2dvNVWrapper(GLuint index_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS2DVNVPROC, "glVertexAttribs2dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS2DVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs2fvNVWrapper(GLuint index_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS2FVNVPROC, "glVertexAttribs2fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS2FVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs2svNVWrapper(GLuint index_, GLsizei count_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS2SVNVPROC, "glVertexAttribs2svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS2SVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs3dvNVWrapper(GLuint index_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS3DVNVPROC, "glVertexAttribs3dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS3DVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs3fvNVWrapper(GLuint index_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS3FVNVPROC, "glVertexAttribs3fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS3FVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs3svNVWrapper(GLuint index_, GLsizei count_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS3SVNVPROC, "glVertexAttribs3svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS3SVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs4dvNVWrapper(GLuint index_, GLsizei count_, const GLdouble* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS4DVNVPROC, "glVertexAttribs4dvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS4DVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs4fvNVWrapper(GLuint index_, GLsizei count_, const GLfloat* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS4FVNVPROC, "glVertexAttribs4fvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS4FVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs4svNVWrapper(GLuint index_, GLsizei count_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS4SVNVPROC, "glVertexAttribs4svNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS4SVNVPROC)( index_, count_, v_ );
}

void glVertexAttribs4ubvNVWrapper(GLuint index_, GLsizei count_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBS4UBVNVPROC, "glVertexAttribs4ubvNV");
  RESOLVED_PROC(PFNGLVERTEXATTRIBS4UBVNVPROC)( index_, count_, v_ );
}

void glVertexAttribI1iEXTWrapper(GLuint index_, GLint x_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1IEXTPROC, "glVertexAttribI1iEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1IEXTPROC)( index_, x_ );
}

void glVertexAttribI2iEXTWrapper(GLuint index_, GLint x_, GLint y_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2IEXTPROC, "glVertexAttribI2iEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2IEXTPROC)( index_, x_, y_ );
}

void glVertexAttribI3iEXTWrapper(GLuint index_, GLint x_, GLint y_, GLint z_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3IEXTPROC, "glVertexAttribI3iEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3IEXTPROC)( index_, x_, y_, z_ );
}

void glVertexAttribI4iEXTWrapper(GLuint index_, GLint x_, GLint y_, GLint z_, GLint w_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4IEXTPROC, "glVertexAttribI4iEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4IEXTPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribI1uiEXTWrapper(GLuint index_, GLuint x_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1UIEXTPROC, "glVertexAttribI1uiEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1UIEXTPROC)( index_, x_ );
}

void glVertexAttribI2uiEXTWrapper(GLuint index_, GLuint x_, GLuint y_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2UIEXTPROC, "glVertexAttribI2uiEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2UIEXTPROC)( index_, x_, y_ );
}

void glVertexAttribI3uiEXTWrapper(GLuint index_, GLuint x_, GLuint y_, GLuint z_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3UIEXTPROC, "glVertexAttribI3uiEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3UIEXTPROC)( index_, x_, y_, z_ );
}

void glVertexAttribI4uiEXTWrapper(GLuint index_, GLuint x_, GLuint y_, GLuint z_, GLuint w_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UIEXTPROC, "glVertexAttribI4uiEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UIEXTPROC)( index_, x_, y_, z_, w_ );
}

void glVertexAttribI1ivEXTWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1IVEXTPROC, "glVertexAttribI1ivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1IVEXTPROC)( index_, v_ );
}

void glVertexAttribI2ivEXTWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2IVEXTPROC, "glVertexAttribI2ivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2IVEXTPROC)( index_, v_ );
}

void glVertexAttribI3ivEXTWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3IVEXTPROC, "glVertexAttribI3ivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3IVEXTPROC)( index_, v_ );
}

void glVertexAttribI4ivEXTWrapper(GLuint index_, const GLint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4IVEXTPROC, "glVertexAttribI4ivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4IVEXTPROC)( index_, v_ );
}

void glVertexAttribI1uivEXTWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI1UIVEXTPROC, "glVertexAttribI1uivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI1UIVEXTPROC)( index_, v_ );
}

void glVertexAttribI2uivEXTWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI2UIVEXTPROC, "glVertexAttribI2uivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI2UIVEXTPROC)( index_, v_ );
}

void glVertexAttribI3uivEXTWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI3UIVEXTPROC, "glVertexAttribI3uivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI3UIVEXTPROC)( index_, v_ );
}

void glVertexAttribI4uivEXTWrapper(GLuint index_, const GLuint* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UIVEXTPROC, "glVertexAttribI4uivEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UIVEXTPROC)( index_, v_ );
}

void glVertexAttribI4bvEXTWrapper(GLuint index_, const GLbyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4BVEXTPROC, "glVertexAttribI4bvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4BVEXTPROC)( index_, v_ );
}

void glVertexAttribI4svEXTWrapper(GLuint index_, const GLshort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4SVEXTPROC, "glVertexAttribI4svEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4SVEXTPROC)( index_, v_ );
}

void glVertexAttribI4ubvEXTWrapper(GLuint index_, const GLubyte* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4UBVEXTPROC, "glVertexAttribI4ubvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4UBVEXTPROC)( index_, v_ );
}

void glVertexAttribI4usvEXTWrapper(GLuint index_, const GLushort* v_)
{
  RESOLVE(PFNGLVERTEXATTRIBI4USVEXTPROC, "glVertexAttribI4usvEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBI4USVEXTPROC)( index_, v_ );
}

void glVertexAttribIPointerEXTWrapper(GLuint index_, GLint size_, GLenum type_, GLsizei stride_, const void * pointer_)
{
  RESOLVE(PFNGLVERTEXATTRIBIPOINTEREXTPROC, "glVertexAttribIPointerEXT");
  RESOLVED_PROC(PFNGLVERTEXATTRIBIPOINTEREXTPROC)( index_, size_, type_, stride_, pointer_ );
}

void glGetVertexAttribIivEXTWrapper(GLuint index_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIIVEXTPROC, "glGetVertexAttribIivEXT");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIIVEXTPROC)( index_, pname_, params_ );
}

void glGetVertexAttribIuivEXTWrapper(GLuint index_, GLenum pname_, GLuint* params_)
{
  RESOLVE(PFNGLGETVERTEXATTRIBIUIVEXTPROC, "glGetVertexAttribIuivEXT");
  RESOLVED_PROC(PFNGLGETVERTEXATTRIBIUIVEXTPROC)( index_, pname_, params_ );
}

void glBeginVideoCaptureNVWrapper(GLuint video_capture_slot_)
{
  RESOLVE(PFNGLBEGINVIDEOCAPTURENVPROC, "glBeginVideoCaptureNV");
  RESOLVED_PROC(PFNGLBEGINVIDEOCAPTURENVPROC)( video_capture_slot_ );
}

void glBindVideoCaptureStreamBufferNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum frame_region_, GLintptrARB offset_)
{
  RESOLVE(PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC, "glBindVideoCaptureStreamBufferNV");
  RESOLVED_PROC(PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)( video_capture_slot_, stream_, frame_region_, offset_ );
}

void glBindVideoCaptureStreamTextureNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum frame_region_, GLenum target_, GLuint texture_)
{
  RESOLVE(PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC, "glBindVideoCaptureStreamTextureNV");
  RESOLVED_PROC(PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)( video_capture_slot_, stream_, frame_region_, target_, texture_ );
}

void glEndVideoCaptureNVWrapper(GLuint video_capture_slot_)
{
  RESOLVE(PFNGLENDVIDEOCAPTURENVPROC, "glEndVideoCaptureNV");
  RESOLVED_PROC(PFNGLENDVIDEOCAPTURENVPROC)( video_capture_slot_ );
}

void glGetVideoCaptureivNVWrapper(GLuint video_capture_slot_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVIDEOCAPTUREIVNVPROC, "glGetVideoCaptureivNV");
  RESOLVED_PROC(PFNGLGETVIDEOCAPTUREIVNVPROC)( video_capture_slot_, pname_, params_ );
}

void glGetVideoCaptureStreamivNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETVIDEOCAPTURESTREAMIVNVPROC, "glGetVideoCaptureStreamivNV");
  RESOLVED_PROC(PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

void glGetVideoCaptureStreamfvNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETVIDEOCAPTURESTREAMFVNVPROC, "glGetVideoCaptureStreamfvNV");
  RESOLVED_PROC(PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

void glGetVideoCaptureStreamdvNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, GLdouble* params_)
{
  RESOLVE(PFNGLGETVIDEOCAPTURESTREAMDVNVPROC, "glGetVideoCaptureStreamdvNV");
  RESOLVED_PROC(PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

GLenum glVideoCaptureNVWrapper(GLuint video_capture_slot_, GLuint* sequence_num_, GLuint64EXT* capture_time_)
{
  RESOLVE_RET(PFNGLVIDEOCAPTURENVPROC, "glVideoCaptureNV", FALSE);
  return RESOLVED_PROC(PFNGLVIDEOCAPTURENVPROC)(video_capture_slot_, sequence_num_, capture_time_ );
}

void glVideoCaptureStreamParameterivNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC, "glVideoCaptureStreamParameterivNV");
  RESOLVED_PROC(PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

void glVideoCaptureStreamParameterfvNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC, "glVideoCaptureStreamParameterfvNV");
  RESOLVED_PROC(PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

void glVideoCaptureStreamParameterdvNVWrapper(GLuint video_capture_slot_, GLuint stream_, GLenum pname_, const GLdouble* params_)
{
  RESOLVE(PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC, "glVideoCaptureStreamParameterdvNV");
  RESOLVED_PROC(PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)( video_capture_slot_, stream_, pname_, params_ );
}

void glFramebufferTextureMultiviewOVRWrapper(GLenum target_, GLenum attachment_, GLuint texture_, GLint level_, GLint baseViewIndex_, GLsizei numViews_)
{
  RESOLVE(PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC, "glFramebufferTextureMultiviewOVR");
  RESOLVED_PROC(PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)( target_, attachment_, texture_, level_, baseViewIndex_, numViews_ );
}

void glHintPGIWrapper(GLenum target_, GLint mode_)
{
  RESOLVE(PFNGLHINTPGIPROC, "glHintPGI");
  RESOLVED_PROC(PFNGLHINTPGIPROC)( target_, mode_ );
}

void glDetailTexFuncSGISWrapper(GLenum target_, GLsizei n_, const GLfloat* points_)
{
  RESOLVE(PFNGLDETAILTEXFUNCSGISPROC, "glDetailTexFuncSGIS");
  RESOLVED_PROC(PFNGLDETAILTEXFUNCSGISPROC)( target_, n_, points_ );
}

void glGetDetailTexFuncSGISWrapper(GLenum target_, GLfloat* points_)
{
  RESOLVE(PFNGLGETDETAILTEXFUNCSGISPROC, "glGetDetailTexFuncSGIS");
  RESOLVED_PROC(PFNGLGETDETAILTEXFUNCSGISPROC)( target_, points_ );
}

void glFogFuncSGISWrapper(GLsizei n_, const GLfloat* points_)
{
  RESOLVE(PFNGLFOGFUNCSGISPROC, "glFogFuncSGIS");
  RESOLVED_PROC(PFNGLFOGFUNCSGISPROC)( n_, points_ );
}

void glGetFogFuncSGISWrapper(GLfloat* points_)
{
  RESOLVE(PFNGLGETFOGFUNCSGISPROC, "glGetFogFuncSGIS");
  RESOLVED_PROC(PFNGLGETFOGFUNCSGISPROC)( points_ );
}

void glSampleMaskSGISWrapper(GLclampf value_, GLboolean invert_)
{
  RESOLVE(PFNGLSAMPLEMASKSGISPROC, "glSampleMaskSGIS");
  RESOLVED_PROC(PFNGLSAMPLEMASKSGISPROC)( value_, invert_ );
}

void glSamplePatternSGISWrapper(GLenum pattern_)
{
  RESOLVE(PFNGLSAMPLEPATTERNSGISPROC, "glSamplePatternSGIS");
  RESOLVED_PROC(PFNGLSAMPLEPATTERNSGISPROC)( pattern_ );
}

void glPixelTexGenParameteriSGISWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLPIXELTEXGENPARAMETERISGISPROC, "glPixelTexGenParameteriSGIS");
  RESOLVED_PROC(PFNGLPIXELTEXGENPARAMETERISGISPROC)( pname_, param_ );
}

void glPixelTexGenParameterivSGISWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLPIXELTEXGENPARAMETERIVSGISPROC, "glPixelTexGenParameterivSGIS");
  RESOLVED_PROC(PFNGLPIXELTEXGENPARAMETERIVSGISPROC)( pname_, params_ );
}

void glPixelTexGenParameterfSGISWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPIXELTEXGENPARAMETERFSGISPROC, "glPixelTexGenParameterfSGIS");
  RESOLVED_PROC(PFNGLPIXELTEXGENPARAMETERFSGISPROC)( pname_, param_ );
}

void glPixelTexGenParameterfvSGISWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPIXELTEXGENPARAMETERFVSGISPROC, "glPixelTexGenParameterfvSGIS");
  RESOLVED_PROC(PFNGLPIXELTEXGENPARAMETERFVSGISPROC)( pname_, params_ );
}

void glGetPixelTexGenParameterivSGISWrapper(GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC, "glGetPixelTexGenParameterivSGIS");
  RESOLVED_PROC(PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC)( pname_, params_ );
}

void glGetPixelTexGenParameterfvSGISWrapper(GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC, "glGetPixelTexGenParameterfvSGIS");
  RESOLVED_PROC(PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC)( pname_, params_ );
}

void glPointParameterfSGISWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLPOINTPARAMETERFSGISPROC, "glPointParameterfSGIS");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFSGISPROC)( pname_, param_ );
}

void glPointParameterfvSGISWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLPOINTPARAMETERFVSGISPROC, "glPointParameterfvSGIS");
  RESOLVED_PROC(PFNGLPOINTPARAMETERFVSGISPROC)( pname_, params_ );
}

void glSharpenTexFuncSGISWrapper(GLenum target_, GLsizei n_, const GLfloat* points_)
{
  RESOLVE(PFNGLSHARPENTEXFUNCSGISPROC, "glSharpenTexFuncSGIS");
  RESOLVED_PROC(PFNGLSHARPENTEXFUNCSGISPROC)( target_, n_, points_ );
}

void glGetSharpenTexFuncSGISWrapper(GLenum target_, GLfloat* points_)
{
  RESOLVE(PFNGLGETSHARPENTEXFUNCSGISPROC, "glGetSharpenTexFuncSGIS");
  RESOLVED_PROC(PFNGLGETSHARPENTEXFUNCSGISPROC)( target_, points_ );
}

void glTexImage4DSGISWrapper(GLenum target_, GLint level_, GLenum internalformat_, GLsizei width_, GLsizei height_, GLsizei depth_, GLsizei size4d_, GLint border_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXIMAGE4DSGISPROC, "glTexImage4DSGIS");
  RESOLVED_PROC(PFNGLTEXIMAGE4DSGISPROC)( target_, level_, internalformat_, width_, height_, depth_, size4d_, border_, format_, type_, pixels_ );
}

void glTexSubImage4DSGISWrapper(GLenum target_, GLint level_, GLint xoffset_, GLint yoffset_, GLint zoffset_, GLint woffset_, GLsizei width_, GLsizei height_, GLsizei depth_, GLsizei size4d_, GLenum format_, GLenum type_, const void * pixels_)
{
  RESOLVE(PFNGLTEXSUBIMAGE4DSGISPROC, "glTexSubImage4DSGIS");
  RESOLVED_PROC(PFNGLTEXSUBIMAGE4DSGISPROC)( target_, level_, xoffset_, yoffset_, zoffset_, woffset_, width_, height_, depth_, size4d_, format_, type_, pixels_ );
}

void glTextureColorMaskSGISWrapper(GLboolean red_, GLboolean green_, GLboolean blue_, GLboolean alpha_)
{
  RESOLVE(PFNGLTEXTURECOLORMASKSGISPROC, "glTextureColorMaskSGIS");
  RESOLVED_PROC(PFNGLTEXTURECOLORMASKSGISPROC)( red_, green_, blue_, alpha_ );
}

void glGetTexFilterFuncSGISWrapper(GLenum target_, GLenum filter_, GLfloat* weights_)
{
  RESOLVE(PFNGLGETTEXFILTERFUNCSGISPROC, "glGetTexFilterFuncSGIS");
  RESOLVED_PROC(PFNGLGETTEXFILTERFUNCSGISPROC)( target_, filter_, weights_ );
}

void glTexFilterFuncSGISWrapper(GLenum target_, GLenum filter_, GLsizei n_, const GLfloat* weights_)
{
  RESOLVE(PFNGLTEXFILTERFUNCSGISPROC, "glTexFilterFuncSGIS");
  RESOLVED_PROC(PFNGLTEXFILTERFUNCSGISPROC)( target_, filter_, n_, weights_ );
}

void glAsyncMarkerSGIXWrapper(GLuint marker_)
{
  RESOLVE(PFNGLASYNCMARKERSGIXPROC, "glAsyncMarkerSGIX");
  RESOLVED_PROC(PFNGLASYNCMARKERSGIXPROC)( marker_ );
}

GLint glFinishAsyncSGIXWrapper(GLuint* markerp_)
{
  RESOLVE_RET(PFNGLFINISHASYNCSGIXPROC, "glFinishAsyncSGIX", FALSE);
  return RESOLVED_PROC(PFNGLFINISHASYNCSGIXPROC)(markerp_ );
}

GLint glPollAsyncSGIXWrapper(GLuint* markerp_)
{
  RESOLVE_RET(PFNGLPOLLASYNCSGIXPROC, "glPollAsyncSGIX", FALSE);
  return RESOLVED_PROC(PFNGLPOLLASYNCSGIXPROC)(markerp_ );
}

GLuint glGenAsyncMarkersSGIXWrapper(GLsizei range_)
{
  RESOLVE_RET(PFNGLGENASYNCMARKERSSGIXPROC, "glGenAsyncMarkersSGIX", FALSE);
  return RESOLVED_PROC(PFNGLGENASYNCMARKERSSGIXPROC)(range_ );
}

void glDeleteAsyncMarkersSGIXWrapper(GLuint marker_, GLsizei range_)
{
  RESOLVE(PFNGLDELETEASYNCMARKERSSGIXPROC, "glDeleteAsyncMarkersSGIX");
  RESOLVED_PROC(PFNGLDELETEASYNCMARKERSSGIXPROC)( marker_, range_ );
}

GLboolean glIsAsyncMarkerSGIXWrapper(GLuint marker_)
{
  RESOLVE_RET(PFNGLISASYNCMARKERSGIXPROC, "glIsAsyncMarkerSGIX", FALSE);
  return RESOLVED_PROC(PFNGLISASYNCMARKERSGIXPROC)(marker_ );
}

void glFlushRasterSGIXWrapper(void)
{
  RESOLVE(PFNGLFLUSHRASTERSGIXPROC, "glFlushRasterSGIX");
  RESOLVED_PROC(PFNGLFLUSHRASTERSGIXPROC)(  );
}

void glFragmentColorMaterialSGIXWrapper(GLenum face_, GLenum mode_)
{
  RESOLVE(PFNGLFRAGMENTCOLORMATERIALSGIXPROC, "glFragmentColorMaterialSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTCOLORMATERIALSGIXPROC)( face_, mode_ );
}

void glFragmentLightfSGIXWrapper(GLenum light_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTFSGIXPROC, "glFragmentLightfSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTFSGIXPROC)( light_, pname_, param_ );
}

void glFragmentLightfvSGIXWrapper(GLenum light_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTFVSGIXPROC, "glFragmentLightfvSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTFVSGIXPROC)( light_, pname_, params_ );
}

void glFragmentLightiSGIXWrapper(GLenum light_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTISGIXPROC, "glFragmentLightiSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTISGIXPROC)( light_, pname_, param_ );
}

void glFragmentLightivSGIXWrapper(GLenum light_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTIVSGIXPROC, "glFragmentLightivSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTIVSGIXPROC)( light_, pname_, params_ );
}

void glFragmentLightModelfSGIXWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTMODELFSGIXPROC, "glFragmentLightModelfSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTMODELFSGIXPROC)( pname_, param_ );
}

void glFragmentLightModelfvSGIXWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTMODELFVSGIXPROC, "glFragmentLightModelfvSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)( pname_, params_ );
}

void glFragmentLightModeliSGIXWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTMODELISGIXPROC, "glFragmentLightModeliSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTMODELISGIXPROC)( pname_, param_ );
}

void glFragmentLightModelivSGIXWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLFRAGMENTLIGHTMODELIVSGIXPROC, "glFragmentLightModelivSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)( pname_, params_ );
}

void glFragmentMaterialfSGIXWrapper(GLenum face_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLFRAGMENTMATERIALFSGIXPROC, "glFragmentMaterialfSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTMATERIALFSGIXPROC)( face_, pname_, param_ );
}

void glFragmentMaterialfvSGIXWrapper(GLenum face_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLFRAGMENTMATERIALFVSGIXPROC, "glFragmentMaterialfvSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTMATERIALFVSGIXPROC)( face_, pname_, params_ );
}

void glFragmentMaterialiSGIXWrapper(GLenum face_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLFRAGMENTMATERIALISGIXPROC, "glFragmentMaterialiSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTMATERIALISGIXPROC)( face_, pname_, param_ );
}

void glFragmentMaterialivSGIXWrapper(GLenum face_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLFRAGMENTMATERIALIVSGIXPROC, "glFragmentMaterialivSGIX");
  RESOLVED_PROC(PFNGLFRAGMENTMATERIALIVSGIXPROC)( face_, pname_, params_ );
}

void glGetFragmentLightfvSGIXWrapper(GLenum light_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETFRAGMENTLIGHTFVSGIXPROC, "glGetFragmentLightfvSGIX");
  RESOLVED_PROC(PFNGLGETFRAGMENTLIGHTFVSGIXPROC)( light_, pname_, params_ );
}

void glGetFragmentLightivSGIXWrapper(GLenum light_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAGMENTLIGHTIVSGIXPROC, "glGetFragmentLightivSGIX");
  RESOLVED_PROC(PFNGLGETFRAGMENTLIGHTIVSGIXPROC)( light_, pname_, params_ );
}

void glGetFragmentMaterialfvSGIXWrapper(GLenum face_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETFRAGMENTMATERIALFVSGIXPROC, "glGetFragmentMaterialfvSGIX");
  RESOLVED_PROC(PFNGLGETFRAGMENTMATERIALFVSGIXPROC)( face_, pname_, params_ );
}

void glGetFragmentMaterialivSGIXWrapper(GLenum face_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETFRAGMENTMATERIALIVSGIXPROC, "glGetFragmentMaterialivSGIX");
  RESOLVED_PROC(PFNGLGETFRAGMENTMATERIALIVSGIXPROC)( face_, pname_, params_ );
}

void glLightEnviSGIXWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLLIGHTENVISGIXPROC, "glLightEnviSGIX");
  RESOLVED_PROC(PFNGLLIGHTENVISGIXPROC)( pname_, param_ );
}

void glFrameZoomSGIXWrapper(GLint factor_)
{
  RESOLVE(PFNGLFRAMEZOOMSGIXPROC, "glFrameZoomSGIX");
  RESOLVED_PROC(PFNGLFRAMEZOOMSGIXPROC)( factor_ );
}

void glIglooInterfaceSGIXWrapper(GLenum pname_, const void * params_)
{
  RESOLVE(PFNGLIGLOOINTERFACESGIXPROC, "glIglooInterfaceSGIX");
  RESOLVED_PROC(PFNGLIGLOOINTERFACESGIXPROC)( pname_, params_ );
}

GLint glGetInstrumentsSGIXWrapper(void)
{
  RESOLVE_RET(PFNGLGETINSTRUMENTSSGIXPROC, "glGetInstrumentsSGIX", FALSE);
  return RESOLVED_PROC(PFNGLGETINSTRUMENTSSGIXPROC)( );
}

void glInstrumentsBufferSGIXWrapper(GLsizei size_, GLint* buffer_)
{
  RESOLVE(PFNGLINSTRUMENTSBUFFERSGIXPROC, "glInstrumentsBufferSGIX");
  RESOLVED_PROC(PFNGLINSTRUMENTSBUFFERSGIXPROC)( size_, buffer_ );
}

GLint glPollInstrumentsSGIXWrapper(GLint* marker_p_)
{
  RESOLVE_RET(PFNGLPOLLINSTRUMENTSSGIXPROC, "glPollInstrumentsSGIX", FALSE);
  return RESOLVED_PROC(PFNGLPOLLINSTRUMENTSSGIXPROC)(marker_p_ );
}

void glReadInstrumentsSGIXWrapper(GLint marker_)
{
  RESOLVE(PFNGLREADINSTRUMENTSSGIXPROC, "glReadInstrumentsSGIX");
  RESOLVED_PROC(PFNGLREADINSTRUMENTSSGIXPROC)( marker_ );
}

void glStartInstrumentsSGIXWrapper(void)
{
  RESOLVE(PFNGLSTARTINSTRUMENTSSGIXPROC, "glStartInstrumentsSGIX");
  RESOLVED_PROC(PFNGLSTARTINSTRUMENTSSGIXPROC)(  );
}

void glStopInstrumentsSGIXWrapper(GLint marker_)
{
  RESOLVE(PFNGLSTOPINSTRUMENTSSGIXPROC, "glStopInstrumentsSGIX");
  RESOLVED_PROC(PFNGLSTOPINSTRUMENTSSGIXPROC)( marker_ );
}

void glGetListParameterfvSGIXWrapper(GLuint list_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETLISTPARAMETERFVSGIXPROC, "glGetListParameterfvSGIX");
  RESOLVED_PROC(PFNGLGETLISTPARAMETERFVSGIXPROC)( list_, pname_, params_ );
}

void glGetListParameterivSGIXWrapper(GLuint list_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETLISTPARAMETERIVSGIXPROC, "glGetListParameterivSGIX");
  RESOLVED_PROC(PFNGLGETLISTPARAMETERIVSGIXPROC)( list_, pname_, params_ );
}

void glListParameterfSGIXWrapper(GLuint list_, GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLLISTPARAMETERFSGIXPROC, "glListParameterfSGIX");
  RESOLVED_PROC(PFNGLLISTPARAMETERFSGIXPROC)( list_, pname_, param_ );
}

void glListParameterfvSGIXWrapper(GLuint list_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLLISTPARAMETERFVSGIXPROC, "glListParameterfvSGIX");
  RESOLVED_PROC(PFNGLLISTPARAMETERFVSGIXPROC)( list_, pname_, params_ );
}

void glListParameteriSGIXWrapper(GLuint list_, GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLLISTPARAMETERISGIXPROC, "glListParameteriSGIX");
  RESOLVED_PROC(PFNGLLISTPARAMETERISGIXPROC)( list_, pname_, param_ );
}

void glListParameterivSGIXWrapper(GLuint list_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLLISTPARAMETERIVSGIXPROC, "glListParameterivSGIX");
  RESOLVED_PROC(PFNGLLISTPARAMETERIVSGIXPROC)( list_, pname_, params_ );
}

void glPixelTexGenSGIXWrapper(GLenum mode_)
{
  RESOLVE(PFNGLPIXELTEXGENSGIXPROC, "glPixelTexGenSGIX");
  RESOLVED_PROC(PFNGLPIXELTEXGENSGIXPROC)( mode_ );
}

void glDeformationMap3dSGIXWrapper(GLenum target_, GLdouble u1_, GLdouble u2_, GLint ustride_, GLint uorder_, GLdouble v1_, GLdouble v2_, GLint vstride_, GLint vorder_, GLdouble w1_, GLdouble w2_, GLint wstride_, GLint worder_, const GLdouble* points_)
{
  RESOLVE(PFNGLDEFORMATIONMAP3DSGIXPROC, "glDeformationMap3dSGIX");
  RESOLVED_PROC(PFNGLDEFORMATIONMAP3DSGIXPROC)( target_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, w1_, w2_, wstride_, worder_, points_ );
}

void glDeformationMap3fSGIXWrapper(GLenum target_, GLfloat u1_, GLfloat u2_, GLint ustride_, GLint uorder_, GLfloat v1_, GLfloat v2_, GLint vstride_, GLint vorder_, GLfloat w1_, GLfloat w2_, GLint wstride_, GLint worder_, const GLfloat* points_)
{
  RESOLVE(PFNGLDEFORMATIONMAP3FSGIXPROC, "glDeformationMap3fSGIX");
  RESOLVED_PROC(PFNGLDEFORMATIONMAP3FSGIXPROC)( target_, u1_, u2_, ustride_, uorder_, v1_, v2_, vstride_, vorder_, w1_, w2_, wstride_, worder_, points_ );
}

void glDeformSGIXWrapper(GLbitfield mask_)
{
  RESOLVE(PFNGLDEFORMSGIXPROC, "glDeformSGIX");
  RESOLVED_PROC(PFNGLDEFORMSGIXPROC)( mask_ );
}

void glLoadIdentityDeformationMapSGIXWrapper(GLbitfield mask_)
{
  RESOLVE(PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC, "glLoadIdentityDeformationMapSGIX");
  RESOLVED_PROC(PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC)( mask_ );
}

void glReferencePlaneSGIXWrapper(const GLdouble* equation_)
{
  RESOLVE(PFNGLREFERENCEPLANESGIXPROC, "glReferencePlaneSGIX");
  RESOLVED_PROC(PFNGLREFERENCEPLANESGIXPROC)( equation_ );
}

void glSpriteParameterfSGIXWrapper(GLenum pname_, GLfloat param_)
{
  RESOLVE(PFNGLSPRITEPARAMETERFSGIXPROC, "glSpriteParameterfSGIX");
  RESOLVED_PROC(PFNGLSPRITEPARAMETERFSGIXPROC)( pname_, param_ );
}

void glSpriteParameterfvSGIXWrapper(GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLSPRITEPARAMETERFVSGIXPROC, "glSpriteParameterfvSGIX");
  RESOLVED_PROC(PFNGLSPRITEPARAMETERFVSGIXPROC)( pname_, params_ );
}

void glSpriteParameteriSGIXWrapper(GLenum pname_, GLint param_)
{
  RESOLVE(PFNGLSPRITEPARAMETERISGIXPROC, "glSpriteParameteriSGIX");
  RESOLVED_PROC(PFNGLSPRITEPARAMETERISGIXPROC)( pname_, param_ );
}

void glSpriteParameterivSGIXWrapper(GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLSPRITEPARAMETERIVSGIXPROC, "glSpriteParameterivSGIX");
  RESOLVED_PROC(PFNGLSPRITEPARAMETERIVSGIXPROC)( pname_, params_ );
}

void glTagSampleBufferSGIXWrapper(void)
{
  RESOLVE(PFNGLTAGSAMPLEBUFFERSGIXPROC, "glTagSampleBufferSGIX");
  RESOLVED_PROC(PFNGLTAGSAMPLEBUFFERSGIXPROC)(  );
}

void glColorTableSGIWrapper(GLenum target_, GLenum internalformat_, GLsizei width_, GLenum format_, GLenum type_, const void * table_)
{
  RESOLVE(PFNGLCOLORTABLESGIPROC, "glColorTableSGI");
  RESOLVED_PROC(PFNGLCOLORTABLESGIPROC)( target_, internalformat_, width_, format_, type_, table_ );
}

void glColorTableParameterfvSGIWrapper(GLenum target_, GLenum pname_, const GLfloat* params_)
{
  RESOLVE(PFNGLCOLORTABLEPARAMETERFVSGIPROC, "glColorTableParameterfvSGI");
  RESOLVED_PROC(PFNGLCOLORTABLEPARAMETERFVSGIPROC)( target_, pname_, params_ );
}

void glColorTableParameterivSGIWrapper(GLenum target_, GLenum pname_, const GLint* params_)
{
  RESOLVE(PFNGLCOLORTABLEPARAMETERIVSGIPROC, "glColorTableParameterivSGI");
  RESOLVED_PROC(PFNGLCOLORTABLEPARAMETERIVSGIPROC)( target_, pname_, params_ );
}

void glCopyColorTableSGIWrapper(GLenum target_, GLenum internalformat_, GLint x_, GLint y_, GLsizei width_)
{
  RESOLVE(PFNGLCOPYCOLORTABLESGIPROC, "glCopyColorTableSGI");
  RESOLVED_PROC(PFNGLCOPYCOLORTABLESGIPROC)( target_, internalformat_, x_, y_, width_ );
}

void glGetColorTableSGIWrapper(GLenum target_, GLenum format_, GLenum type_, void * table_)
{
  RESOLVE(PFNGLGETCOLORTABLESGIPROC, "glGetColorTableSGI");
  RESOLVED_PROC(PFNGLGETCOLORTABLESGIPROC)( target_, format_, type_, table_ );
}

void glGetColorTableParameterfvSGIWrapper(GLenum target_, GLenum pname_, GLfloat* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERFVSGIPROC, "glGetColorTableParameterfvSGI");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)( target_, pname_, params_ );
}

void glGetColorTableParameterivSGIWrapper(GLenum target_, GLenum pname_, GLint* params_)
{
  RESOLVE(PFNGLGETCOLORTABLEPARAMETERIVSGIPROC, "glGetColorTableParameterivSGI");
  RESOLVED_PROC(PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)( target_, pname_, params_ );
}

void glFinishTextureSUNXWrapper(void)
{
  RESOLVE(PFNGLFINISHTEXTURESUNXPROC, "glFinishTextureSUNX");
  RESOLVED_PROC(PFNGLFINISHTEXTURESUNXPROC)(  );
}

void glGlobalAlphaFactorbSUNWrapper(GLbyte factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORBSUNPROC, "glGlobalAlphaFactorbSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORBSUNPROC)( factor_ );
}

void glGlobalAlphaFactorsSUNWrapper(GLshort factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORSSUNPROC, "glGlobalAlphaFactorsSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORSSUNPROC)( factor_ );
}

void glGlobalAlphaFactoriSUNWrapper(GLint factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORISUNPROC, "glGlobalAlphaFactoriSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORISUNPROC)( factor_ );
}

void glGlobalAlphaFactorfSUNWrapper(GLfloat factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORFSUNPROC, "glGlobalAlphaFactorfSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORFSUNPROC)( factor_ );
}

void glGlobalAlphaFactordSUNWrapper(GLdouble factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORDSUNPROC, "glGlobalAlphaFactordSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORDSUNPROC)( factor_ );
}

void glGlobalAlphaFactorubSUNWrapper(GLubyte factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORUBSUNPROC, "glGlobalAlphaFactorubSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORUBSUNPROC)( factor_ );
}

void glGlobalAlphaFactorusSUNWrapper(GLushort factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORUSSUNPROC, "glGlobalAlphaFactorusSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORUSSUNPROC)( factor_ );
}

void glGlobalAlphaFactoruiSUNWrapper(GLuint factor_)
{
  RESOLVE(PFNGLGLOBALALPHAFACTORUISUNPROC, "glGlobalAlphaFactoruiSUN");
  RESOLVED_PROC(PFNGLGLOBALALPHAFACTORUISUNPROC)( factor_ );
}

void glDrawMeshArraysSUNWrapper(GLenum mode_, GLint first_, GLsizei count_, GLsizei width_)
{
  RESOLVE(PFNGLDRAWMESHARRAYSSUNPROC, "glDrawMeshArraysSUN");
  RESOLVED_PROC(PFNGLDRAWMESHARRAYSSUNPROC)( mode_, first_, count_, width_ );
}

void glReplacementCodeuiSUNWrapper(GLuint code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUISUNPROC, "glReplacementCodeuiSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUISUNPROC)( code_ );
}

void glReplacementCodeusSUNWrapper(GLushort code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUSSUNPROC, "glReplacementCodeusSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUSSUNPROC)( code_ );
}

void glReplacementCodeubSUNWrapper(GLubyte code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUBSUNPROC, "glReplacementCodeubSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUBSUNPROC)( code_ );
}

void glReplacementCodeuivSUNWrapper(const GLuint* code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUIVSUNPROC, "glReplacementCodeuivSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUIVSUNPROC)( code_ );
}

void glReplacementCodeusvSUNWrapper(const GLushort* code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUSVSUNPROC, "glReplacementCodeusvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUSVSUNPROC)( code_ );
}

void glReplacementCodeubvSUNWrapper(const GLubyte* code_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUBVSUNPROC, "glReplacementCodeubvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUBVSUNPROC)( code_ );
}

void glReplacementCodePointerSUNWrapper(GLenum type_, GLsizei stride_, const void ** pointer_)
{
  RESOLVE(PFNGLREPLACEMENTCODEPOINTERSUNPROC, "glReplacementCodePointerSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEPOINTERSUNPROC)( type_, stride_, pointer_ );
}

void glColor4ubVertex2fSUNWrapper(GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_, GLfloat x_, GLfloat y_)
{
  RESOLVE(PFNGLCOLOR4UBVERTEX2FSUNPROC, "glColor4ubVertex2fSUN");
  RESOLVED_PROC(PFNGLCOLOR4UBVERTEX2FSUNPROC)( r_, g_, b_, a_, x_, y_ );
}

void glColor4ubVertex2fvSUNWrapper(const GLubyte* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLCOLOR4UBVERTEX2FVSUNPROC, "glColor4ubVertex2fvSUN");
  RESOLVED_PROC(PFNGLCOLOR4UBVERTEX2FVSUNPROC)( c_, v_ );
}

void glColor4ubVertex3fSUNWrapper(GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLCOLOR4UBVERTEX3FSUNPROC, "glColor4ubVertex3fSUN");
  RESOLVED_PROC(PFNGLCOLOR4UBVERTEX3FSUNPROC)( r_, g_, b_, a_, x_, y_, z_ );
}

void glColor4ubVertex3fvSUNWrapper(const GLubyte* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLCOLOR4UBVERTEX3FVSUNPROC, "glColor4ubVertex3fvSUN");
  RESOLVED_PROC(PFNGLCOLOR4UBVERTEX3FVSUNPROC)( c_, v_ );
}

void glColor3fVertex3fSUNWrapper(GLfloat r_, GLfloat g_, GLfloat b_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLCOLOR3FVERTEX3FSUNPROC, "glColor3fVertex3fSUN");
  RESOLVED_PROC(PFNGLCOLOR3FVERTEX3FSUNPROC)( r_, g_, b_, x_, y_, z_ );
}

void glColor3fVertex3fvSUNWrapper(const GLfloat* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLCOLOR3FVERTEX3FVSUNPROC, "glColor3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLCOLOR3FVERTEX3FVSUNPROC)( c_, v_ );
}

void glNormal3fVertex3fSUNWrapper(GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLNORMAL3FVERTEX3FSUNPROC, "glNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLNORMAL3FVERTEX3FSUNPROC)( nx_, ny_, nz_, x_, y_, z_ );
}

void glNormal3fVertex3fvSUNWrapper(const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLNORMAL3FVERTEX3FVSUNPROC, "glNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLNORMAL3FVERTEX3FVSUNPROC)( n_, v_ );
}

void glColor4fNormal3fVertex3fSUNWrapper(GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC, "glColor4fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)( r_, g_, b_, a_, nx_, ny_, nz_, x_, y_, z_ );
}

void glColor4fNormal3fVertex3fvSUNWrapper(const GLfloat* c_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC, "glColor4fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)( c_, n_, v_ );
}

void glTexCoord2fVertex3fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLTEXCOORD2FVERTEX3FSUNPROC, "glTexCoord2fVertex3fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FVERTEX3FSUNPROC)( s_, t_, x_, y_, z_ );
}

void glTexCoord2fVertex3fvSUNWrapper(const GLfloat* tc_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD2FVERTEX3FVSUNPROC, "glTexCoord2fVertex3fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FVERTEX3FVSUNPROC)( tc_, v_ );
}

void glTexCoord4fVertex4fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat p_, GLfloat q_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLTEXCOORD4FVERTEX4FSUNPROC, "glTexCoord4fVertex4fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD4FVERTEX4FSUNPROC)( s_, t_, p_, q_, x_, y_, z_, w_ );
}

void glTexCoord4fVertex4fvSUNWrapper(const GLfloat* tc_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD4FVERTEX4FVSUNPROC, "glTexCoord4fVertex4fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD4FVERTEX4FVSUNPROC)( tc_, v_ );
}

void glTexCoord2fColor4ubVertex3fSUNWrapper(GLfloat s_, GLfloat t_, GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC, "glTexCoord2fColor4ubVertex3fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)( s_, t_, r_, g_, b_, a_, x_, y_, z_ );
}

void glTexCoord2fColor4ubVertex3fvSUNWrapper(const GLfloat* tc_, const GLubyte* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC, "glTexCoord2fColor4ubVertex3fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)( tc_, c_, v_ );
}

void glTexCoord2fColor3fVertex3fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC, "glTexCoord2fColor3fVertex3fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)( s_, t_, r_, g_, b_, x_, y_, z_ );
}

void glTexCoord2fColor3fVertex3fvSUNWrapper(const GLfloat* tc_, const GLfloat* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC, "glTexCoord2fColor3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)( tc_, c_, v_ );
}

void glTexCoord2fNormal3fVertex3fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC, "glTexCoord2fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)( s_, t_, nx_, ny_, nz_, x_, y_, z_ );
}

void glTexCoord2fNormal3fVertex3fvSUNWrapper(const GLfloat* tc_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC, "glTexCoord2fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)( tc_, n_, v_ );
}

void glTexCoord2fColor4fNormal3fVertex3fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC, "glTexCoord2fColor4fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)( s_, t_, r_, g_, b_, a_, nx_, ny_, nz_, x_, y_, z_ );
}

void glTexCoord2fColor4fNormal3fVertex3fvSUNWrapper(const GLfloat* tc_, const GLfloat* c_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC, "glTexCoord2fColor4fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)( tc_, c_, n_, v_ );
}

void glTexCoord4fColor4fNormal3fVertex4fSUNWrapper(GLfloat s_, GLfloat t_, GLfloat p_, GLfloat q_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_, GLfloat w_)
{
  RESOLVE(PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC, "glTexCoord4fColor4fNormal3fVertex4fSUN");
  RESOLVED_PROC(PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)( s_, t_, p_, q_, r_, g_, b_, a_, nx_, ny_, nz_, x_, y_, z_, w_ );
}

void glTexCoord4fColor4fNormal3fVertex4fvSUNWrapper(const GLfloat* tc_, const GLfloat* c_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC, "glTexCoord4fColor4fNormal3fVertex4fvSUN");
  RESOLVED_PROC(PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)( tc_, c_, n_, v_ );
}

void glReplacementCodeuiVertex3fSUNWrapper(GLuint rc_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC, "glReplacementCodeuiVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)( rc_, x_, y_, z_ );
}

void glReplacementCodeuiVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC, "glReplacementCodeuiVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)( rc_, v_ );
}

void glReplacementCodeuiColor4ubVertex3fSUNWrapper(GLuint rc_, GLubyte r_, GLubyte g_, GLubyte b_, GLubyte a_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC, "glReplacementCodeuiColor4ubVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)( rc_, r_, g_, b_, a_, x_, y_, z_ );
}

void glReplacementCodeuiColor4ubVertex3fvSUNWrapper(const GLuint* rc_, const GLubyte* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC, "glReplacementCodeuiColor4ubVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)( rc_, c_, v_ );
}

void glReplacementCodeuiColor3fVertex3fSUNWrapper(GLuint rc_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC, "glReplacementCodeuiColor3fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)( rc_, r_, g_, b_, x_, y_, z_ );
}

void glReplacementCodeuiColor3fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* c_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC, "glReplacementCodeuiColor3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)( rc_, c_, v_ );
}

void glReplacementCodeuiNormal3fVertex3fSUNWrapper(GLuint rc_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC, "glReplacementCodeuiNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)( rc_, nx_, ny_, nz_, x_, y_, z_ );
}

void glReplacementCodeuiNormal3fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC, "glReplacementCodeuiNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)( rc_, n_, v_ );
}

void glReplacementCodeuiColor4fNormal3fVertex3fSUNWrapper(GLuint rc_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC, "glReplacementCodeuiColor4fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)( rc_, r_, g_, b_, a_, nx_, ny_, nz_, x_, y_, z_ );
}

void glReplacementCodeuiColor4fNormal3fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* c_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC, "glReplacementCodeuiColor4fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)( rc_, c_, n_, v_ );
}

void glReplacementCodeuiTexCoord2fVertex3fSUNWrapper(GLuint rc_, GLfloat s_, GLfloat t_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC, "glReplacementCodeuiTexCoord2fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)( rc_, s_, t_, x_, y_, z_ );
}

void glReplacementCodeuiTexCoord2fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* tc_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC, "glReplacementCodeuiTexCoord2fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)( rc_, tc_, v_ );
}

void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUNWrapper(GLuint rc_, GLfloat s_, GLfloat t_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC, "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)( rc_, s_, t_, nx_, ny_, nz_, x_, y_, z_ );
}

void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* tc_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC, "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)( rc_, tc_, n_, v_ );
}

void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUNWrapper(GLuint rc_, GLfloat s_, GLfloat t_, GLfloat r_, GLfloat g_, GLfloat b_, GLfloat a_, GLfloat nx_, GLfloat ny_, GLfloat nz_, GLfloat x_, GLfloat y_, GLfloat z_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC, "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)( rc_, s_, t_, r_, g_, b_, a_, nx_, ny_, nz_, x_, y_, z_ );
}

void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUNWrapper(const GLuint* rc_, const GLfloat* tc_, const GLfloat* c_, const GLfloat* n_, const GLfloat* v_)
{
  RESOLVE(PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC, "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN");
  RESOLVED_PROC(PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)( rc_, tc_, c_, n_, v_ );
}

