GLboolean glIsBuffer(GLuint buffer) {
	return FNPTR(IsBuffer)(buffer);
}

GLboolean glIsEnabled(GLenum cap) {
	return FNPTR(IsEnabled)(cap);
}

GLboolean glIsFramebuffer(GLuint framebuffer) {
	return FNPTR(IsFramebuffer)(framebuffer);
}

GLboolean glIsProgram(GLuint program) {
	return FNPTR(IsProgram)(program);
}

GLboolean glIsRenderbuffer(GLuint renderbuffer) {
	return FNPTR(IsRenderbuffer)(renderbuffer);
}

GLboolean glIsShader(GLuint shader) {
	return FNPTR(IsShader)(shader);
}

GLboolean glIsTexture(GLuint texture) {
	return FNPTR(IsTexture)(texture);
}

GLenum glCheckFramebufferStatus(GLenum target) {
	return FNPTR(CheckFramebufferStatus)(target);
}

GLenum glGetError(void) {
	return FNPTR(GetError)();
}

GLint glGetAttribLocation(GLuint program, const char* name) {
	return FNPTR(GetAttribLocation)(program, name);
}

GLint glGetUniformLocation(GLuint program, const char* name) {
	return FNPTR(GetUniformLocation)(program, name);
}

GLuint glCreateProgram(void) {
	return FNPTR(CreateProgram)();
}

GLuint glCreateShader(GLenum type) {
	return FNPTR(CreateShader)(type);
}

const GLubyte* glGetString(GLenum name) {
	return FNPTR(GetString)(name);
}

void glActiveTexture(GLenum texture) {
	FNPTR(ActiveTexture)(texture);
}

void glAlphaFunc(GLenum func, GLclampf ref) {
	FNPTR(AlphaFunc)(func, ref);
}

void glAttachShader(GLuint program, GLuint shader) {
	FNPTR(AttachShader)(program, shader);
}

void glBindAttribLocation(GLuint program, GLuint index, const char* name) {
	FNPTR(BindAttribLocation)(program, index, name);
}

void glBindBuffer(GLenum target, GLuint buffer) {
	FNPTR(BindBuffer)(target, buffer);
}

void glBindFramebuffer(GLenum target, GLuint framebuffer) {
	FNPTR(BindFramebuffer)(target, framebuffer);
}

void glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
	FNPTR(BindRenderbuffer)(target, renderbuffer);
}

void glBindTexture(GLenum target, GLuint texture) {
	FNPTR(BindTexture)(target, texture);
}

void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
	FNPTR(BlendColor)(red, green, blue, alpha);
}

void glBlendEquation(GLenum mode) {
	FNPTR(BlendEquation)(mode);
}

void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
	FNPTR(BlendEquationSeparate)(modeRGB, modeAlpha);
}

void glBlendFunc(GLenum sfactor, GLenum dfactor) {
	FNPTR(BlendFunc)(sfactor, dfactor);
}

void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
	FNPTR(BlendFuncSeparate)(srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
	FNPTR(BufferData)(target, size, data, usage);
}

void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
	FNPTR(BufferSubData)(target, offset, size, data);
}

void glClear(GLbitfield mask) {
	FNPTR(Clear)(mask);
}

void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
	FNPTR(ClearColor)(red, green, blue, alpha);
}

void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
	FNPTR(ClearColorx)(red, green, blue, alpha);
}

void glClearDepthf(GLclampf depth) {
	FNPTR(ClearDepthf)(depth);
}

void glClearStencil(GLint s) {
	FNPTR(ClearStencil)(s);
}

void glClientActiveTexture(GLenum texture) {
	FNPTR(ClientActiveTexture)(texture);
}

void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
	FNPTR(Color4f)(red, green, blue, alpha);
}

void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
	FNPTR(Color4ub)(red, green, blue, alpha);
}

void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
	FNPTR(ColorMask)(red, green, blue, alpha);
}

void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
	FNPTR(ColorPointer)(size, type, stride, pointer);
}

void glCompileShader(GLuint shader) {
	FNPTR(CompileShader)(shader);
}

void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) {
	FNPTR(CompressedTexImage2D)(target, level, internalformat, width, height, border, imageSize, data);
}

void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) {
	FNPTR(CompressedTexSubImage2D)(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
	FNPTR(CopyTexImage2D)(target, level, internalformat, x, y, width, height, border);
}

void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
	FNPTR(CopyTexSubImage2D)(target, level, xoffset, yoffset, x, y, width, height);
}

void glCullFace(GLenum mode) {
	FNPTR(CullFace)(mode);
}

void glDeleteBuffers(GLsizei n, const GLuint* buffers) {
	FNPTR(DeleteBuffers)(n, buffers);
}

void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
	FNPTR(DeleteFramebuffers)(n, framebuffers);
}

void glDeleteProgram(GLuint program) {
	FNPTR(DeleteProgram)(program);
}

void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
	FNPTR(DeleteRenderbuffers)(n, renderbuffers);
}

void glDeleteShader(GLuint shader) {
	FNPTR(DeleteShader)(shader);
}

void glDeleteTextures(GLsizei n, const GLuint* textures) {
	FNPTR(DeleteTextures)(n, textures);
}

void glDepthFunc(GLenum func) {
	FNPTR(DepthFunc)(func);
}

void glDepthMask(GLboolean flag) {
	FNPTR(DepthMask)(flag);
}

void glDepthRangef(GLclampf zNear, GLclampf zFar) {
	FNPTR(DepthRangef)(zNear, zFar);
}

void glDetachShader(GLuint program, GLuint shader) {
	FNPTR(DetachShader)(program, shader);
}

void glDisable(GLenum cap) {
	FNPTR(Disable)(cap);
}

void glDisableClientState(GLenum array) {
	FNPTR(DisableClientState)(array);
}

void glDisableVertexAttribArray(GLuint index) {
	FNPTR(DisableVertexAttribArray)(index);
}

void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
	FNPTR(DrawArrays)(mode, first, count);
}

void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
	FNPTR(DrawElements)(mode, count, type, indices);
}

void glEnable(GLenum cap) {
	FNPTR(Enable)(cap);
}

void glEnableClientState(GLenum array) {
	FNPTR(EnableClientState)(array);
}

void glEnableVertexAttribArray(GLuint index) {
	FNPTR(EnableVertexAttribArray)(index);
}

void glFinish(void) {
	FNPTR(Finish)();
}

void glFlush(void) {
	FNPTR(Flush)();
}

void glFogf(GLenum pname, GLfloat param) {
	FNPTR(Fogf)(pname, param);
}

void glFogfv(GLenum pname, const GLfloat* params) {
	FNPTR(Fogfv)(pname, params);
}

void glFogi(GLenum pname, GLint param) {
	FNPTR(Fogi)(pname, param);
}

void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
	FNPTR(FramebufferRenderbuffer)(target, attachment, renderbuffertarget, renderbuffer);
}

void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
	FNPTR(FramebufferTexture2D)(target, attachment, textarget, texture, level);
}

void glFrontFace(GLenum mode) {
	FNPTR(FrontFace)(mode);
}

void glGenBuffers(GLsizei n, GLuint* buffers) {
	FNPTR(GenBuffers)(n, buffers);
}

void glGenFramebuffers(GLsizei n, GLuint* framebuffers) {
	FNPTR(GenFramebuffers)(n, framebuffers);
}

void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
	FNPTR(GenRenderbuffers)(n, renderbuffers);
}

void glGenTextures(GLsizei n, GLuint* textures) {
	FNPTR(GenTextures)(n, textures);
}

void glGenerateMipmap(GLenum target) {
	FNPTR(GenerateMipmap)(target);
}

void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) {
	FNPTR(GetActiveAttrib)(program, index, bufsize, length, size, type, name);
}

void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) {
	FNPTR(GetActiveUniform)(program, index, bufsize, length, size, type, name);
}


void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
	FNPTR(GetAttachedShaders)(program, maxcount, count, shaders);
}


void glGetBooleanv(GLenum pname, GLboolean* params) {
	FNPTR(GetBooleanv)(pname, params);
}


void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
	FNPTR(GetBufferParameteriv)(target, pname, params);
}


void glGetFloatv(GLenum pname, GLfloat* params) {
	FNPTR(GetFloatv)(pname, params);
}


void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) {
	FNPTR(GetFramebufferAttachmentParameteriv)(target, attachment, pname, params);
}


void glGetIntegerv(GLenum pname, GLint* params) {
	FNPTR(GetIntegerv)(pname, params);
}


void glGetLightfv(GLenum light, GLenum pname, GLfloat* params) {
	FNPTR(GetLightfv)(light, pname, params);
}


void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params) {
	FNPTR(GetMaterialfv)(face, pname, params);
}


void glGetPointerv(GLenum pname, void** params) {
	FNPTR(GetPointerv)(pname, params);
}


void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) {
	FNPTR(GetProgramInfoLog)(program, bufsize, length, infolog);
}


void glGetProgramiv(GLuint program, GLenum pname, GLint* params) {
	FNPTR(GetProgramiv)(program, pname, params);
}


void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) {
	FNPTR(GetRenderbufferParameteriv)(target, pname, params);
}


void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) {
	FNPTR(GetShaderInfoLog)(shader, bufsize, length, infolog);
}


void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) {
	FNPTR(GetShaderSource)(shader, bufsize, length, source);
}


void glGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
	FNPTR(GetShaderiv)(shader, pname, params);
}


void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params) {
	FNPTR(GetTexEnvfv)(env, pname, params);
}


void glGetTexEnviv(GLenum env, GLenum pname, GLint* params) {
	FNPTR(GetTexEnviv)(env, pname, params);
}


void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
	FNPTR(GetTexParameterfv)(target, pname, params);
}


void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
	FNPTR(GetTexParameteriv)(target, pname, params);
}


void glGetUniformfv(GLuint program, GLint location, GLfloat* params) {
	FNPTR(GetUniformfv)(program, location, params);
}


void glGetUniformiv(GLuint program, GLint location, GLint* params) {
	FNPTR(GetUniformiv)(program, location, params);
}


void glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
	FNPTR(GetVertexAttribPointerv)(index, pname, pointer);
}


void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
	FNPTR(GetVertexAttribfv)(index, pname, params);
}


void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
	FNPTR(GetVertexAttribiv)(index, pname, params);
}


void glHint(GLenum target, GLenum mode) {
	FNPTR(Hint)(target, mode);
}


void glLightModelf(GLenum pname, GLfloat param) {
	FNPTR(LightModelf)(pname, param);
}


void glLightModelfv(GLenum pname, const GLfloat* params) {
	FNPTR(LightModelfv)(pname, params);
}


void glLightf(GLenum light, GLenum pname, GLfloat param) {
	FNPTR(Lightf)(light, pname, param);
}


void glLightfv(GLenum light, GLenum pname, const GLfloat* params) {
	FNPTR(Lightfv)(light, pname, params);
}


void glLineWidth(GLfloat width) {
	FNPTR(LineWidth)(width);
}


void glLinkProgram(GLuint program) {
	FNPTR(LinkProgram)(program);
}


void glLoadIdentity(void) {
	FNPTR(LoadIdentity)();
}


void glLoadMatrixf(const GLfloat* m) {
	FNPTR(LoadMatrixf)(m);
}


void glLogicOp(GLenum opcode) {
	FNPTR(LogicOp)(opcode);
}


void glMaterialf(GLenum face, GLenum pname, GLfloat param) {
	FNPTR(Materialf)(face, pname, param);
}


void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params) {
	FNPTR(Materialfv)(face, pname, params);
}


void glMatrixMode(GLenum mode) {
	FNPTR(MatrixMode)(mode);
}


void glMultMatrixf(const GLfloat* m) {
	FNPTR(MultMatrixf)(m);
}


void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
	FNPTR(MultiTexCoord4f)(target, s, t, r, q);
}


void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
	FNPTR(Normal3f)(nx, ny, nz);
}


void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer) {
	FNPTR(NormalPointer)(type, stride, pointer);
}

void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far) {
	FNPTR(Ortho)(left, right, bottom, top, near, far);
}

void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far) {
	FNPTR(Orthof)(left, right, bottom, top, near, far);
}

void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed near, GLfixed far) {
	FNPTR(Orthox)(left, right, bottom, top, near, far);
}


void glPixelStorei(GLenum pname, GLint param) {
	FNPTR(PixelStorei)(pname, param);
}


void glPointParameterf(GLenum pname, GLfloat param) {
	FNPTR(PointParameterf)(pname, param);
}


void glPointParameterfv(GLenum pname, const GLfloat* params) {
	FNPTR(PointParameterfv)(pname, params);
}


void glPointSize(GLfloat size) {
	FNPTR(PointSize)(size);
}


void glPolygonOffset(GLfloat factor, GLfloat units) {
	FNPTR(PolygonOffset)(factor, units);
}


void glPopMatrix(void) {
	FNPTR(PopMatrix)();
}


void glPushMatrix(void) {
	FNPTR(PushMatrix)();
}


void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) {
	FNPTR(ReadPixels)(x, y, width, height, format, type, pixels);
}


void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
	FNPTR(RenderbufferStorage)(target, internalformat, width, height);
}


void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
	FNPTR(Rotatef)(angle, x, y, z);
}

void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
	FNPTR(Rotatex)(angle, x, y, z);
}

void glSampleCoverage(GLclampf value, GLboolean invert) {
	FNPTR(SampleCoverage)(value, invert);
}


void glScalef(GLfloat x, GLfloat y, GLfloat z) {
	FNPTR(Scalef)(x, y, z);
}


void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
	FNPTR(Scissor)(x, y, width, height);
}


void glShadeModel(GLenum mode) {
	FNPTR(ShadeModel)(mode);
}


void glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) {
	FNPTR(ShaderSource)(shader, count, string, length);
}


void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
	FNPTR(StencilFunc)(func, ref, mask);
}


void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
	FNPTR(StencilFuncSeparate)(face, func, ref, mask);
}


void glStencilMask(GLuint mask) {
	FNPTR(StencilMask)(mask);
}


void glStencilMaskSeparate(GLenum face, GLuint mask) {
	FNPTR(StencilMaskSeparate)(face, mask);
}


void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
	FNPTR(StencilOp)(fail, zfail, zpass);
}


void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
	FNPTR(StencilOpSeparate)(face, fail, zfail, zpass);
}


void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
	FNPTR(TexCoordPointer)(size, type, stride, pointer);
}


void glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
	FNPTR(TexEnvf)(target, pname, param);
}


void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params) {
	FNPTR(TexEnvfv)(target, pname, params);
}


void glTexEnvi(GLenum target, GLenum pname, GLint param) {
	FNPTR(TexEnvi)(target, pname, param);
}


void glTexEnviv(GLenum target, GLenum pname, const GLint* params) {
	FNPTR(TexEnviv)(target, pname, params);
}


void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) {
	FNPTR(TexImage2D)(target, level, internalformat, width, height, border, format, type, pixels);
}


void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
	FNPTR(TexParameterf)(target, pname, param);
}


void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
	FNPTR(TexParameterfv)(target, pname, params);
}


void glTexParameteri(GLenum target, GLenum pname, GLint param) {
	FNPTR(TexParameteri)(target, pname, param);
}


void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
	FNPTR(TexParameteriv)(target, pname, params);
}


void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) {
	FNPTR(TexSubImage2D)(target, level, xoffset, yoffset, width, height, format, type, pixels);
}


void glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
	FNPTR(Translatef)(x, y, z);
}

void glTranslatex(GLfixed x, GLfixed y, GLfixed z) {
	FNPTR(Translatex)(x, y, z);
}

void glUniform1f(GLint location, GLfloat x) {
	FNPTR(Uniform1f)(location, x);
}


void glUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
	FNPTR(Uniform1fv)(location, count, v);
}


void glUniform1i(GLint location, GLint x) {
	FNPTR(Uniform1i)(location, x);
}


void glUniform1iv(GLint location, GLsizei count, const GLint* v) {
	FNPTR(Uniform1iv)(location, count, v);
}


void glUniform2f(GLint location, GLfloat x, GLfloat y) {
	FNPTR(Uniform2f)(location, x, y);
}


void glUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
	FNPTR(Uniform2fv)(location, count, v);
}


void glUniform2i(GLint location, GLint x, GLint y) {
	FNPTR(Uniform2i)(location, x, y);
}


void glUniform2iv(GLint location, GLsizei count, const GLint* v) {
	FNPTR(Uniform2iv)(location, count, v);
}


void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
	FNPTR(Uniform3f)(location, x, y, z);
}


void glUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
	FNPTR(Uniform3fv)(location, count, v);
}


void glUniform3i(GLint location, GLint x, GLint y, GLint z) {
	FNPTR(Uniform3i)(location, x, y, z);
}


void glUniform3iv(GLint location, GLsizei count, const GLint* v) {
	FNPTR(Uniform3iv)(location, count, v);
}


void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
	FNPTR(Uniform4f)(location, x, y, z, w);
}


void glUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
	FNPTR(Uniform4fv)(location, count, v);
}


void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
	FNPTR(Uniform4i)(location, x, y, z, w);
}


void glUniform4iv(GLint location, GLsizei count, const GLint* v) {
	FNPTR(Uniform4iv)(location, count, v);
}


void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
	FNPTR(UniformMatrix2fv)(location, count, transpose, value);
}


void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
	FNPTR(UniformMatrix3fv)(location, count, transpose, value);
}


void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
	FNPTR(UniformMatrix4fv)(location, count, transpose, value);
}


void glUseProgram(GLuint program) {
	FNPTR(UseProgram)(program);
}


void glValidateProgram(GLuint program) {
	FNPTR(ValidateProgram)(program);
}


void glVertexAttrib1f(GLuint indx, GLfloat x) {
	FNPTR(VertexAttrib1f)(indx, x);
}


void glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
	FNPTR(VertexAttrib1fv)(indx, values);
}


void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
	FNPTR(VertexAttrib2f)(indx, x, y);
}


void glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
	FNPTR(VertexAttrib2fv)(indx, values);
}


void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
	FNPTR(VertexAttrib3f)(indx, x, y, z);
}


void glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
	FNPTR(VertexAttrib3fv)(indx, values);
}


void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
	FNPTR(VertexAttrib4f)(indx, x, y, z, w);
}


void glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
	FNPTR(VertexAttrib4fv)(indx, values);
}


void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) {
	FNPTR(VertexAttribPointer)(indx, size, type, normalized, stride, ptr);
}


void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
	FNPTR(VertexPointer)(size, type, stride, pointer);
}


void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
	FNPTR(Viewport)(x, y, width, height);
}