	{"glClearIndex",
	"void glClearIndex( GLfloat c )",
	glClearIndex},
	{"glClearColor",
	"void glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )",
	glClearColor},
	{"glClear",
	"void glClear( GLbitfield mask )",
	glClear},
	{"glIndexMask",
	"void glIndexMask( GLuint mask )",
	glIndexMask},
	{"glColorMask",
	"void glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )",
	glColorMask},
	{"glAlphaFunc",
	"void glAlphaFunc( GLenum func, GLclampf ref )",
	glAlphaFunc},
	{"glBlendFunc",
	"void glBlendFunc( GLenum sfactor, GLenum dfactor )",
	glBlendFunc},
	{"glLogicOp",
	"void glLogicOp( GLenum opcode )",
	glLogicOp},
	{"glCullFace",
	"void glCullFace( GLenum mode )",
	glCullFace},
	{"glFrontFace",
	"void glFrontFace( GLenum mode )",
	glFrontFace},
	{"glPointSize",
	"void glPointSize( GLfloat size )",
	glPointSize},
	{"glLineWidth",
	"void glLineWidth( GLfloat width )",
	glLineWidth},
	{"glLineStipple",
	"void glLineStipple( GLint factor, GLushort pattern )",
	glLineStipple},
	{"glPolygonMode",
	"void glPolygonMode( GLenum face, GLenum mode )",
	glPolygonMode},
	{"glPolygonOffset",
	"void glPolygonOffset( GLfloat factor, GLfloat units )",
	glPolygonOffset},
	{"glPolygonStipple",
	"void glPolygonStipple( const GLubyte *mask )",
	glPolygonStipple},
	{"glGetPolygonStipple",
	"void glGetPolygonStipple( GLubyte *mask )",
	glGetPolygonStipple},
	{"glEdgeFlag",
	"void glEdgeFlag( GLboolean flag )",
	glEdgeFlag},
	{"glEdgeFlagv",
	"void glEdgeFlagv( const GLboolean *flag )",
	glEdgeFlagv},
	{"glScissor",
	"void glScissor( GLint x, GLint y, GLsizei width, GLsizei height)",
	glScissor},
	{"glClipPlane",
	"void glClipPlane( GLenum plane, const GLdouble *equation )",
	glClipPlane},
	{"glGetClipPlane",
	"void glGetClipPlane( GLenum plane, GLdouble *equation )",
	glGetClipPlane},
	{"glDrawBuffer",
	"void glDrawBuffer( GLenum mode )",
	glDrawBuffer},
	{"glReadBuffer",
	"void glReadBuffer( GLenum mode )",
	glReadBuffer},
	{"glEnable",
	"void glEnable( GLenum cap )",
	glEnable},
	{"glDisable",
	"void glDisable( GLenum cap )",
	glDisable},
	{"glIsEnabled",
	"GLboolean glIsEnabled( GLenum cap )",
	glIsEnabled},
	{"glEnableClientState",
	"void glEnableClientState( GLenum cap )",
	glEnableClientState},
	{"glDisableClientState",
	"void glDisableClientState( GLenum cap )",
	glDisableClientState},
	{"glGetBooleanv",
	"void glGetBooleanv( GLenum pname, GLboolean *params )",
	glGetBooleanv},
	{"glGetDoublev",
	"void glGetDoublev( GLenum pname, GLdouble *params )",
	glGetDoublev},
	{"glGetFloatv",
	"void glGetFloatv( GLenum pname, GLfloat *params )",
	glGetFloatv},
	{"glGetIntegerv",
	"void glGetIntegerv( GLenum pname, GLint *params )",
	glGetIntegerv},
	{"glPushAttrib",
	"void glPushAttrib( GLbitfield mask )",
	glPushAttrib},
	{"glPopAttrib",
	"void glPopAttrib( void )",
	glPopAttrib},
	{"glPushClientAttrib",
	"void glPushClientAttrib( GLbitfield mask )",
	glPushClientAttrib},
	{"glPopClientAttrib",
	"void glPopClientAttrib( void )",
	glPopClientAttrib},
	{"glRenderMode",
	"GLint glRenderMode( GLenum mode )",
	glRenderMode},
	{"glGetError",
	"GLenum glGetError( void )",
	glGetError},
	{"glGetString",
	"const GLubyte* glGetString( GLenum name )",
	glGetString},
	{"glFinish",
	"void glFinish( void )",
	glFinish},
	{"glFlush",
	"void glFlush( void )",
	glFlush},
	{"glHint",
	"void glHint( GLenum target, GLenum mode )",
	glHint},
	{"glClearDepth",
	"void glClearDepth( GLclampd depth )",
	glClearDepth},
	{"glDepthFunc",
	"void glDepthFunc( GLenum func )",
	glDepthFunc},
	{"glDepthMask",
	"void glDepthMask( GLboolean flag )",
	glDepthMask},
	{"glDepthRange",
	"void glDepthRange( GLclampd near_val, GLclampd far_val )",
	glDepthRange},
	{"glClearAccum",
	"void glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )",
	glClearAccum},
	{"glAccum",
	"void glAccum( GLenum op, GLfloat value )",
	glAccum},
	{"glMatrixMode",
	"void glMatrixMode( GLenum mode )",
	glMatrixMode},
	{"glOrtho6d",
	"void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )",
	glOrtho},
	{"glFrustum",
	"void glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val )",
	glFrustum},
	{"glViewport",
	"void glViewport( GLint x, GLint y, GLsizei width, GLsizei height )",
	glViewport},
	{"glPushMatrix",
	"void glPushMatrix( void )",
	glPushMatrix},
	{"glPopMatrix",
	"void glPopMatrix( void )",
	glPopMatrix},
	{"glLoadIdentity",
	"void glLoadIdentity( void )",
	glLoadIdentity},
	{"glLoadMatrixd",
	"void glLoadMatrixd( const GLdouble *m )",
	glLoadMatrixd},
	{"glLoadMatrixf",
	"void glLoadMatrixf( const GLfloat *m )",
	glLoadMatrixf},
	{"glMultMatrixd",
	"void glMultMatrixd( const GLdouble *m )",
	glMultMatrixd},
	{"glMultMatrixf",
	"void glMultMatrixf( const GLfloat *m )",
	glMultMatrixf},
	{"glRotated",
	"void glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )",
	glRotated},
	{"glRotatef",
	"void glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )",
	glRotatef},
	{"glScaled",
	"void glScaled( GLdouble x, GLdouble y, GLdouble z )",
	glScaled},
	{"glScalef",
	"void glScalef( GLfloat x, GLfloat y, GLfloat z )",
	glScalef},
	{"glTranslated",
	"void glTranslated( GLdouble x, GLdouble y, GLdouble z )",
	glTranslated},
	{"glTranslatef",
	"void glTranslatef( GLfloat x, GLfloat y, GLfloat z )",
	glTranslatef},
	{"glIsList",
	"GLboolean glIsList( GLuint list )",
	glIsList},
	{"glDeleteLists",
	"void glDeleteLists( GLuint list, GLsizei range )",
	glDeleteLists},
	{"glGenLists",
	"GLuint glGenLists( GLsizei range )",
	glGenLists},
	{"glNewList",
	"void glNewList( GLuint list, GLenum mode )",
	glNewList},
	{"glEndList",
	"void glEndList( void )",
	glEndList},
	{"glCallList",
	"void glCallList( GLuint list )",
	glCallList},
	{"glCallLists",
	"void glCallLists( GLsizei n, GLenum type,                                      const GLvoid *lists )",
	glCallLists},
	{"glListBase",
	"void glListBase( GLuint base )",
	glListBase},
	{"glBegin",
	"void glBegin( GLenum mode )",
	glBegin},
	{"glEnd",
	"void glEnd( void )",
	glEnd},
	{"glVertex2d",
	"void glVertex2d( GLdouble x, GLdouble y )",
	glVertex2d},
	{"glVertex2f",
	"void glVertex2f( GLfloat x, GLfloat y )",
	glVertex2f},
	{"glVertex2i",
	"void glVertex2i( GLint x, GLint y )",
	glVertex2i},
	{"glVertex2s",
	"void glVertex2s( GLshort x, GLshort y )",
	glVertex2s},
	{"glVertex3d",
	"void glVertex3d( GLdouble x, GLdouble y, GLdouble z )",
	glVertex3d},
	{"glVertex3f",
	"void glVertex3f( GLfloat x, GLfloat y, GLfloat z )",
	glVertex3f},
	{"glVertex3i",
	"void glVertex3i( GLint x, GLint y, GLint z )",
	glVertex3i},
	{"glVertex3s",
	"void glVertex3s( GLshort x, GLshort y, GLshort z )",
	glVertex3s},
	{"glVertex4d",
	"void glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )",
	glVertex4d},
	{"glVertex4f",
	"void glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )",
	glVertex4f},
	{"glVertex4i",
	"void glVertex4i( GLint x, GLint y, GLint z, GLint w )",
	glVertex4i},
	{"glVertex4s",
	"void glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )",
	glVertex4s},
	{"glVertex2dv",
	"void glVertex2dv( const GLdouble *v )",
	glVertex2dv},
	{"glVertex2fv",
	"void glVertex2fv( const GLfloat *v )",
	glVertex2fv},
	{"glVertex2iv",
	"void glVertex2iv( const GLint *v )",
	glVertex2iv},
	{"glVertex2sv",
	"void glVertex2sv( const GLshort *v )",
	glVertex2sv},
	{"glVertex3dv",
	"void glVertex3dv( const GLdouble *v )",
	glVertex3dv},
	{"glVertex3fv",
	"void glVertex3fv( const GLfloat *v )",
	glVertex3fv},
	{"glVertex3iv",
	"void glVertex3iv( const GLint *v )",
	glVertex3iv},
	{"glVertex3sv",
	"void glVertex3sv( const GLshort *v )",
	glVertex3sv},
	{"glVertex4dv",
	"void glVertex4dv( const GLdouble *v )",
	glVertex4dv},
	{"glVertex4fv",
	"void glVertex4fv( const GLfloat *v )",
	glVertex4fv},
	{"glVertex4iv",
	"void glVertex4iv( const GLint *v )",
	glVertex4iv},
	{"glVertex4sv",
	"void glVertex4sv( const GLshort *v )",
	glVertex4sv},
	{"glNormal3b",
	"void glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )",
	glNormal3b},
	{"glNormal3d",
	"void glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )",
	glNormal3d},
	{"glNormal3f",
	"void glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )",
	glNormal3f},
	{"glNormal3i",
	"void glNormal3i( GLint nx, GLint ny, GLint nz )",
	glNormal3i},
	{"glNormal3s",
	"void glNormal3s( GLshort nx, GLshort ny, GLshort nz )",
	glNormal3s},
	{"glNormal3bv",
	"void glNormal3bv( const GLbyte *v )",
	glNormal3bv},
	{"glNormal3dv",
	"void glNormal3dv( const GLdouble *v )",
	glNormal3dv},
	{"glNormal3fv",
	"void glNormal3fv( const GLfloat *v )",
	glNormal3fv},
	{"glNormal3iv",
	"void glNormal3iv( const GLint *v )",
	glNormal3iv},
	{"glNormal3sv",
	"void glNormal3sv( const GLshort *v )",
	glNormal3sv},
	{"glIndexd",
	"void glIndexd( GLdouble c )",
	glIndexd},
	{"glIndexf",
	"void glIndexf( GLfloat c )",
	glIndexf},
	{"glIndexi",
	"void glIndexi( GLint c )",
	glIndexi},
	{"glIndexs",
	"void glIndexs( GLshort c )",
	glIndexs},
	{"glIndexub",
	"void glIndexub( GLubyte c )",
	glIndexub},
	{"glIndexdv",
	"void glIndexdv( const GLdouble *c )",
	glIndexdv},
	{"glIndexfv",
	"void glIndexfv( const GLfloat *c )",
	glIndexfv},
	{"glIndexiv",
	"void glIndexiv( const GLint *c )",
	glIndexiv},
	{"glIndexsv",
	"void glIndexsv( const GLshort *c )",
	glIndexsv},
	{"glIndexubv",
	"void glIndexubv( const GLubyte *c )",
	glIndexubv},
	{"glColor3b",
	"void glColor3b( GLbyte red, GLbyte green, GLbyte blue )",
	glColor3b},
	{"glColor3d",
	"void glColor3d( GLdouble red, GLdouble green, GLdouble blue )",
	glColor3d},
	{"glColor3f",
	"void glColor3f( GLfloat red, GLfloat green, GLfloat blue )",
	glColor3f},
	{"glColor3i",
	"void glColor3i( GLint red, GLint green, GLint blue )",
	glColor3i},
	{"glColor3s",
	"void glColor3s( GLshort red, GLshort green, GLshort blue )",
	glColor3s},
	{"glColor3ub",
	"void glColor3ub( GLubyte red, GLubyte green, GLubyte blue )",
	glColor3ub},
	{"glColor3ui",
	"void glColor3ui( GLuint red, GLuint green, GLuint blue )",
	glColor3ui},
	{"glColor3us",
	"void glColor3us( GLushort red, GLushort green, GLushort blue )",
	glColor3us},
	{"glColor4b",
	"void glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )",
	glColor4b},
	{"glColor4d",
	"void glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )",
	glColor4d},
	{"glColor4f",
	"void glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )",
	glColor4f},
	{"glColor4i",
	"void glColor4i( GLint red, GLint green, GLint blue, GLint alpha )",
	glColor4i},
	{"glColor4s",
	"void glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )",
	glColor4s},
	{"glColor4ub",
	"void glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )",
	glColor4ub},
	{"glColor4ui",
	"void glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )",
	glColor4ui},
	{"glColor4us",
	"void glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )",
	glColor4us},
	{"glColor3bv",
	"void glColor3bv( const GLbyte *v )",
	glColor3bv},
	{"glColor3dv",
	"void glColor3dv( const GLdouble *v )",
	glColor3dv},
	{"glColor3fv",
	"void glColor3fv( const GLfloat *v )",
	glColor3fv},
	{"glColor3iv",
	"void glColor3iv( const GLint *v )",
	glColor3iv},
	{"glColor3sv",
	"void glColor3sv( const GLshort *v )",
	glColor3sv},
	{"glColor3ubv",
	"void glColor3ubv( const GLubyte *v )",
	glColor3ubv},
	{"glColor3uiv",
	"void glColor3uiv( const GLuint *v )",
	glColor3uiv},
	{"glColor3usv",
	"void glColor3usv( const GLushort *v )",
	glColor3usv},
	{"glColor4bv",
	"void glColor4bv( const GLbyte *v )",
	glColor4bv},
	{"glColor4dv",
	"void glColor4dv( const GLdouble *v )",
	glColor4dv},
	{"glColor4fv",
	"void glColor4fv( const GLfloat *v )",
	glColor4fv},
	{"glColor4iv",
	"void glColor4iv( const GLint *v )",
	glColor4iv},
	{"glColor4sv",
	"void glColor4sv( const GLshort *v )",
	glColor4sv},
	{"glColor4ubv",
	"void glColor4ubv( const GLubyte *v )",
	glColor4ubv},
	{"glColor4uiv",
	"void glColor4uiv( const GLuint *v )",
	glColor4uiv},
	{"glColor4usv",
	"void glColor4usv( const GLushort *v )",
	glColor4usv},
	{"glTexCoord1d",
	"void glTexCoord1d( GLdouble s )",
	glTexCoord1d},
	{"glTexCoord1f",
	"void glTexCoord1f( GLfloat s )",
	glTexCoord1f},
	{"glTexCoord1i",
	"void glTexCoord1i( GLint s )",
	glTexCoord1i},
	{"glTexCoord1s",
	"void glTexCoord1s( GLshort s )",
	glTexCoord1s},
	{"glTexCoord2d",
	"void glTexCoord2d( GLdouble s, GLdouble t )",
	glTexCoord2d},
	{"glTexCoord2f",
	"void glTexCoord2f( GLfloat s, GLfloat t )",
	glTexCoord2f},
	{"glTexCoord2i",
	"void glTexCoord2i( GLint s, GLint t )",
	glTexCoord2i},
	{"glTexCoord2s",
	"void glTexCoord2s( GLshort s, GLshort t )",
	glTexCoord2s},
	{"glTexCoord3d",
	"void glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )",
	glTexCoord3d},
	{"glTexCoord3f",
	"void glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )",
	glTexCoord3f},
	{"glTexCoord3i",
	"void glTexCoord3i( GLint s, GLint t, GLint r )",
	glTexCoord3i},
	{"glTexCoord3s",
	"void glTexCoord3s( GLshort s, GLshort t, GLshort r )",
	glTexCoord3s},
	{"glTexCoord4d",
	"void glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )",
	glTexCoord4d},
	{"glTexCoord4f",
	"void glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )",
	glTexCoord4f},
	{"glTexCoord4i",
	"void glTexCoord4i( GLint s, GLint t, GLint r, GLint q )",
	glTexCoord4i},
	{"glTexCoord4s",
	"void glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )",
	glTexCoord4s},
	{"glTexCoord1dv",
	"void glTexCoord1dv( const GLdouble *v )",
	glTexCoord1dv},
	{"glTexCoord1fv",
	"void glTexCoord1fv( const GLfloat *v )",
	glTexCoord1fv},
	{"glTexCoord1iv",
	"void glTexCoord1iv( const GLint *v )",
	glTexCoord1iv},
	{"glTexCoord1sv",
	"void glTexCoord1sv( const GLshort *v )",
	glTexCoord1sv},
	{"glTexCoord2dv",
	"void glTexCoord2dv( const GLdouble *v )",
	glTexCoord2dv},
	{"glTexCoord2fv",
	"void glTexCoord2fv( const GLfloat *v )",
	glTexCoord2fv},
	{"glTexCoord2iv",
	"void glTexCoord2iv( const GLint *v )",
	glTexCoord2iv},
	{"glTexCoord2sv",
	"void glTexCoord2sv( const GLshort *v )",
	glTexCoord2sv},
	{"glTexCoord3dv",
	"void glTexCoord3dv( const GLdouble *v )",
	glTexCoord3dv},
	{"glTexCoord3fv",
	"void glTexCoord3fv( const GLfloat *v )",
	glTexCoord3fv},
	{"glTexCoord3iv",
	"void glTexCoord3iv( const GLint *v )",
	glTexCoord3iv},
	{"glTexCoord3sv",
	"void glTexCoord3sv( const GLshort *v )",
	glTexCoord3sv},
	{"glTexCoord4dv",
	"void glTexCoord4dv( const GLdouble *v )",
	glTexCoord4dv},
	{"glTexCoord4fv",
	"void glTexCoord4fv( const GLfloat *v )",
	glTexCoord4fv},
	{"glTexCoord4iv",
	"void glTexCoord4iv( const GLint *v )",
	glTexCoord4iv},
	{"glTexCoord4sv",
	"void glTexCoord4sv( const GLshort *v )",
	glTexCoord4sv},
	{"glRasterPos2d",
	"void glRasterPos2d( GLdouble x, GLdouble y )",
	glRasterPos2d},
	{"glRasterPos2f",
	"void glRasterPos2f( GLfloat x, GLfloat y )",
	glRasterPos2f},
	{"glRasterPos2i",
	"void glRasterPos2i( GLint x, GLint y )",
	glRasterPos2i},
	{"glRasterPos2s",
	"void glRasterPos2s( GLshort x, GLshort y )",
	glRasterPos2s},
	{"glRasterPos3d",
	"void glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )",
	glRasterPos3d},
	{"glRasterPos3f",
	"void glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )",
	glRasterPos3f},
	{"glRasterPos3i",
	"void glRasterPos3i( GLint x, GLint y, GLint z )",
	glRasterPos3i},
	{"glRasterPos3s",
	"void glRasterPos3s( GLshort x, GLshort y, GLshort z )",
	glRasterPos3s},
	{"glRasterPos4d",
	"void glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )",
	glRasterPos4d},
	{"glRasterPos4f",
	"void glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )",
	glRasterPos4f},
	{"glRasterPos4i",
	"void glRasterPos4i( GLint x, GLint y, GLint z, GLint w )",
	glRasterPos4i},
	{"glRasterPos4s",
	"void glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )",
	glRasterPos4s},
	{"glRasterPos2dv",
	"void glRasterPos2dv( const GLdouble *v )",
	glRasterPos2dv},
	{"glRasterPos2fv",
	"void glRasterPos2fv( const GLfloat *v )",
	glRasterPos2fv},
	{"glRasterPos2iv",
	"void glRasterPos2iv( const GLint *v )",
	glRasterPos2iv},
	{"glRasterPos2sv",
	"void glRasterPos2sv( const GLshort *v )",
	glRasterPos2sv},
	{"glRasterPos3dv",
	"void glRasterPos3dv( const GLdouble *v )",
	glRasterPos3dv},
	{"glRasterPos3fv",
	"void glRasterPos3fv( const GLfloat *v )",
	glRasterPos3fv},
	{"glRasterPos3iv",
	"void glRasterPos3iv( const GLint *v )",
	glRasterPos3iv},
	{"glRasterPos3sv",
	"void glRasterPos3sv( const GLshort *v )",
	glRasterPos3sv},
	{"glRasterPos4dv",
	"void glRasterPos4dv( const GLdouble *v )",
	glRasterPos4dv},
	{"glRasterPos4fv",
	"void glRasterPos4fv( const GLfloat *v )",
	glRasterPos4fv},
	{"glRasterPos4iv",
	"void glRasterPos4iv( const GLint *v )",
	glRasterPos4iv},
	{"glRasterPos4sv",
	"void glRasterPos4sv( const GLshort *v )",
	glRasterPos4sv},
	{"glRectd",
	"void glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )",
	glRectd},
	{"glRectf",
	"void glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )",
	glRectf},
	{"glRecti",
	"void glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )",
	glRecti},
	{"glRects",
	"void glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )",
	glRects},
	{"glRectdv",
	"void glRectdv( const GLdouble *v1, const GLdouble *v2 )",
	glRectdv},
	{"glRectfv",
	"void glRectfv( const GLfloat *v1, const GLfloat *v2 )",
	glRectfv},
	{"glRectiv",
	"void glRectiv( const GLint *v1, const GLint *v2 )",
	glRectiv},
	{"glRectsv",
	"void glRectsv( const GLshort *v1, const GLshort *v2 )",
	glRectsv},
	{"glVertexPointer",
	"void glVertexPointer( GLint size, GLenum type,                                        GLsizei stride, const GLvoid *ptr )",
	glVertexPointer},
	{"glNormalPointer",
	"void glNormalPointer( GLenum type, GLsizei stride,                                        const GLvoid *ptr )",
	glNormalPointer},
	{"glColorPointer",
	"void glColorPointer( GLint size, GLenum type,                                       GLsizei stride, const GLvoid *ptr )",
	glColorPointer},
	{"glIndexPointer",
	"void glIndexPointer( GLenum type, GLsizei stride,                                       const GLvoid *ptr )",
	glIndexPointer},
	{"glTexCoordPointer",
	"void glTexCoordPointer( GLint size, GLenum type,                                          GLsizei stride, const GLvoid *ptr )",
	glTexCoordPointer},
	{"glEdgeFlagPointer",
	"void glEdgeFlagPointer( GLsizei stride, const GLvoid *ptr )",
	glEdgeFlagPointer},
	{"glGetPointerv",
	"void glGetPointerv( GLenum pname, GLvoid **params )",
	glGetPointerv},
	{"glArrayElement",
	"void glArrayElement( GLint i )",
	glArrayElement},
	{"glDrawArrays",
	"void glDrawArrays( GLenum mode, GLint first, GLsizei count )",
	glDrawArrays},
	{"glDrawElements",
	"void glDrawElements( GLenum mode, GLsizei count,                                       GLenum type, const GLvoid *indices )",
	glDrawElements},
	{"glInterleavedArrays",
	"void glInterleavedArrays( GLenum format, GLsizei stride,                                            const GLvoid *pointer )",
	glInterleavedArrays},
	{"glShadeModel",
	"void glShadeModel( GLenum mode )",
	glShadeModel},
	{"glLightf",
	"void glLightf( GLenum light, GLenum pname, GLfloat param )",
	glLightf},
	{"glLighti",
	"void glLighti( GLenum light, GLenum pname, GLint param )",
	glLighti},
	{"glLightfv",
	"void glLightfv( GLenum light, GLenum pname,                                  const GLfloat *params )",
	glLightfv},
	{"glLightiv",
	"void glLightiv( GLenum light, GLenum pname,                                  const GLint *params )",
	glLightiv},
	{"glGetLightfv",
	"void glGetLightfv( GLenum light, GLenum pname,                                     GLfloat *params )",
	glGetLightfv},
	{"glGetLightiv",
	"void glGetLightiv( GLenum light, GLenum pname,                                     GLint *params )",
	glGetLightiv},
	{"glLightModelf",
	"void glLightModelf( GLenum pname, GLfloat param )",
	glLightModelf},
	{"glLightModeli",
	"void glLightModeli( GLenum pname, GLint param )",
	glLightModeli},
	{"glLightModelfv",
	"void glLightModelfv( GLenum pname, const GLfloat *params )",
	glLightModelfv},
	{"glLightModeliv",
	"void glLightModeliv( GLenum pname, const GLint *params )",
	glLightModeliv},
	{"glMaterialf",
	"void glMaterialf( GLenum face, GLenum pname, GLfloat param )",
	glMaterialf},
	{"glMateriali",
	"void glMateriali( GLenum face, GLenum pname, GLint param )",
	glMateriali},
	{"glMaterialfv",
	"void glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )",
	glMaterialfv},
	{"glMaterialiv",
	"void glMaterialiv( GLenum face, GLenum pname, const GLint *params )",
	glMaterialiv},
	{"glGetMaterialfv",
	"void glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )",
	glGetMaterialfv},
	{"glGetMaterialiv",
	"void glGetMaterialiv( GLenum face, GLenum pname, GLint *params )",
	glGetMaterialiv},
	{"glColorMaterial",
	"void glColorMaterial( GLenum face, GLenum mode )",
	glColorMaterial},
	{"glPixelZoom",
	"void glPixelZoom( GLfloat xfactor, GLfloat yfactor )",
	glPixelZoom},
	{"glPixelStoref",
	"void glPixelStoref( GLenum pname, GLfloat param )",
	glPixelStoref},
	{"glPixelStorei",
	"void glPixelStorei( GLenum pname, GLint param )",
	glPixelStorei},
	{"glPixelTransferf",
	"void glPixelTransferf( GLenum pname, GLfloat param )",
	glPixelTransferf},
	{"glPixelTransferi",
	"void glPixelTransferi( GLenum pname, GLint param )",
	glPixelTransferi},
	{"glPixelMapfv",
	"void glPixelMapfv( GLenum map, GLsizei mapsize,                                     const GLfloat *values )",
	glPixelMapfv},
	{"glPixelMapuiv",
	"void glPixelMapuiv( GLenum map, GLsizei mapsize,                                      const GLuint *values )",
	glPixelMapuiv},
	{"glPixelMapusv",
	"void glPixelMapusv( GLenum map, GLsizei mapsize,                                      const GLushort *values )",
	glPixelMapusv},
	{"glGetPixelMapfv",
	"void glGetPixelMapfv( GLenum map, GLfloat *values )",
	glGetPixelMapfv},
	{"glGetPixelMapuiv",
	"void glGetPixelMapuiv( GLenum map, GLuint *values )",
	glGetPixelMapuiv},
	{"glGetPixelMapusv",
	"void glGetPixelMapusv( GLenum map, GLushort *values )",
	glGetPixelMapusv},
	{"glBitmap",
	"void glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )",
	glBitmap},
	{"glReadPixels",
	"void glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels )",
	glReadPixels},
	{"glDrawPixels",
	"void glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )",
	glDrawPixels},
	{"glCopyPixels",
	"void glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )",
	glCopyPixels},
	{"glStencilFunc",
	"void glStencilFunc( GLenum func, GLint ref, GLuint mask )",
	glStencilFunc},
	{"glStencilMask",
	"void glStencilMask( GLuint mask )",
	glStencilMask},
	{"glStencilOp",
	"void glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )",
	glStencilOp},
	{"glClearStencil",
	"void glClearStencil( GLint s )",
	glClearStencil},
	{"glTexGend",
	"void glTexGend( GLenum coord, GLenum pname, GLdouble param )",
	glTexGend},
	{"glTexGenf",
	"void glTexGenf( GLenum coord, GLenum pname, GLfloat param )",
	glTexGenf},
	{"glTexGeni",
	"void glTexGeni( GLenum coord, GLenum pname, GLint param )",
	glTexGeni},
	{"glTexGendv",
	"void glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )",
	glTexGendv},
	{"glTexGenfv",
	"void glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )",
	glTexGenfv},
	{"glTexGeniv",
	"void glTexGeniv( GLenum coord, GLenum pname, const GLint *params )",
	glTexGeniv},
	{"glGetTexGendv",
	"void glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )",
	glGetTexGendv},
	{"glGetTexGenfv",
	"void glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )",
	glGetTexGenfv},
	{"glGetTexGeniv",
	"void glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )",
	glGetTexGeniv},
	{"glTexEnvf",
	"void glTexEnvf( GLenum target, GLenum pname, GLfloat param )",
	glTexEnvf},
	{"glTexEnvi",
	"void glTexEnvi( GLenum target, GLenum pname, GLint param )",
	glTexEnvi},
	{"glTexEnvfv",
	"void glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )",
	glTexEnvfv},
	{"glTexEnviv",
	"void glTexEnviv( GLenum target, GLenum pname, const GLint *params )",
	glTexEnviv},
	{"glGetTexEnvfv",
	"void glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )",
	glGetTexEnvfv},
	{"glGetTexEnviv",
	"void glGetTexEnviv( GLenum target, GLenum pname, GLint *params )",
	glGetTexEnviv},
	{"glTexParameterf",
	"void glTexParameterf( GLenum target, GLenum pname, GLfloat param )",
	glTexParameterf},
	{"glTexParameteri",
	"void glTexParameteri( GLenum target, GLenum pname, GLint param )",
	glTexParameteri},
	{"glTexParameterfv",
	"void glTexParameterfv( GLenum target, GLenum pname,                                           const GLfloat *params )",
	glTexParameterfv},
	{"glTexParameteriv",
	"void glTexParameteriv( GLenum target, GLenum pname,                                           const GLint *params )",
	glTexParameteriv},
	{"glGetTexParameterfv",
	"void glGetTexParameterfv( GLenum target,                                            GLenum pname, GLfloat *params)",
	glGetTexParameterfv},
	{"glGetTexParameteriv",
	"void glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )",
	glGetTexParameteriv},
	{"glGetTexLevelParameterfv",
	"void glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )",
	glGetTexLevelParameterfv},
	{"glGetTexLevelParameteriv",
	"void glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )",
	glGetTexLevelParameteriv},
	{"glTexImage1D",
	"void glTexImage1D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type,                                     const GLvoid *pixels )",
	glTexImage1D},
	{"glTexImage2D",
	"void glTexImage2D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,                                     const GLvoid *pixels )",
	glTexImage2D},
	{"glGetTexImage",
	"void glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels )",
	glGetTexImage},
	{"glGenTextures",
	"void glGenTextures( GLsizei n, GLuint *textures )",
	glGenTextures},
	{"glDeleteTextures",
	"void glDeleteTextures( GLsizei n, const GLuint *textures)",
	glDeleteTextures},
	{"glBindTexture",
	"void glBindTexture( GLenum target, GLuint texture )",
	glBindTexture},
	{"glPrioritizeTextures",
	"void glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLclampf *priorities )",
	glPrioritizeTextures},
	{"glAreTexturesResident",
	"GLboolean glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )",
	glAreTexturesResident},
	{"glIsTexture",
	"GLboolean glIsTexture( GLuint texture )",
	glIsTexture},
	{"glTexSubImage1D",
	"void glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels )",
	glTexSubImage1D},
	{"glTexSubImage2D",
	"void glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels )",
	glTexSubImage2D},
	{"glCopyTexImage1D",
	"void glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )",
	glCopyTexImage1D},
	{"glCopyTexImage2D",
	"void glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )",
	glCopyTexImage2D},
	{"glCopyTexSubImage1D",
	"void glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )",
	glCopyTexSubImage1D},
	{"glCopyTexSubImage2D",
	"void glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )",
	glCopyTexSubImage2D},
	{"glMap1d",
	"void glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )",
	glMap1d},
	{"glMap1f",
	"void glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )",
	glMap1f},
	{"glMap2d",
	"void glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )",
	glMap2d},
	{"glMap2f",
	"void glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )",
	glMap2f},
	{"glGetMapdv",
	"void glGetMapdv( GLenum target, GLenum query, GLdouble *v )",
	glGetMapdv},
	{"glGetMapfv",
	"void glGetMapfv( GLenum target, GLenum query, GLfloat *v )",
	glGetMapfv},
	{"glGetMapiv",
	"void glGetMapiv( GLenum target, GLenum query, GLint *v )",
	glGetMapiv},
	{"glEvalCoord1d",
	"void glEvalCoord1d( GLdouble u )",
	glEvalCoord1d},
	{"glEvalCoord1f",
	"void glEvalCoord1f( GLfloat u )",
	glEvalCoord1f},
	{"glEvalCoord1dv",
	"void glEvalCoord1dv( const GLdouble *u )",
	glEvalCoord1dv},
	{"glEvalCoord1fv",
	"void glEvalCoord1fv( const GLfloat *u )",
	glEvalCoord1fv},
	{"glEvalCoord2d",
	"void glEvalCoord2d( GLdouble u, GLdouble v )",
	glEvalCoord2d},
	{"glEvalCoord2f",
	"void glEvalCoord2f( GLfloat u, GLfloat v )",
	glEvalCoord2f},
	{"glEvalCoord2dv",
	"void glEvalCoord2dv( const GLdouble *u )",
	glEvalCoord2dv},
	{"glEvalCoord2fv",
	"void glEvalCoord2fv( const GLfloat *u )",
	glEvalCoord2fv},
	{"glMapGrid1d",
	"void glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )",
	glMapGrid1d},
	{"glMapGrid1f",
	"void glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )",
	glMapGrid1f},
	{"glMapGrid2d",
	"void glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,                                    GLint vn, GLdouble v1, GLdouble v2 )",
	glMapGrid2d},
	{"glMapGrid2f",
	"void glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,                                    GLint vn, GLfloat v1, GLfloat v2 )",
	glMapGrid2f},
	{"glEvalPoint1",
	"void glEvalPoint1( GLint i )",
	glEvalPoint1},
	{"glEvalPoint2",
	"void glEvalPoint2( GLint i, GLint j )",
	glEvalPoint2},
	{"glEvalMesh1",
	"void glEvalMesh1( GLenum mode, GLint i1, GLint i2 )",
	glEvalMesh1},
	{"glEvalMesh2",
	"void glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )",
	glEvalMesh2},
	{"glFogf",
	"void glFogf( GLenum pname, GLfloat param )",
	glFogf},
	{"glFogi",
	"void glFogi( GLenum pname, GLint param )",
	glFogi},
	{"glFogfv",
	"void glFogfv( GLenum pname, const GLfloat *params )",
	glFogfv},
	{"glFogiv",
	"void glFogiv( GLenum pname, const GLint *params )",
	glFogiv},
	{"glFeedbackBuffer",
	"void glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )",
	glFeedbackBuffer},
	{"glPassThrough",
	"void glPassThrough( GLfloat token )",
	glPassThrough},
	{"glSelectBuffer",
	"void glSelectBuffer( GLsizei size, GLuint *buffer )",
	glSelectBuffer},
	{"glInitNames",
	"void glInitNames( void )",
	glInitNames},
	{"glLoadName",
	"void glLoadName( GLuint name )",
	glLoadName},
	{"glPushName",
	"void glPushName( GLuint name )",
	glPushName},
	{"glPopName",
	"void glPopName( void )",
	glPopName},
/*
	{"glDrawRangeElements",
	"void glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices )",
	glDrawRangeElements},
	{"glTexImage3D",
	"void glTexImage3D( GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels )",
	glTexImage3D},
	{"glTexSubImage3D",
	"void glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)",
	glTexSubImage3D},
	{"glCopyTexSubImage3D",
	"void glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )",
	glCopyTexSubImage3D},
	{"glColorTable",
	"void glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table )",
	glColorTable},
	{"glColorSubTable",
	"void glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data )",
	glColorSubTable},
	{"glColorTableParameteriv",
	"void glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)",
	glColorTableParameteriv},
	{"glColorTableParameterfv",
	"void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)",
	glColorTableParameterfv},
	{"glCopyColorSubTable",
	"void glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )",
	glCopyColorSubTable},
	{"glCopyColorTable",
	"void glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )",
	glCopyColorTable},
	{"glGetColorTable",
	"void glGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid *table )",
	glGetColorTable},
	{"glGetColorTableParameterfv",
	"void glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )",
	glGetColorTableParameterfv},
	{"glGetColorTableParameteriv",
	"void glGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )",
	glGetColorTableParameteriv},
	{"glBlendEquation",
	"void glBlendEquation( GLenum mode )",
	glBlendEquation},
	{"glBlendColor",
	"void glBlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )",
	glBlendColor},
	{"glHistogram",
	"void glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )",
	glHistogram},
	{"glResetHistogram",
	"void glResetHistogram( GLenum target )",
	glResetHistogram},
	{"glGetHistogram",
	"void glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values )",
	glGetHistogram},
	{"glGetHistogramParameterfv",
	"void glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params )",
	glGetHistogramParameterfv},
	{"glGetHistogramParameteriv",
	"void glGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params )",
	glGetHistogramParameteriv},
	{"glMinmax",
	"void glMinmax( GLenum target, GLenum internalformat, GLboolean sink )",
	glMinmax},
	{"glResetMinmax",
	"void glResetMinmax( GLenum target )",
	glResetMinmax},
	{"glGetMinmax",
	"void glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values )",
	glGetMinmax},
	{"glGetMinmaxParameterfv",
	"void glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params )",
	glGetMinmaxParameterfv},
	{"glGetMinmaxParameteriv",
	"void glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params )",
	glGetMinmaxParameteriv},
	{"glConvolutionFilter1D",
	"void glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, 	const GLvoid *image )",
	glConvolutionFilter1D},
	{"glConvolutionFilter2D",
	"void glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, 	GLenum type, const GLvoid *image )",
	glConvolutionFilter2D},
	{"glConvolutionParameterf",
	"void glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params )",
	glConvolutionParameterf},
	{"glConvolutionParameterfv",
	"void glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params )",
	glConvolutionParameterfv},
	{"glConvolutionParameteri",
	"void glConvolutionParameteri( GLenum target, GLenum pname, GLint params )",
	glConvolutionParameteri},
	{"glConvolutionParameteriv",
	"void glConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params )",
	glConvolutionParameteriv},
	{"glCopyConvolutionFilter1D",
	"void glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )",
	glCopyConvolutionFilter1D},
	{"glCopyConvolutionFilter2D",
	"void glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)",
	glCopyConvolutionFilter2D},
	{"glGetConvolutionFilter",
	"void glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid *image )",
	glGetConvolutionFilter},
	{"glGetConvolutionParameterfv",
	"void glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params )",
	glGetConvolutionParameterfv},
	{"glGetConvolutionParameteriv",
	"void glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params )",
	glGetConvolutionParameteriv},
	{"glSeparableFilter2D",
	"void glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column )",
	glSeparableFilter2D},
	{"glGetSeparableFilter",
	"void glGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span )",
	glGetSeparableFilter},
	{"glActiveTexture",
	"void glActiveTexture( GLenum texture )",
	glActiveTexture},
	{"glClientActiveTexture",
	"void glClientActiveTexture( GLenum texture )",
	glClientActiveTexture},
	{"glCompressedTexImage1D",
	"void glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexImage1D},
	{"glCompressedTexImage2D",
	"void glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexImage2D},
	{"glCompressedTexImage3D",
	"void glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexImage3D},
	{"glCompressedTexSubImage1D",
	"void glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexSubImage1D},
	{"glCompressedTexSubImage2D",
	"void glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexSubImage2D},
	{"glCompressedTexSubImage3D",
	"void glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data )",
	glCompressedTexSubImage3D},
	{"glGetCompressedTexImage",
	"void glGetCompressedTexImage( GLenum target, GLint lod, GLvoid *img )",
	glGetCompressedTexImage},
	{"glMultiTexCoord1d",
	"void glMultiTexCoord1d( GLenum target, GLdouble s )",
	glMultiTexCoord1d},
	{"glMultiTexCoord1dv",
	"void glMultiTexCoord1dv( GLenum target, const GLdouble *v )",
	glMultiTexCoord1dv},
	{"glMultiTexCoord1f",
	"void glMultiTexCoord1f( GLenum target, GLfloat s )",
	glMultiTexCoord1f},
	{"glMultiTexCoord1fv",
	"void glMultiTexCoord1fv( GLenum target, const GLfloat *v )",
	glMultiTexCoord1fv},
	{"glMultiTexCoord1i",
	"void glMultiTexCoord1i( GLenum target, GLint s )",
	glMultiTexCoord1i},
	{"glMultiTexCoord1iv",
	"void glMultiTexCoord1iv( GLenum target, const GLint *v )",
	glMultiTexCoord1iv},
	{"glMultiTexCoord1s",
	"void glMultiTexCoord1s( GLenum target, GLshort s )",
	glMultiTexCoord1s},
	{"glMultiTexCoord1sv",
	"void glMultiTexCoord1sv( GLenum target, const GLshort *v )",
	glMultiTexCoord1sv},
	{"glMultiTexCoord2d",
	"void glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t )",
	glMultiTexCoord2d},
	{"glMultiTexCoord2dv",
	"void glMultiTexCoord2dv( GLenum target, const GLdouble *v )",
	glMultiTexCoord2dv},
	{"glMultiTexCoord2f",
	"void glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t )",
	glMultiTexCoord2f},
	{"glMultiTexCoord2fv",
	"void glMultiTexCoord2fv( GLenum target, const GLfloat *v )",
	glMultiTexCoord2fv},
	{"glMultiTexCoord2i",
	"void glMultiTexCoord2i( GLenum target, GLint s, GLint t )",
	glMultiTexCoord2i},
	{"glMultiTexCoord2iv",
	"void glMultiTexCoord2iv( GLenum target, const GLint *v )",
	glMultiTexCoord2iv},
	{"glMultiTexCoord2s",
	"void glMultiTexCoord2s( GLenum target, GLshort s, GLshort t )",
	glMultiTexCoord2s},
	{"glMultiTexCoord2sv",
	"void glMultiTexCoord2sv( GLenum target, const GLshort *v )",
	glMultiTexCoord2sv},
	{"glMultiTexCoord3d",
	"void glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r )",
	glMultiTexCoord3d},
	{"glMultiTexCoord3dv",
	"void glMultiTexCoord3dv( GLenum target, const GLdouble *v )",
	glMultiTexCoord3dv},
	{"glMultiTexCoord3f",
	"void glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r )",
	glMultiTexCoord3f},
	{"glMultiTexCoord3fv",
	"void glMultiTexCoord3fv( GLenum target, const GLfloat *v )",
	glMultiTexCoord3fv},
	{"glMultiTexCoord3i",
	"void glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r )",
	glMultiTexCoord3i},
	{"glMultiTexCoord3iv",
	"void glMultiTexCoord3iv( GLenum target, const GLint *v )",
	glMultiTexCoord3iv},
	{"glMultiTexCoord3s",
	"void glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r )",
	glMultiTexCoord3s},
	{"glMultiTexCoord3sv",
	"void glMultiTexCoord3sv( GLenum target, const GLshort *v )",
	glMultiTexCoord3sv},
	{"glMultiTexCoord4d",
	"void glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )",
	glMultiTexCoord4d},
	{"glMultiTexCoord4dv",
	"void glMultiTexCoord4dv( GLenum target, const GLdouble *v )",
	glMultiTexCoord4dv},
	{"glMultiTexCoord4f",
	"void glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )",
	glMultiTexCoord4f},
	{"glMultiTexCoord4fv",
	"void glMultiTexCoord4fv( GLenum target, const GLfloat *v )",
	glMultiTexCoord4fv},
	{"glMultiTexCoord4i",
	"void glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q )",
	glMultiTexCoord4i},
	{"glMultiTexCoord4iv",
	"void glMultiTexCoord4iv( GLenum target, const GLint *v )",
	glMultiTexCoord4iv},
	{"glMultiTexCoord4s",
	"void glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )",
	glMultiTexCoord4s},
	{"glMultiTexCoord4sv",
	"void glMultiTexCoord4sv( GLenum target, const GLshort *v )",
	glMultiTexCoord4sv},
	{"glLoadTransposeMatrixd",
	"void glLoadTransposeMatrixd( const GLdouble m[16] )",
	glLoadTransposeMatrixd},
	{"glLoadTransposeMatrixf",
	"void glLoadTransposeMatrixf( const GLfloat m[16] )",
	glLoadTransposeMatrixf},
	{"glMultTransposeMatrixd",
	"void glMultTransposeMatrixd( const GLdouble m[16] )",
	glMultTransposeMatrixd},
	{"glMultTransposeMatrixf",
	"void glMultTransposeMatrixf( const GLfloat m[16] )",
	glMultTransposeMatrixf},
	{"glSampleCoverage",
	"void glSampleCoverage( GLclampf value, GLboolean invert )",
	glSampleCoverage},
	{"glActiveTextureARB",
	"void glActiveTextureARB(GLenum texture)",
	glActiveTextureARB},
	{"glClientActiveTextureARB",
	"void glClientActiveTextureARB(GLenum texture)",
	glClientActiveTextureARB},
	{"glMultiTexCoord1dARB",
	"void glMultiTexCoord1dARB(GLenum target, GLdouble s)",
	glMultiTexCoord1dARB},
	{"glMultiTexCoord1dvARB",
	"void glMultiTexCoord1dvARB(GLenum target, const GLdouble *v)",
	glMultiTexCoord1dvARB},
	{"glMultiTexCoord1fARB",
	"void glMultiTexCoord1fARB(GLenum target, GLfloat s)",
	glMultiTexCoord1fARB},
	{"glMultiTexCoord1fvARB",
	"void glMultiTexCoord1fvARB(GLenum target, const GLfloat *v)",
	glMultiTexCoord1fvARB},
	{"glMultiTexCoord1iARB",
	"void glMultiTexCoord1iARB(GLenum target, GLint s)",
	glMultiTexCoord1iARB},
	{"glMultiTexCoord1ivARB",
	"void glMultiTexCoord1ivARB(GLenum target, const GLint *v)",
	glMultiTexCoord1ivARB},
	{"glMultiTexCoord1sARB",
	"void glMultiTexCoord1sARB(GLenum target, GLshort s)",
	glMultiTexCoord1sARB},
	{"glMultiTexCoord1svARB",
	"void glMultiTexCoord1svARB(GLenum target, const GLshort *v)",
	glMultiTexCoord1svARB},
	{"glMultiTexCoord2dARB",
	"void glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)",
	glMultiTexCoord2dARB},
	{"glMultiTexCoord2dvARB",
	"void glMultiTexCoord2dvARB(GLenum target, const GLdouble *v)",
	glMultiTexCoord2dvARB},
	{"glMultiTexCoord2fARB",
	"void glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)",
	glMultiTexCoord2fARB},
	{"glMultiTexCoord2fvARB",
	"void glMultiTexCoord2fvARB(GLenum target, const GLfloat *v)",
	glMultiTexCoord2fvARB},
	{"glMultiTexCoord2iARB",
	"void glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)",
	glMultiTexCoord2iARB},
	{"glMultiTexCoord2ivARB",
	"void glMultiTexCoord2ivARB(GLenum target, const GLint *v)",
	glMultiTexCoord2ivARB},
	{"glMultiTexCoord2sARB",
	"void glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)",
	glMultiTexCoord2sARB},
	{"glMultiTexCoord2svARB",
	"void glMultiTexCoord2svARB(GLenum target, const GLshort *v)",
	glMultiTexCoord2svARB},
	{"glMultiTexCoord3dARB",
	"void glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)",
	glMultiTexCoord3dARB},
	{"glMultiTexCoord3dvARB",
	"void glMultiTexCoord3dvARB(GLenum target, const GLdouble *v)",
	glMultiTexCoord3dvARB},
	{"glMultiTexCoord3fARB",
	"void glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)",
	glMultiTexCoord3fARB},
	{"glMultiTexCoord3fvARB",
	"void glMultiTexCoord3fvARB(GLenum target, const GLfloat *v)",
	glMultiTexCoord3fvARB},
	{"glMultiTexCoord3iARB",
	"void glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)",
	glMultiTexCoord3iARB},
	{"glMultiTexCoord3ivARB",
	"void glMultiTexCoord3ivARB(GLenum target, const GLint *v)",
	glMultiTexCoord3ivARB},
	{"glMultiTexCoord3sARB",
	"void glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)",
	glMultiTexCoord3sARB},
	{"glMultiTexCoord3svARB",
	"void glMultiTexCoord3svARB(GLenum target, const GLshort *v)",
	glMultiTexCoord3svARB},
	{"glMultiTexCoord4dARB",
	"void glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)",
	glMultiTexCoord4dARB},
	{"glMultiTexCoord4dvARB",
	"void glMultiTexCoord4dvARB(GLenum target, const GLdouble *v)",
	glMultiTexCoord4dvARB},
	{"glMultiTexCoord4fARB",
	"void glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)",
	glMultiTexCoord4fARB},
	{"glMultiTexCoord4fvARB",
	"void glMultiTexCoord4fvARB(GLenum target, const GLfloat *v)",
	glMultiTexCoord4fvARB},
	{"glMultiTexCoord4iARB",
	"void glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)",
	glMultiTexCoord4iARB},
	{"glMultiTexCoord4ivARB",
	"void glMultiTexCoord4ivARB(GLenum target, const GLint *v)",
	glMultiTexCoord4ivARB},
	{"glMultiTexCoord4sARB",
	"void glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)",
	glMultiTexCoord4sARB},
	{"glMultiTexCoord4svARB",
	"void glMultiTexCoord4svARB(GLenum target, const GLshort *v)",
	glMultiTexCoord4svARB},
*/
	{"glEnableTraceMESA",
	"void glEnableTraceMESA( GLbitfield mask )",
	glEnableTraceMESA},
	{"glDisableTraceMESA",
	"void glDisableTraceMESA( GLbitfield mask )",
	glDisableTraceMESA},
	{"glNewTraceMESA",
	"void glNewTraceMESA( GLbitfield mask, const GLubyte * traceName )",
	glNewTraceMESA},
	{"glEndTraceMESA",
	"void glEndTraceMESA( void )",
	glEndTraceMESA},
	{"glTraceAssertAttribMESA",
	"void glTraceAssertAttribMESA( GLbitfield attribMask )",
	glTraceAssertAttribMESA},
	{"glTraceCommentMESA",
	"void glTraceCommentMESA( const GLubyte * comment )",
	glTraceCommentMESA},
	{"glTraceTextureMESA",
	"void glTraceTextureMESA( GLuint name, const GLubyte* comment )",
	glTraceTextureMESA},
	{"glTraceListMESA",
	"void glTraceListMESA( GLuint name, const GLubyte* comment )",
	glTraceListMESA},
	{"glTracePointerMESA",
	"void glTracePointerMESA( GLvoid* pointer, const GLubyte* comment )",
	glTracePointerMESA},
	{"glTracePointerRangeMESA",
	"void glTracePointerRangeMESA( const GLvoid* first, const GLvoid* last, const GLubyte* comment )",
	glTracePointerRangeMESA},
	{"glBlendEquationSeparateATI",
	"void glBlendEquationSeparateATI( GLenum modeRGB, GLenum modeA )",
	glBlendEquationSeparateATI},
