// Automatically generated OpenGL binding.
// 
// Categories in this package: 
// 
// ARB_ES2_compatibility: https://www.opengl.org/registry/specs/ARB/ES2_compatibility.txt
// 
// ARB_base_instance: https://www.opengl.org/registry/specs/ARB/base_instance.txt
// 
// ARB_blend_func_extended: https://www.opengl.org/registry/specs/ARB/blend_func_extended.txt
// 
// ARB_cl_event: https://www.opengl.org/registry/specs/ARB/cl_event.txt
// 
// ARB_clear_buffer_object: https://www.opengl.org/registry/specs/ARB/clear_buffer_object.txt
// 
// ARB_color_buffer_float: https://www.opengl.org/registry/specs/ARB/color_buffer_float.txt
// 
// ARB_compute_shader: https://www.opengl.org/registry/specs/ARB/compute_shader.txt
// 
// ARB_copy_buffer: https://www.opengl.org/registry/specs/ARB/copy_buffer.txt
// 
// ARB_copy_image: https://www.opengl.org/registry/specs/ARB/copy_image.txt
// 
// ARB_debug_output: https://www.opengl.org/registry/specs/ARB/debug_output.txt
// 
// ARB_draw_buffers: https://www.opengl.org/registry/specs/ARB/draw_buffers.txt
// 
// ARB_draw_buffers_blend: https://www.opengl.org/registry/specs/ARB/draw_buffers_blend.txt
// 
// ARB_draw_elements_base_vertex: https://www.opengl.org/registry/specs/ARB/draw_elements_base_vertex.txt
// 
// ARB_draw_indirect: https://www.opengl.org/registry/specs/ARB/draw_indirect.txt
// 
// ARB_draw_instanced: https://www.opengl.org/registry/specs/ARB/draw_instanced.txt
// 
// ARB_framebuffer_no_attachments: https://www.opengl.org/registry/specs/ARB/framebuffer_no_attachments.txt
// 
// ARB_framebuffer_object: https://www.opengl.org/registry/specs/ARB/framebuffer_object.txt
// 
// ARB_geometry_shader4: https://www.opengl.org/registry/specs/ARB/geometry_shader4.txt
// 
// ARB_get_program_binary: https://www.opengl.org/registry/specs/ARB/get_program_binary.txt
// 
// ARB_gpu_shader_fp64: https://www.opengl.org/registry/specs/ARB/gpu_shader_fp64.txt
// 
// ARB_instanced_arrays: https://www.opengl.org/registry/specs/ARB/instanced_arrays.txt
// 
// ARB_internalformat_query: https://www.opengl.org/registry/specs/ARB/internalformat_query.txt
// 
// ARB_internalformat_query2: https://www.opengl.org/registry/specs/ARB/internalformat_query2.txt
// 
// ARB_invalidate_subdata: https://www.opengl.org/registry/specs/ARB/invalidate_subdata.txt
// 
// ARB_map_buffer_range: https://www.opengl.org/registry/specs/ARB/map_buffer_range.txt
// 
// ARB_matrix_palette: https://www.opengl.org/registry/specs/ARB/matrix_palette.txt
// 
// ARB_multi_draw_indirect: https://www.opengl.org/registry/specs/ARB/multi_draw_indirect.txt
// 
// ARB_multisample: https://www.opengl.org/registry/specs/ARB/multisample.txt
// 
// ARB_multitexture: https://www.opengl.org/registry/specs/ARB/multitexture.txt
// 
// ARB_occlusion_query: https://www.opengl.org/registry/specs/ARB/occlusion_query.txt
// 
// ARB_point_parameters: https://www.opengl.org/registry/specs/ARB/point_parameters.txt
// 
// ARB_program_interface_query: https://www.opengl.org/registry/specs/ARB/program_interface_query.txt
// 
// ARB_provoking_vertex: https://www.opengl.org/registry/specs/ARB/provoking_vertex.txt
// 
// ARB_robustness: https://www.opengl.org/registry/specs/ARB/robustness.txt
// 
// ARB_sample_shading: https://www.opengl.org/registry/specs/ARB/sample_shading.txt
// 
// ARB_sampler_objects: https://www.opengl.org/registry/specs/ARB/sampler_objects.txt
// 
// ARB_separate_shader_objects: https://www.opengl.org/registry/specs/ARB/separate_shader_objects.txt
// 
// ARB_shader_atomic_counters: https://www.opengl.org/registry/specs/ARB/shader_atomic_counters.txt
// 
// ARB_shader_image_load_store: https://www.opengl.org/registry/specs/ARB/shader_image_load_store.txt
// 
// ARB_shader_objects: https://www.opengl.org/registry/specs/ARB/shader_objects.txt
// 
// ARB_shader_storage_buffer_object: https://www.opengl.org/registry/specs/ARB/shader_storage_buffer_object.txt
// 
// ARB_shader_subroutine: https://www.opengl.org/registry/specs/ARB/shader_subroutine.txt
// 
// ARB_shading_language_include: https://www.opengl.org/registry/specs/ARB/shading_language_include.txt
// 
// ARB_sync: https://www.opengl.org/registry/specs/ARB/sync.txt
// 
// ARB_tessellation_shader: https://www.opengl.org/registry/specs/ARB/tessellation_shader.txt
// 
// ARB_texture_buffer_object: https://www.opengl.org/registry/specs/ARB/texture_buffer_object.txt
// 
// ARB_texture_buffer_range: https://www.opengl.org/registry/specs/ARB/texture_buffer_range.txt
// 
// ARB_texture_compression: https://www.opengl.org/registry/specs/ARB/texture_compression.txt
// 
// ARB_texture_multisample: https://www.opengl.org/registry/specs/ARB/texture_multisample.txt
// 
// ARB_texture_storage: https://www.opengl.org/registry/specs/ARB/texture_storage.txt
// 
// ARB_texture_storage_multisample: https://www.opengl.org/registry/specs/ARB/texture_storage_multisample.txt
// 
// ARB_texture_view: https://www.opengl.org/registry/specs/ARB/texture_view.txt
// 
// ARB_timer_query: https://www.opengl.org/registry/specs/ARB/timer_query.txt
// 
// ARB_transform_feedback2: https://www.opengl.org/registry/specs/ARB/transform_feedback2.txt
// 
// ARB_transform_feedback3: https://www.opengl.org/registry/specs/ARB/transform_feedback3.txt
// 
// ARB_transform_feedback_instanced: https://www.opengl.org/registry/specs/ARB/transform_feedback_instanced.txt
// 
// ARB_transpose_matrix: https://www.opengl.org/registry/specs/ARB/transpose_matrix.txt
// 
// ARB_uniform_buffer_object: https://www.opengl.org/registry/specs/ARB/uniform_buffer_object.txt
// 
// ARB_vertex_array_object: https://www.opengl.org/registry/specs/ARB/vertex_array_object.txt
// 
// ARB_vertex_attrib_64bit: https://www.opengl.org/registry/specs/ARB/vertex_attrib_64bit.txt
// 
// ARB_vertex_attrib_binding: https://www.opengl.org/registry/specs/ARB/vertex_attrib_binding.txt
// 
// ARB_vertex_blend: https://www.opengl.org/registry/specs/ARB/vertex_blend.txt
// 
// ARB_vertex_buffer_object: https://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
// 
// ARB_vertex_program: https://www.opengl.org/registry/specs/ARB/vertex_program.txt
// 
// ARB_vertex_shader: https://www.opengl.org/registry/specs/ARB/vertex_shader.txt
// 
// ARB_vertex_type_2_10_10_10_rev: https://www.opengl.org/registry/specs/ARB/vertex_type_2_10_10_10_rev.txt
// 
// ARB_viewport_array: https://www.opengl.org/registry/specs/ARB/viewport_array.txt
// 
// ARB_window_pos: https://www.opengl.org/registry/specs/ARB/window_pos.txt
// 
package arb

// #cgo darwin  LDFLAGS: -framework OpenGL
// #cgo linux   LDFLAGS: -lGL
// #cgo windows LDFLAGS: -lopengl32
// 
// #include <stdlib.h>
// #if defined(__APPLE__)
// #include <dlfcn.h>
// #elif defined(_WIN32)
// #define WIN32_LEAN_AND_MEAN 1
// #include <windows.h>
// #else
// #include <X11/Xlib.h>
// #include <GL/glx.h>
// #endif
// 
// #ifndef APIENTRY
// #define APIENTRY
// #endif
// #ifndef APIENTRYP
// #define APIENTRYP APIENTRY *
// #endif
// #ifndef GLAPI
// #define GLAPI extern
// #endif
// 
// typedef unsigned int GLenum;
// typedef unsigned char GLboolean;
// typedef unsigned int GLbitfield;
// typedef signed char GLbyte;
// typedef short GLshort;
// typedef int GLint;
// typedef int GLsizei;
// typedef unsigned char GLubyte;
// typedef unsigned short GLushort;
// typedef unsigned int GLuint;
// typedef unsigned short GLhalf;
// typedef float GLfloat;
// typedef float GLclampf;
// typedef double GLdouble;
// typedef double GLclampd;
// typedef void GLvoid;
// 
// #include <stddef.h>
// #ifndef GL_VERSION_2_0
// /* GL type for program/shader text */
// typedef char GLchar;
// #endif
// 
// #ifndef GL_VERSION_1_5
// /* GL types for handling large vertex buffer objects */
// typedef ptrdiff_t GLintptr;
// typedef ptrdiff_t GLsizeiptr;
// #endif
// 
// #ifndef GL_ARB_vertex_buffer_object
// /* GL types for handling large vertex buffer objects */
// typedef ptrdiff_t GLintptrARB;
// typedef ptrdiff_t GLsizeiptrARB;
// #endif
// 
// #ifndef GL_ARB_shader_objects
// /* GL types for program/shader text and shader object handles */
// typedef char GLcharARB;
// typedef unsigned int GLhandleARB;
// #endif
// 
// /* GL type for "half" precision (s10e5) float data in host memory */
// #ifndef GL_ARB_half_float_pixel
// typedef unsigned short GLhalfARB;
// #endif
// 
// #ifndef GL_NV_half_float
// typedef unsigned short GLhalfNV;
// #endif
// 
// #ifndef GLEXT_64_TYPES_DEFINED
// /* This code block is duplicated in glxext.h, so must be protected */
// #define GLEXT_64_TYPES_DEFINED
// /* Define int32_t, int64_t, and uint64_t types for UST/MSC */
// /* (as used in the GL_EXT_timer_query extension). */
// #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
// #include <inttypes.h>
// #elif defined(__sun__) || defined(__digital__)
// #include <inttypes.h>
// #if defined(__STDC__)
// #if defined(__arch64__) || defined(_LP64)
// typedef long int int64_t;
// typedef unsigned long int uint64_t;
// #else
// typedef long long int int64_t;
// typedef unsigned long long int uint64_t;
// #endif /* __arch64__ */
// #endif /* __STDC__ */
// #elif defined( __VMS ) || defined(__sgi)
// #include <inttypes.h>
// #elif defined(__SCO__) || defined(__USLC__)
// #include <stdint.h>
// #elif defined(__UNIXOS2__) || defined(__SOL64__)
// typedef long int int32_t;
// typedef long long int int64_t;
// typedef unsigned long long int uint64_t;
// #elif defined(_WIN32) && defined(__GNUC__)
// #include <stdint.h>
// #elif defined(_WIN32)
// typedef __int32 int32_t;
// typedef __int64 int64_t;
// typedef unsigned __int64 uint64_t;
// #else
// /* Fallback if nothing above works */
// #include <inttypes.h>
// #endif
// #endif
// 
// #ifndef GL_EXT_timer_query
// typedef int64_t GLint64EXT;
// typedef uint64_t GLuint64EXT;
// #endif
// 
// #ifndef GL_ARB_sync
// typedef int64_t GLint64;
// typedef uint64_t GLuint64;
// typedef struct __GLsync *GLsync;
// #endif
// 
// #ifndef GL_ARB_cl_event
// /* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */
// struct _cl_context;
// struct _cl_event;
// #endif
// 
// #ifndef GL_ARB_debug_output
// typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
// #endif
// 
// #ifndef GL_AMD_debug_output
// typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
// #endif
// 
// #ifndef GL_KHR_debug
// typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
// #endif
// 
// #ifndef GL_NV_vdpau_interop
// typedef GLintptr GLvdpauSurfaceNV;
// #endif
// 
// #ifdef _WIN32
// static HMODULE opengl32 = NULL;
// #endif
// 
// static void* goglGetProcAddress(const char* name) { 
// #ifdef __APPLE__
// 	return dlsym(RTLD_DEFAULT, name);
// #elif _WIN32
// 	void* pf = wglGetProcAddress((LPCSTR)name);
// 	if(pf) {
// 		return pf;
// 	}
// 	if(opengl32 == NULL) {
// 		opengl32 = LoadLibraryA("opengl32.dll");
// 	}
// 	return GetProcAddress(opengl32, (LPCSTR)name);
// #else
// 	return glXGetProcAddress((const GLubyte*)name);
// #endif
// }
// 
// //  ARB_ES2_compatibility
// void (APIENTRYP ptrglReleaseShaderCompiler)();
// void (APIENTRYP ptrglShaderBinary)(GLsizei count, GLuint* shaders, GLenum binaryformat, GLvoid* binary, GLsizei length);
// void (APIENTRYP ptrglGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
// void (APIENTRYP ptrglDepthRangef)(GLfloat n, GLfloat f);
// void (APIENTRYP ptrglClearDepthf)(GLfloat d);
// //  ARB_base_instance
// void (APIENTRYP ptrglDrawArraysInstancedBaseInstance)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
// void (APIENTRYP ptrglDrawElementsInstancedBaseInstance)(GLenum mode, GLsizei count, GLenum type, void* indices, GLsizei instancecount, GLuint baseinstance);
// void (APIENTRYP ptrglDrawElementsInstancedBaseVertexBaseInstance)(GLenum mode, GLsizei count, GLenum type, void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
// //  ARB_blend_func_extended
// void (APIENTRYP ptrglBindFragDataLocationIndexed)(GLuint program, GLuint colorNumber, GLuint index, GLchar* name);
// GLint (APIENTRYP ptrglGetFragDataIndex)(GLuint program, GLchar* name);
// //  ARB_cl_event
// GLsync (APIENTRYP ptrglCreateSyncFromCLeventARB)(struct _cl_context * context, struct _cl_event * event, GLbitfield flags);
// //  ARB_clear_buffer_object
// void (APIENTRYP ptrglClearBufferData)(GLenum target, GLenum internalformat, GLenum format, GLenum type, void* data);
// void (APIENTRYP ptrglClearBufferSubData)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, void* data);
// void (APIENTRYP ptrglClearNamedBufferDataEXT)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, void* data);
// void (APIENTRYP ptrglClearNamedBufferSubDataEXT)(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, void* data);
// //  ARB_color_buffer_float
// void (APIENTRYP ptrglClampColorARB)(GLenum target, GLenum clamp);
// //  ARB_compute_shader
// void (APIENTRYP ptrglDispatchCompute)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
// void (APIENTRYP ptrglDispatchComputeIndirect)(GLintptr indirect);
// //  ARB_copy_buffer
// void (APIENTRYP ptrglCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
// //  ARB_copy_image
// void (APIENTRYP ptrglCopyImageSubData)(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);
// //  ARB_debug_output
// void (APIENTRYP ptrglDebugMessageControlARB)(GLenum source, GLenum type, GLenum severity, GLsizei count, GLuint* ids, GLboolean enabled);
// void (APIENTRYP ptrglDebugMessageInsertARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, GLchar* buf);
// void (APIENTRYP ptrglDebugMessageCallbackARB)(GLDEBUGPROCARB callback, GLvoid* userParam);
// GLuint (APIENTRYP ptrglGetDebugMessageLogARB)(GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog);
// //  ARB_draw_buffers
// void (APIENTRYP ptrglDrawBuffersARB)(GLsizei n, GLenum* bufs);
// //  ARB_draw_buffers_blend
// void (APIENTRYP ptrglBlendEquationiARB)(GLuint buf, GLenum mode);
// void (APIENTRYP ptrglBlendEquationSeparateiARB)(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
// void (APIENTRYP ptrglBlendFunciARB)(GLuint buf, GLenum src, GLenum dst);
// void (APIENTRYP ptrglBlendFuncSeparateiARB)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
// //  ARB_draw_elements_base_vertex
// void (APIENTRYP ptrglDrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex);
// void (APIENTRYP ptrglDrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex);
// void (APIENTRYP ptrglDrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei instancecount, GLint basevertex);
// void (APIENTRYP ptrglMultiDrawElementsBaseVertex)(GLenum mode, GLsizei* count, GLenum type, GLvoid* const* indices, GLsizei drawcount, GLint* basevertex);
// //  ARB_draw_indirect
// void (APIENTRYP ptrglDrawArraysIndirect)(GLenum mode, GLvoid* indirect);
// void (APIENTRYP ptrglDrawElementsIndirect)(GLenum mode, GLenum type, GLvoid* indirect);
// //  ARB_draw_instanced
// void (APIENTRYP ptrglDrawArraysInstancedARB)(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
// void (APIENTRYP ptrglDrawElementsInstancedARB)(GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount);
// //  ARB_framebuffer_no_attachments
// void (APIENTRYP ptrglFramebufferParameteri)(GLenum target, GLenum pname, GLint param);
// void (APIENTRYP ptrglGetFramebufferParameteriv)(GLenum target, GLenum pname, GLint* params);
// void (APIENTRYP ptrglNamedFramebufferParameteriEXT)(GLuint framebuffer, GLenum pname, GLint param);
// void (APIENTRYP ptrglGetNamedFramebufferParameterivEXT)(GLuint framebuffer, GLenum pname, GLint* params);
// //  ARB_framebuffer_object
// GLboolean (APIENTRYP ptrglIsRenderbuffer)(GLuint renderbuffer);
// void (APIENTRYP ptrglBindRenderbuffer)(GLenum target, GLuint renderbuffer);
// void (APIENTRYP ptrglDeleteRenderbuffers)(GLsizei n, GLuint* renderbuffers);
// void (APIENTRYP ptrglGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);
// void (APIENTRYP ptrglRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
// void (APIENTRYP ptrglGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
// GLboolean (APIENTRYP ptrglIsFramebuffer)(GLuint framebuffer);
// void (APIENTRYP ptrglBindFramebuffer)(GLenum target, GLuint framebuffer);
// void (APIENTRYP ptrglDeleteFramebuffers)(GLsizei n, GLuint* framebuffers);
// void (APIENTRYP ptrglGenFramebuffers)(GLsizei n, GLuint* framebuffers);
// GLenum (APIENTRYP ptrglCheckFramebufferStatus)(GLenum target);
// void (APIENTRYP ptrglFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
// void (APIENTRYP ptrglFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
// void (APIENTRYP ptrglFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
// void (APIENTRYP ptrglFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
// void (APIENTRYP ptrglGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGenerateMipmap)(GLenum target);
// void (APIENTRYP ptrglBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
// void (APIENTRYP ptrglRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
// void (APIENTRYP ptrglFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
// //  ARB_geometry_shader4
// void (APIENTRYP ptrglProgramParameteriARB)(GLuint program, GLenum pname, GLint value);
// void (APIENTRYP ptrglFramebufferTextureARB)(GLenum target, GLenum attachment, GLuint texture, GLint level);
// void (APIENTRYP ptrglFramebufferTextureLayerARB)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
// void (APIENTRYP ptrglFramebufferTextureFaceARB)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);
// //  ARB_get_program_binary
// void (APIENTRYP ptrglGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary);
// void (APIENTRYP ptrglProgramBinary)(GLuint program, GLenum binaryFormat, GLvoid* binary, GLsizei length);
// void (APIENTRYP ptrglProgramParameteri)(GLuint program, GLenum pname, GLint value);
// //  ARB_gpu_shader_fp64
// void (APIENTRYP ptrglUniform1d)(GLint location, GLdouble x);
// void (APIENTRYP ptrglUniform2d)(GLint location, GLdouble x, GLdouble y);
// void (APIENTRYP ptrglUniform3d)(GLint location, GLdouble x, GLdouble y, GLdouble z);
// void (APIENTRYP ptrglUniform4d)(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
// void (APIENTRYP ptrglUniform1dv)(GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglUniform2dv)(GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglUniform3dv)(GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglUniform4dv)(GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix2dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix3dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix4dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix2x3dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix2x4dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix3x2dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix3x4dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix4x2dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglUniformMatrix4x3dv)(GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglGetUniformdv)(GLuint program, GLint location, GLdouble* params);
// //  ARB_instanced_arrays
// void (APIENTRYP ptrglVertexAttribDivisorARB)(GLuint index, GLuint divisor);
// //  ARB_internalformat_query
// void (APIENTRYP ptrglGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params);
// //  ARB_internalformat_query2
// void (APIENTRYP ptrglGetInternalformati64v)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params);
// //  ARB_invalidate_subdata
// void (APIENTRYP ptrglInvalidateTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
// void (APIENTRYP ptrglInvalidateTexImage)(GLuint texture, GLint level);
// void (APIENTRYP ptrglInvalidateBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr length);
// void (APIENTRYP ptrglInvalidateBufferData)(GLuint buffer);
// void (APIENTRYP ptrglInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, GLenum* attachments);
// void (APIENTRYP ptrglInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height);
// //  ARB_map_buffer_range
// GLvoid* (APIENTRYP ptrglMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
// void (APIENTRYP ptrglFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
// //  ARB_matrix_palette
// void (APIENTRYP ptrglCurrentPaletteMatrixARB)(GLint index);
// void (APIENTRYP ptrglMatrixIndexubvARB)(GLint size, GLubyte* indices);
// void (APIENTRYP ptrglMatrixIndexusvARB)(GLint size, GLushort* indices);
// void (APIENTRYP ptrglMatrixIndexuivARB)(GLint size, GLuint* indices);
// void (APIENTRYP ptrglMatrixIndexPointerARB)(GLint size, GLenum type, GLsizei stride, GLvoid* pointer);
// //  ARB_multi_draw_indirect
// void (APIENTRYP ptrglMultiDrawArraysIndirect)(GLenum mode, void* indirect, GLsizei drawcount, GLsizei stride);
// void (APIENTRYP ptrglMultiDrawElementsIndirect)(GLenum mode, GLenum type, void* indirect, GLsizei drawcount, GLsizei stride);
// //  ARB_multisample
// void (APIENTRYP ptrglSampleCoverageARB)(GLfloat value, GLboolean invert);
// //  ARB_multitexture
// void (APIENTRYP ptrglActiveTextureARB)(GLenum texture);
// void (APIENTRYP ptrglClientActiveTextureARB)(GLenum texture);
// void (APIENTRYP ptrglMultiTexCoord1dARB)(GLenum target, GLdouble s);
// void (APIENTRYP ptrglMultiTexCoord1dvARB)(GLenum target, GLdouble* v);
// void (APIENTRYP ptrglMultiTexCoord1fARB)(GLenum target, GLfloat s);
// void (APIENTRYP ptrglMultiTexCoord1fvARB)(GLenum target, GLfloat* v);
// void (APIENTRYP ptrglMultiTexCoord1iARB)(GLenum target, GLint s);
// void (APIENTRYP ptrglMultiTexCoord1ivARB)(GLenum target, GLint* v);
// void (APIENTRYP ptrglMultiTexCoord1sARB)(GLenum target, GLshort s);
// void (APIENTRYP ptrglMultiTexCoord1svARB)(GLenum target, GLshort* v);
// void (APIENTRYP ptrglMultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t);
// void (APIENTRYP ptrglMultiTexCoord2dvARB)(GLenum target, GLdouble* v);
// void (APIENTRYP ptrglMultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t);
// void (APIENTRYP ptrglMultiTexCoord2fvARB)(GLenum target, GLfloat* v);
// void (APIENTRYP ptrglMultiTexCoord2iARB)(GLenum target, GLint s, GLint t);
// void (APIENTRYP ptrglMultiTexCoord2ivARB)(GLenum target, GLint* v);
// void (APIENTRYP ptrglMultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t);
// void (APIENTRYP ptrglMultiTexCoord2svARB)(GLenum target, GLshort* v);
// void (APIENTRYP ptrglMultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
// void (APIENTRYP ptrglMultiTexCoord3dvARB)(GLenum target, GLdouble* v);
// void (APIENTRYP ptrglMultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
// void (APIENTRYP ptrglMultiTexCoord3fvARB)(GLenum target, GLfloat* v);
// void (APIENTRYP ptrglMultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r);
// void (APIENTRYP ptrglMultiTexCoord3ivARB)(GLenum target, GLint* v);
// void (APIENTRYP ptrglMultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r);
// void (APIENTRYP ptrglMultiTexCoord3svARB)(GLenum target, GLshort* v);
// void (APIENTRYP ptrglMultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
// void (APIENTRYP ptrglMultiTexCoord4dvARB)(GLenum target, GLdouble* v);
// void (APIENTRYP ptrglMultiTexCoord4fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
// void (APIENTRYP ptrglMultiTexCoord4fvARB)(GLenum target, GLfloat* v);
// void (APIENTRYP ptrglMultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q);
// void (APIENTRYP ptrglMultiTexCoord4ivARB)(GLenum target, GLint* v);
// void (APIENTRYP ptrglMultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
// void (APIENTRYP ptrglMultiTexCoord4svARB)(GLenum target, GLshort* v);
// //  ARB_occlusion_query
// void (APIENTRYP ptrglGenQueriesARB)(GLsizei n, GLuint* ids);
// void (APIENTRYP ptrglDeleteQueriesARB)(GLsizei n, GLuint* ids);
// GLboolean (APIENTRYP ptrglIsQueryARB)(GLuint id);
// void (APIENTRYP ptrglBeginQueryARB)(GLenum target, GLuint id);
// void (APIENTRYP ptrglEndQueryARB)(GLenum target);
// void (APIENTRYP ptrglGetQueryivARB)(GLenum target, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetQueryObjectivARB)(GLuint id, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetQueryObjectuivARB)(GLuint id, GLenum pname, GLuint* params);
// //  ARB_point_parameters
// void (APIENTRYP ptrglPointParameterfARB)(GLenum pname, GLfloat param);
// void (APIENTRYP ptrglPointParameterfvARB)(GLenum pname, GLfloat* params);
// //  ARB_program_interface_query
// void (APIENTRYP ptrglGetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint* params);
// GLuint (APIENTRYP ptrglGetProgramResourceIndex)(GLuint program, GLenum programInterface, GLchar* name);
// void (APIENTRYP ptrglGetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name);
// void (APIENTRYP ptrglGetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params);
// GLint (APIENTRYP ptrglGetProgramResourceLocation)(GLuint program, GLenum programInterface, GLchar* name);
// GLint (APIENTRYP ptrglGetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, GLchar* name);
// //  ARB_provoking_vertex
// void (APIENTRYP ptrglProvokingVertex)(GLenum mode);
// //  ARB_robustness
// GLenum (APIENTRYP ptrglGetGraphicsResetStatusARB)();
// void (APIENTRYP ptrglGetnMapdvARB)(GLenum target, GLenum query, GLsizei bufSize, GLdouble* v);
// void (APIENTRYP ptrglGetnMapfvARB)(GLenum target, GLenum query, GLsizei bufSize, GLfloat* v);
// void (APIENTRYP ptrglGetnMapivARB)(GLenum target, GLenum query, GLsizei bufSize, GLint* v);
// void (APIENTRYP ptrglGetnPixelMapfvARB)(GLenum map, GLsizei bufSize, GLfloat* values);
// void (APIENTRYP ptrglGetnPixelMapuivARB)(GLenum map, GLsizei bufSize, GLuint* values);
// void (APIENTRYP ptrglGetnPixelMapusvARB)(GLenum map, GLsizei bufSize, GLushort* values);
// void (APIENTRYP ptrglGetnPolygonStippleARB)(GLsizei bufSize, GLubyte* pattern);
// void (APIENTRYP ptrglGetnColorTableARB)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid* table);
// void (APIENTRYP ptrglGetnConvolutionFilterARB)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid* image);
// void (APIENTRYP ptrglGetnSeparableFilterARB)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid* row, GLsizei columnBufSize, GLvoid* column, GLvoid* span);
// void (APIENTRYP ptrglGetnHistogramARB)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid* values);
// void (APIENTRYP ptrglGetnMinmaxARB)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid* values);
// void (APIENTRYP ptrglGetnTexImageARB)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid* img);
// void (APIENTRYP ptrglReadnPixelsARB)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid* data);
// void (APIENTRYP ptrglGetnCompressedTexImageARB)(GLenum target, GLint lod, GLsizei bufSize, GLvoid* img);
// void (APIENTRYP ptrglGetnUniformfvARB)(GLuint program, GLint location, GLsizei bufSize, GLfloat* params);
// void (APIENTRYP ptrglGetnUniformivARB)(GLuint program, GLint location, GLsizei bufSize, GLint* params);
// void (APIENTRYP ptrglGetnUniformuivARB)(GLuint program, GLint location, GLsizei bufSize, GLuint* params);
// void (APIENTRYP ptrglGetnUniformdvARB)(GLuint program, GLint location, GLsizei bufSize, GLdouble* params);
// //  ARB_sample_shading
// void (APIENTRYP ptrglMinSampleShadingARB)(GLfloat value);
// //  ARB_sampler_objects
// void (APIENTRYP ptrglGenSamplers)(GLsizei count, GLuint* samplers);
// void (APIENTRYP ptrglDeleteSamplers)(GLsizei count, GLuint* samplers);
// GLboolean (APIENTRYP ptrglIsSampler)(GLuint sampler);
// void (APIENTRYP ptrglBindSampler)(GLuint unit, GLuint sampler);
// void (APIENTRYP ptrglSamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
// void (APIENTRYP ptrglSamplerParameteriv)(GLuint sampler, GLenum pname, GLint* param);
// void (APIENTRYP ptrglSamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
// void (APIENTRYP ptrglSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat* param);
// void (APIENTRYP ptrglSamplerParameterIiv)(GLuint sampler, GLenum pname, GLint* param);
// void (APIENTRYP ptrglSamplerParameterIuiv)(GLuint sampler, GLenum pname, GLuint* param);
// void (APIENTRYP ptrglGetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetSamplerParameterIiv)(GLuint sampler, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat* params);
// void (APIENTRYP ptrglGetSamplerParameterIuiv)(GLuint sampler, GLenum pname, GLuint* params);
// //  ARB_separate_shader_objects
// void (APIENTRYP ptrglUseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program);
// void (APIENTRYP ptrglActiveShaderProgram)(GLuint pipeline, GLuint program);
// GLuint (APIENTRYP ptrglCreateShaderProgramv)(GLenum type, GLsizei count, GLchar* const* strings);
// void (APIENTRYP ptrglBindProgramPipeline)(GLuint pipeline);
// void (APIENTRYP ptrglDeleteProgramPipelines)(GLsizei n, GLuint* pipelines);
// void (APIENTRYP ptrglGenProgramPipelines)(GLsizei n, GLuint* pipelines);
// GLboolean (APIENTRYP ptrglIsProgramPipeline)(GLuint pipeline);
// void (APIENTRYP ptrglGetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint* params);
// void (APIENTRYP ptrglProgramUniform1i)(GLuint program, GLint location, GLint v0);
// void (APIENTRYP ptrglProgramUniform1iv)(GLuint program, GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglProgramUniform1f)(GLuint program, GLint location, GLfloat v0);
// void (APIENTRYP ptrglProgramUniform1fv)(GLuint program, GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglProgramUniform1d)(GLuint program, GLint location, GLdouble v0);
// void (APIENTRYP ptrglProgramUniform1dv)(GLuint program, GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglProgramUniform1ui)(GLuint program, GLint location, GLuint v0);
// void (APIENTRYP ptrglProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, GLuint* value);
// void (APIENTRYP ptrglProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1);
// void (APIENTRYP ptrglProgramUniform2iv)(GLuint program, GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
// void (APIENTRYP ptrglProgramUniform2fv)(GLuint program, GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglProgramUniform2d)(GLuint program, GLint location, GLdouble v0, GLdouble v1);
// void (APIENTRYP ptrglProgramUniform2dv)(GLuint program, GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1);
// void (APIENTRYP ptrglProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, GLuint* value);
// void (APIENTRYP ptrglProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
// void (APIENTRYP ptrglProgramUniform3iv)(GLuint program, GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
// void (APIENTRYP ptrglProgramUniform3fv)(GLuint program, GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglProgramUniform3d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
// void (APIENTRYP ptrglProgramUniform3dv)(GLuint program, GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
// void (APIENTRYP ptrglProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, GLuint* value);
// void (APIENTRYP ptrglProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
// void (APIENTRYP ptrglProgramUniform4iv)(GLuint program, GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
// void (APIENTRYP ptrglProgramUniform4fv)(GLuint program, GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglProgramUniform4d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
// void (APIENTRYP ptrglProgramUniform4dv)(GLuint program, GLint location, GLsizei count, GLdouble* value);
// void (APIENTRYP ptrglProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
// void (APIENTRYP ptrglProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, GLuint* value);
// void (APIENTRYP ptrglProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglProgramUniformMatrix2x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix3x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix2x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix4x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix3x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglProgramUniformMatrix4x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value);
// void (APIENTRYP ptrglValidateProgramPipeline)(GLuint pipeline);
// void (APIENTRYP ptrglGetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
// //  ARB_shader_atomic_counters
// void (APIENTRYP ptrglGetActiveAtomicCounterBufferiv)(GLuint program, GLuint bufferIndex, GLenum pname, GLint* params);
// //  ARB_shader_image_load_store
// void (APIENTRYP ptrglBindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
// void (APIENTRYP ptrglMemoryBarrier)(GLbitfield barriers);
// //  ARB_shader_objects
// void (APIENTRYP ptrglDeleteObjectARB)(GLhandleARB obj);
// GLhandleARB (APIENTRYP ptrglGetHandleARB)(GLenum pname);
// void (APIENTRYP ptrglDetachObjectARB)(GLhandleARB containerObj, GLhandleARB attachedObj);
// GLhandleARB (APIENTRYP ptrglCreateShaderObjectARB)(GLenum shaderType);
// void (APIENTRYP ptrglShaderSourceARB)(GLhandleARB shaderObj, GLsizei count, GLcharARB** string, GLint* length);
// void (APIENTRYP ptrglCompileShaderARB)(GLhandleARB shaderObj);
// GLhandleARB (APIENTRYP ptrglCreateProgramObjectARB)();
// void (APIENTRYP ptrglAttachObjectARB)(GLhandleARB containerObj, GLhandleARB obj);
// void (APIENTRYP ptrglLinkProgramARB)(GLhandleARB programObj);
// void (APIENTRYP ptrglUseProgramObjectARB)(GLhandleARB programObj);
// void (APIENTRYP ptrglValidateProgramARB)(GLhandleARB programObj);
// void (APIENTRYP ptrglUniform1fARB)(GLint location, GLfloat v0);
// void (APIENTRYP ptrglUniform2fARB)(GLint location, GLfloat v0, GLfloat v1);
// void (APIENTRYP ptrglUniform3fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
// void (APIENTRYP ptrglUniform4fARB)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
// void (APIENTRYP ptrglUniform1iARB)(GLint location, GLint v0);
// void (APIENTRYP ptrglUniform2iARB)(GLint location, GLint v0, GLint v1);
// void (APIENTRYP ptrglUniform3iARB)(GLint location, GLint v0, GLint v1, GLint v2);
// void (APIENTRYP ptrglUniform4iARB)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
// void (APIENTRYP ptrglUniform1fvARB)(GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglUniform2fvARB)(GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglUniform3fvARB)(GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglUniform4fvARB)(GLint location, GLsizei count, GLfloat* value);
// void (APIENTRYP ptrglUniform1ivARB)(GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglUniform2ivARB)(GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglUniform3ivARB)(GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglUniform4ivARB)(GLint location, GLsizei count, GLint* value);
// void (APIENTRYP ptrglUniformMatrix2fvARB)(GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglUniformMatrix3fvARB)(GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglUniformMatrix4fvARB)(GLint location, GLsizei count, GLboolean transpose, GLfloat* value);
// void (APIENTRYP ptrglGetObjectParameterfvARB)(GLhandleARB obj, GLenum pname, GLfloat* params);
// void (APIENTRYP ptrglGetObjectParameterivARB)(GLhandleARB obj, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetInfoLogARB)(GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog);
// void (APIENTRYP ptrglGetAttachedObjectsARB)(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj);
// GLint (APIENTRYP ptrglGetUniformLocationARB)(GLhandleARB programObj, GLcharARB* name);
// void (APIENTRYP ptrglGetActiveUniformARB)(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name);
// void (APIENTRYP ptrglGetUniformfvARB)(GLhandleARB programObj, GLint location, GLfloat* params);
// void (APIENTRYP ptrglGetUniformivARB)(GLhandleARB programObj, GLint location, GLint* params);
// void (APIENTRYP ptrglGetShaderSourceARB)(GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* source);
// //  ARB_shader_storage_buffer_object
// void (APIENTRYP ptrglShaderStorageBlockBinding)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
// //  ARB_shader_subroutine
// GLint (APIENTRYP ptrglGetSubroutineUniformLocation)(GLuint program, GLenum shadertype, GLchar* name);
// GLuint (APIENTRYP ptrglGetSubroutineIndex)(GLuint program, GLenum shadertype, GLchar* name);
// void (APIENTRYP ptrglGetActiveSubroutineUniformiv)(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values);
// void (APIENTRYP ptrglGetActiveSubroutineUniformName)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name);
// void (APIENTRYP ptrglGetActiveSubroutineName)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name);
// void (APIENTRYP ptrglUniformSubroutinesuiv)(GLenum shadertype, GLsizei count, GLuint* indices);
// void (APIENTRYP ptrglGetUniformSubroutineuiv)(GLenum shadertype, GLint location, GLuint* params);
// void (APIENTRYP ptrglGetProgramStageiv)(GLuint program, GLenum shadertype, GLenum pname, GLint* values);
// //  ARB_shading_language_include
// void (APIENTRYP ptrglNamedStringARB)(GLenum type, GLint namelen, GLchar* name, GLint stringlen, GLchar* string);
// void (APIENTRYP ptrglDeleteNamedStringARB)(GLint namelen, GLchar* name);
// void (APIENTRYP ptrglCompileShaderIncludeARB)(GLuint shader, GLsizei count, GLchar** path, GLint* length);
// GLboolean (APIENTRYP ptrglIsNamedStringARB)(GLint namelen, GLchar* name);
// void (APIENTRYP ptrglGetNamedStringARB)(GLint namelen, GLchar* name, GLsizei bufSize, GLint* stringlen, GLchar* string);
// void (APIENTRYP ptrglGetNamedStringivARB)(GLint namelen, GLchar* name, GLenum pname, GLint* params);
// //  ARB_sync
// GLsync (APIENTRYP ptrglFenceSync)(GLenum condition, GLbitfield flags);
// GLboolean (APIENTRYP ptrglIsSync)(GLsync sync);
// void (APIENTRYP ptrglDeleteSync)(GLsync sync);
// GLenum (APIENTRYP ptrglClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
// void (APIENTRYP ptrglWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
// void (APIENTRYP ptrglGetInteger64v)(GLenum pname, GLint64* params);
// void (APIENTRYP ptrglGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values);
// //  ARB_tessellation_shader
// void (APIENTRYP ptrglPatchParameteri)(GLenum pname, GLint value);
// void (APIENTRYP ptrglPatchParameterfv)(GLenum pname, GLfloat* values);
// //  ARB_texture_buffer_object
// void (APIENTRYP ptrglTexBufferARB)(GLenum target, GLenum internalformat, GLuint buffer);
// //  ARB_texture_buffer_range
// void (APIENTRYP ptrglTexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
// void (APIENTRYP ptrglTextureBufferRangeEXT)(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
// //  ARB_texture_compression
// void (APIENTRYP ptrglCompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglCompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglCompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglCompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglCompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglCompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* data);
// void (APIENTRYP ptrglGetCompressedTexImageARB)(GLenum target, GLint level, GLvoid* img);
// //  ARB_texture_multisample
// void (APIENTRYP ptrglTexImage2DMultisample)(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
// void (APIENTRYP ptrglTexImage3DMultisample)(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
// void (APIENTRYP ptrglGetMultisamplefv)(GLenum pname, GLuint index, GLfloat* val);
// void (APIENTRYP ptrglSampleMaski)(GLuint index, GLbitfield mask);
// //  ARB_texture_storage
// void (APIENTRYP ptrglTexStorage1D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
// void (APIENTRYP ptrglTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
// void (APIENTRYP ptrglTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
// void (APIENTRYP ptrglTextureStorage1DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
// void (APIENTRYP ptrglTextureStorage2DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
// void (APIENTRYP ptrglTextureStorage3DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
// //  ARB_texture_storage_multisample
// void (APIENTRYP ptrglTexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
// void (APIENTRYP ptrglTexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
// void (APIENTRYP ptrglTextureStorage2DMultisampleEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
// void (APIENTRYP ptrglTextureStorage3DMultisampleEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
// //  ARB_texture_view
// void (APIENTRYP ptrglTextureView)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
// //  ARB_timer_query
// void (APIENTRYP ptrglQueryCounter)(GLuint id, GLenum target);
// void (APIENTRYP ptrglGetQueryObjecti64v)(GLuint id, GLenum pname, GLint64* params);
// void (APIENTRYP ptrglGetQueryObjectui64v)(GLuint id, GLenum pname, GLuint64* params);
// //  ARB_transform_feedback2
// void (APIENTRYP ptrglBindTransformFeedback)(GLenum target, GLuint id);
// void (APIENTRYP ptrglDeleteTransformFeedbacks)(GLsizei n, GLuint* ids);
// void (APIENTRYP ptrglGenTransformFeedbacks)(GLsizei n, GLuint* ids);
// GLboolean (APIENTRYP ptrglIsTransformFeedback)(GLuint id);
// void (APIENTRYP ptrglPauseTransformFeedback)();
// void (APIENTRYP ptrglResumeTransformFeedback)();
// void (APIENTRYP ptrglDrawTransformFeedback)(GLenum mode, GLuint id);
// //  ARB_transform_feedback3
// void (APIENTRYP ptrglDrawTransformFeedbackStream)(GLenum mode, GLuint id, GLuint stream);
// void (APIENTRYP ptrglBeginQueryIndexed)(GLenum target, GLuint index, GLuint id);
// void (APIENTRYP ptrglEndQueryIndexed)(GLenum target, GLuint index);
// void (APIENTRYP ptrglGetQueryIndexediv)(GLenum target, GLuint index, GLenum pname, GLint* params);
// //  ARB_transform_feedback_instanced
// void (APIENTRYP ptrglDrawTransformFeedbackInstanced)(GLenum mode, GLuint id, GLsizei instancecount);
// void (APIENTRYP ptrglDrawTransformFeedbackStreamInstanced)(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
// //  ARB_transpose_matrix
// void (APIENTRYP ptrglLoadTransposeMatrixfARB)(GLfloat* m);
// void (APIENTRYP ptrglLoadTransposeMatrixdARB)(GLdouble* m);
// void (APIENTRYP ptrglMultTransposeMatrixfARB)(GLfloat* m);
// void (APIENTRYP ptrglMultTransposeMatrixdARB)(GLdouble* m);
// //  ARB_uniform_buffer_object
// void (APIENTRYP ptrglGetUniformIndices)(GLuint program, GLsizei uniformCount, GLchar* const* uniformNames, GLuint* uniformIndices);
// void (APIENTRYP ptrglGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, GLuint* uniformIndices, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName);
// GLuint (APIENTRYP ptrglGetUniformBlockIndex)(GLuint program, GLchar* uniformBlockName);
// void (APIENTRYP ptrglGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName);
// void (APIENTRYP ptrglUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
// //  ARB_vertex_array_object
// void (APIENTRYP ptrglBindVertexArray)(GLuint array);
// void (APIENTRYP ptrglDeleteVertexArrays)(GLsizei n, GLuint* arrays);
// void (APIENTRYP ptrglGenVertexArrays)(GLsizei n, GLuint* arrays);
// GLboolean (APIENTRYP ptrglIsVertexArray)(GLuint array);
// //  ARB_vertex_attrib_64bit
// void (APIENTRYP ptrglVertexAttribL1d)(GLuint index, GLdouble x);
// void (APIENTRYP ptrglVertexAttribL2d)(GLuint index, GLdouble x, GLdouble y);
// void (APIENTRYP ptrglVertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
// void (APIENTRYP ptrglVertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
// void (APIENTRYP ptrglVertexAttribL1dv)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttribL2dv)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttribL3dv)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttribL4dv)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttribLPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, GLvoid* pointer);
// void (APIENTRYP ptrglGetVertexAttribLdv)(GLuint index, GLenum pname, GLdouble* params);
// //  ARB_vertex_attrib_binding
// void (APIENTRYP ptrglBindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
// void (APIENTRYP ptrglVertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexAttribLFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexAttribBinding)(GLuint attribindex, GLuint bindingindex);
// void (APIENTRYP ptrglVertexBindingDivisor)(GLuint bindingindex, GLuint divisor);
// void (APIENTRYP ptrglVertexArrayBindVertexBufferEXT)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
// void (APIENTRYP ptrglVertexArrayVertexAttribFormatEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexArrayVertexAttribIFormatEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexArrayVertexAttribLFormatEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
// void (APIENTRYP ptrglVertexArrayVertexAttribBindingEXT)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
// void (APIENTRYP ptrglVertexArrayVertexBindingDivisorEXT)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
// //  ARB_vertex_blend
// void (APIENTRYP ptrglWeightbvARB)(GLint size, GLbyte* weights);
// void (APIENTRYP ptrglWeightsvARB)(GLint size, GLshort* weights);
// void (APIENTRYP ptrglWeightivARB)(GLint size, GLint* weights);
// void (APIENTRYP ptrglWeightfvARB)(GLint size, GLfloat* weights);
// void (APIENTRYP ptrglWeightdvARB)(GLint size, GLdouble* weights);
// void (APIENTRYP ptrglWeightubvARB)(GLint size, GLubyte* weights);
// void (APIENTRYP ptrglWeightusvARB)(GLint size, GLushort* weights);
// void (APIENTRYP ptrglWeightuivARB)(GLint size, GLuint* weights);
// void (APIENTRYP ptrglWeightPointerARB)(GLint size, GLenum type, GLsizei stride, GLvoid* pointer);
// void (APIENTRYP ptrglVertexBlendARB)(GLint count);
// //  ARB_vertex_buffer_object
// void (APIENTRYP ptrglBindBufferARB)(GLenum target, GLuint buffer);
// void (APIENTRYP ptrglDeleteBuffersARB)(GLsizei n, GLuint* buffers);
// void (APIENTRYP ptrglGenBuffersARB)(GLsizei n, GLuint* buffers);
// GLboolean (APIENTRYP ptrglIsBufferARB)(GLuint buffer);
// void (APIENTRYP ptrglBufferDataARB)(GLenum target, GLsizeiptrARB size, GLvoid* data, GLenum usage);
// void (APIENTRYP ptrglBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data);
// void (APIENTRYP ptrglGetBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data);
// GLvoid* (APIENTRYP ptrglMapBufferARB)(GLenum target, GLenum access);
// GLboolean (APIENTRYP ptrglUnmapBufferARB)(GLenum target);
// void (APIENTRYP ptrglGetBufferParameterivARB)(GLenum target, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetBufferPointervARB)(GLenum target, GLenum pname, GLvoid** params);
// //  ARB_vertex_program
// void (APIENTRYP ptrglVertexAttrib1dARB)(GLuint index, GLdouble x);
// void (APIENTRYP ptrglVertexAttrib1dvARB)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttrib1fARB)(GLuint index, GLfloat x);
// void (APIENTRYP ptrglVertexAttrib1fvARB)(GLuint index, GLfloat* v);
// void (APIENTRYP ptrglVertexAttrib1sARB)(GLuint index, GLshort x);
// void (APIENTRYP ptrglVertexAttrib1svARB)(GLuint index, GLshort* v);
// void (APIENTRYP ptrglVertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y);
// void (APIENTRYP ptrglVertexAttrib2dvARB)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y);
// void (APIENTRYP ptrglVertexAttrib2fvARB)(GLuint index, GLfloat* v);
// void (APIENTRYP ptrglVertexAttrib2sARB)(GLuint index, GLshort x, GLshort y);
// void (APIENTRYP ptrglVertexAttrib2svARB)(GLuint index, GLshort* v);
// void (APIENTRYP ptrglVertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
// void (APIENTRYP ptrglVertexAttrib3dvARB)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
// void (APIENTRYP ptrglVertexAttrib3fvARB)(GLuint index, GLfloat* v);
// void (APIENTRYP ptrglVertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z);
// void (APIENTRYP ptrglVertexAttrib3svARB)(GLuint index, GLshort* v);
// void (APIENTRYP ptrglVertexAttrib4NbvARB)(GLuint index, GLbyte* v);
// void (APIENTRYP ptrglVertexAttrib4NivARB)(GLuint index, GLint* v);
// void (APIENTRYP ptrglVertexAttrib4NsvARB)(GLuint index, GLshort* v);
// void (APIENTRYP ptrglVertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
// void (APIENTRYP ptrglVertexAttrib4NubvARB)(GLuint index, GLubyte* v);
// void (APIENTRYP ptrglVertexAttrib4NuivARB)(GLuint index, GLuint* v);
// void (APIENTRYP ptrglVertexAttrib4NusvARB)(GLuint index, GLushort* v);
// void (APIENTRYP ptrglVertexAttrib4bvARB)(GLuint index, GLbyte* v);
// void (APIENTRYP ptrglVertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
// void (APIENTRYP ptrglVertexAttrib4dvARB)(GLuint index, GLdouble* v);
// void (APIENTRYP ptrglVertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
// void (APIENTRYP ptrglVertexAttrib4fvARB)(GLuint index, GLfloat* v);
// void (APIENTRYP ptrglVertexAttrib4ivARB)(GLuint index, GLint* v);
// void (APIENTRYP ptrglVertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
// void (APIENTRYP ptrglVertexAttrib4svARB)(GLuint index, GLshort* v);
// void (APIENTRYP ptrglVertexAttrib4ubvARB)(GLuint index, GLubyte* v);
// void (APIENTRYP ptrglVertexAttrib4uivARB)(GLuint index, GLuint* v);
// void (APIENTRYP ptrglVertexAttrib4usvARB)(GLuint index, GLushort* v);
// void (APIENTRYP ptrglVertexAttribPointerARB)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid* pointer);
// void (APIENTRYP ptrglEnableVertexAttribArrayARB)(GLuint index);
// void (APIENTRYP ptrglDisableVertexAttribArrayARB)(GLuint index);
// void (APIENTRYP ptrglProgramStringARB)(GLenum target, GLenum format, GLsizei len, GLvoid* string);
// void (APIENTRYP ptrglBindProgramARB)(GLenum target, GLuint program);
// void (APIENTRYP ptrglDeleteProgramsARB)(GLsizei n, GLuint* programs);
// void (APIENTRYP ptrglGenProgramsARB)(GLsizei n, GLuint* programs);
// void (APIENTRYP ptrglProgramEnvParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
// void (APIENTRYP ptrglProgramEnvParameter4dvARB)(GLenum target, GLuint index, GLdouble* params);
// void (APIENTRYP ptrglProgramEnvParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
// void (APIENTRYP ptrglProgramEnvParameter4fvARB)(GLenum target, GLuint index, GLfloat* params);
// void (APIENTRYP ptrglProgramLocalParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
// void (APIENTRYP ptrglProgramLocalParameter4dvARB)(GLenum target, GLuint index, GLdouble* params);
// void (APIENTRYP ptrglProgramLocalParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
// void (APIENTRYP ptrglProgramLocalParameter4fvARB)(GLenum target, GLuint index, GLfloat* params);
// void (APIENTRYP ptrglGetProgramEnvParameterdvARB)(GLenum target, GLuint index, GLdouble* params);
// void (APIENTRYP ptrglGetProgramEnvParameterfvARB)(GLenum target, GLuint index, GLfloat* params);
// void (APIENTRYP ptrglGetProgramLocalParameterdvARB)(GLenum target, GLuint index, GLdouble* params);
// void (APIENTRYP ptrglGetProgramLocalParameterfvARB)(GLenum target, GLuint index, GLfloat* params);
// void (APIENTRYP ptrglGetProgramivARB)(GLenum target, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetProgramStringARB)(GLenum target, GLenum pname, GLvoid* string);
// void (APIENTRYP ptrglGetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble* params);
// void (APIENTRYP ptrglGetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat* params);
// void (APIENTRYP ptrglGetVertexAttribivARB)(GLuint index, GLenum pname, GLint* params);
// void (APIENTRYP ptrglGetVertexAttribPointervARB)(GLuint index, GLenum pname, GLvoid** pointer);
// GLboolean (APIENTRYP ptrglIsProgramARB)(GLuint program);
// //  ARB_vertex_shader
// void (APIENTRYP ptrglBindAttribLocationARB)(GLhandleARB programObj, GLuint index, GLcharARB* name);
// void (APIENTRYP ptrglGetActiveAttribARB)(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name);
// GLint (APIENTRYP ptrglGetAttribLocationARB)(GLhandleARB programObj, GLcharARB* name);
// //  ARB_vertex_type_2_10_10_10_rev
// void (APIENTRYP ptrglVertexP2ui)(GLenum type, GLuint value);
// void (APIENTRYP ptrglVertexP2uiv)(GLenum type, GLuint* value);
// void (APIENTRYP ptrglVertexP3ui)(GLenum type, GLuint value);
// void (APIENTRYP ptrglVertexP3uiv)(GLenum type, GLuint* value);
// void (APIENTRYP ptrglVertexP4ui)(GLenum type, GLuint value);
// void (APIENTRYP ptrglVertexP4uiv)(GLenum type, GLuint* value);
// void (APIENTRYP ptrglTexCoordP1ui)(GLenum type, GLuint coords);
// void (APIENTRYP ptrglTexCoordP1uiv)(GLenum type, GLuint* coords);
// void (APIENTRYP ptrglTexCoordP2ui)(GLenum type, GLuint coords);
// void (APIENTRYP ptrglTexCoordP2uiv)(GLenum type, GLuint* coords);
// void (APIENTRYP ptrglTexCoordP3ui)(GLenum type, GLuint coords);
// void (APIENTRYP ptrglTexCoordP3uiv)(GLenum type, GLuint* coords);
// void (APIENTRYP ptrglTexCoordP4ui)(GLenum type, GLuint coords);
// void (APIENTRYP ptrglTexCoordP4uiv)(GLenum type, GLuint* coords);
// void (APIENTRYP ptrglMultiTexCoordP1ui)(GLenum texture, GLenum type, GLuint coords);
// void (APIENTRYP ptrglMultiTexCoordP1uiv)(GLenum texture, GLenum type, GLuint* coords);
// void (APIENTRYP ptrglMultiTexCoordP2ui)(GLenum texture, GLenum type, GLuint coords);
// void (APIENTRYP ptrglMultiTexCoordP2uiv)(GLenum texture, GLenum type, GLuint* coords);
// void (APIENTRYP ptrglMultiTexCoordP3ui)(GLenum texture, GLenum type, GLuint coords);
// void (APIENTRYP ptrglMultiTexCoordP3uiv)(GLenum texture, GLenum type, GLuint* coords);
// void (APIENTRYP ptrglMultiTexCoordP4ui)(GLenum texture, GLenum type, GLuint coords);
// void (APIENTRYP ptrglMultiTexCoordP4uiv)(GLenum texture, GLenum type, GLuint* coords);
// void (APIENTRYP ptrglNormalP3ui)(GLenum type, GLuint coords);
// void (APIENTRYP ptrglNormalP3uiv)(GLenum type, GLuint* coords);
// void (APIENTRYP ptrglColorP3ui)(GLenum type, GLuint color);
// void (APIENTRYP ptrglColorP3uiv)(GLenum type, GLuint* color);
// void (APIENTRYP ptrglColorP4ui)(GLenum type, GLuint color);
// void (APIENTRYP ptrglColorP4uiv)(GLenum type, GLuint* color);
// void (APIENTRYP ptrglSecondaryColorP3ui)(GLenum type, GLuint color);
// void (APIENTRYP ptrglSecondaryColorP3uiv)(GLenum type, GLuint* color);
// void (APIENTRYP ptrglVertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
// void (APIENTRYP ptrglVertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized, GLuint* value);
// void (APIENTRYP ptrglVertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
// void (APIENTRYP ptrglVertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized, GLuint* value);
// void (APIENTRYP ptrglVertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
// void (APIENTRYP ptrglVertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized, GLuint* value);
// void (APIENTRYP ptrglVertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
// void (APIENTRYP ptrglVertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized, GLuint* value);
// //  ARB_viewport_array
// void (APIENTRYP ptrglViewportArrayv)(GLuint first, GLsizei count, GLfloat* v);
// void (APIENTRYP ptrglViewportIndexedf)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
// void (APIENTRYP ptrglViewportIndexedfv)(GLuint index, GLfloat* v);
// void (APIENTRYP ptrglScissorArrayv)(GLuint first, GLsizei count, GLint* v);
// void (APIENTRYP ptrglScissorIndexed)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
// void (APIENTRYP ptrglScissorIndexedv)(GLuint index, GLint* v);
// void (APIENTRYP ptrglDepthRangeArrayv)(GLuint first, GLsizei count, GLdouble* v);
// void (APIENTRYP ptrglDepthRangeIndexed)(GLuint index, GLdouble n, GLdouble f);
// void (APIENTRYP ptrglGetFloati_v)(GLenum target, GLuint index, GLfloat* data);
// void (APIENTRYP ptrglGetDoublei_v)(GLenum target, GLuint index, GLdouble* data);
// //  ARB_window_pos
// void (APIENTRYP ptrglWindowPos2dARB)(GLdouble x, GLdouble y);
// void (APIENTRYP ptrglWindowPos2dvARB)(GLdouble* v);
// void (APIENTRYP ptrglWindowPos2fARB)(GLfloat x, GLfloat y);
// void (APIENTRYP ptrglWindowPos2fvARB)(GLfloat* v);
// void (APIENTRYP ptrglWindowPos2iARB)(GLint x, GLint y);
// void (APIENTRYP ptrglWindowPos2ivARB)(GLint* v);
// void (APIENTRYP ptrglWindowPos2sARB)(GLshort x, GLshort y);
// void (APIENTRYP ptrglWindowPos2svARB)(GLshort* v);
// void (APIENTRYP ptrglWindowPos3dARB)(GLdouble x, GLdouble y, GLdouble z);
// void (APIENTRYP ptrglWindowPos3dvARB)(GLdouble* v);
// void (APIENTRYP ptrglWindowPos3fARB)(GLfloat x, GLfloat y, GLfloat z);
// void (APIENTRYP ptrglWindowPos3fvARB)(GLfloat* v);
// void (APIENTRYP ptrglWindowPos3iARB)(GLint x, GLint y, GLint z);
// void (APIENTRYP ptrglWindowPos3ivARB)(GLint* v);
// void (APIENTRYP ptrglWindowPos3sARB)(GLshort x, GLshort y, GLshort z);
// void (APIENTRYP ptrglWindowPos3svARB)(GLshort* v);
// 
// //  ARB_ES2_compatibility
// void goglReleaseShaderCompiler() {
// 	(*ptrglReleaseShaderCompiler)();
// }
// void goglShaderBinary(GLsizei count, GLuint* shaders, GLenum binaryformat, GLvoid* binary, GLsizei length) {
// 	(*ptrglShaderBinary)(count, shaders, binaryformat, binary, length);
// }
// void goglGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range_, GLint* precision) {
// 	(*ptrglGetShaderPrecisionFormat)(shadertype, precisiontype, range_, precision);
// }
// void goglDepthRangef(GLfloat n, GLfloat f) {
// 	(*ptrglDepthRangef)(n, f);
// }
// void goglClearDepthf(GLfloat d) {
// 	(*ptrglClearDepthf)(d);
// }
// //  ARB_base_instance
// void goglDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) {
// 	(*ptrglDrawArraysInstancedBaseInstance)(mode, first, count, instancecount, baseinstance);
// }
// void goglDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type_, void* indices, GLsizei instancecount, GLuint baseinstance) {
// 	(*ptrglDrawElementsInstancedBaseInstance)(mode, count, type_, indices, instancecount, baseinstance);
// }
// void goglDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type_, void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
// 	(*ptrglDrawElementsInstancedBaseVertexBaseInstance)(mode, count, type_, indices, instancecount, basevertex, baseinstance);
// }
// //  ARB_blend_func_extended
// void goglBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, GLchar* name) {
// 	(*ptrglBindFragDataLocationIndexed)(program, colorNumber, index, name);
// }
// GLint goglGetFragDataIndex(GLuint program, GLchar* name) {
// 	return (*ptrglGetFragDataIndex)(program, name);
// }
// //  ARB_cl_event
// GLsync goglCreateSyncFromCLeventARB(struct _cl_context * context, struct _cl_event * event, GLbitfield flags) {
// 	return (*ptrglCreateSyncFromCLeventARB)(context, event, flags);
// }
// //  ARB_clear_buffer_object
// void goglClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type_, void* data) {
// 	(*ptrglClearBufferData)(target, internalformat, format, type_, data);
// }
// void goglClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type_, void* data) {
// 	(*ptrglClearBufferSubData)(target, internalformat, offset, size, format, type_, data);
// }
// void goglClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type_, void* data) {
// 	(*ptrglClearNamedBufferDataEXT)(buffer, internalformat, format, type_, data);
// }
// void goglClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type_, void* data) {
// 	(*ptrglClearNamedBufferSubDataEXT)(buffer, internalformat, offset, size, format, type_, data);
// }
// //  ARB_color_buffer_float
// void goglClampColorARB(GLenum target, GLenum clamp) {
// 	(*ptrglClampColorARB)(target, clamp);
// }
// //  ARB_compute_shader
// void goglDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
// 	(*ptrglDispatchCompute)(num_groups_x, num_groups_y, num_groups_z);
// }
// void goglDispatchComputeIndirect(GLintptr indirect) {
// 	(*ptrglDispatchComputeIndirect)(indirect);
// }
// //  ARB_copy_buffer
// void goglCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
// 	(*ptrglCopyBufferSubData)(readTarget, writeTarget, readOffset, writeOffset, size);
// }
// //  ARB_copy_image
// void goglCopyImageSubData(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) {
// 	(*ptrglCopyImageSubData)(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
// }
// //  ARB_debug_output
// void goglDebugMessageControlARB(GLenum source, GLenum type_, GLenum severity, GLsizei count, GLuint* ids, GLboolean enabled) {
// 	(*ptrglDebugMessageControlARB)(source, type_, severity, count, ids, enabled);
// }
// void goglDebugMessageInsertARB(GLenum source, GLenum type_, GLuint id, GLenum severity, GLsizei length, GLchar* buf) {
// 	(*ptrglDebugMessageInsertARB)(source, type_, id, severity, length, buf);
// }
// void goglDebugMessageCallbackARB(GLDEBUGPROCARB callback, GLvoid* userParam) {
// 	(*ptrglDebugMessageCallbackARB)(callback, userParam);
// }
// GLuint goglGetDebugMessageLogARB(GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog) {
// 	return (*ptrglGetDebugMessageLogARB)(count, bufsize, sources, types, ids, severities, lengths, messageLog);
// }
// //  ARB_draw_buffers
// void goglDrawBuffersARB(GLsizei n, GLenum* bufs) {
// 	(*ptrglDrawBuffersARB)(n, bufs);
// }
// //  ARB_draw_buffers_blend
// void goglBlendEquationiARB(GLuint buf, GLenum mode) {
// 	(*ptrglBlendEquationiARB)(buf, mode);
// }
// void goglBlendEquationSeparateiARB(GLuint buf, GLenum modeRGB, GLenum modeAlpha) {
// 	(*ptrglBlendEquationSeparateiARB)(buf, modeRGB, modeAlpha);
// }
// void goglBlendFunciARB(GLuint buf, GLenum src, GLenum dst) {
// 	(*ptrglBlendFunciARB)(buf, src, dst);
// }
// void goglBlendFuncSeparateiARB(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
// 	(*ptrglBlendFuncSeparateiARB)(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
// }
// //  ARB_draw_elements_base_vertex
// void goglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type_, GLvoid* indices, GLint basevertex) {
// 	(*ptrglDrawElementsBaseVertex)(mode, count, type_, indices, basevertex);
// }
// void goglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type_, GLvoid* indices, GLint basevertex) {
// 	(*ptrglDrawRangeElementsBaseVertex)(mode, start, end, count, type_, indices, basevertex);
// }
// void goglDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type_, GLvoid* indices, GLsizei instancecount, GLint basevertex) {
// 	(*ptrglDrawElementsInstancedBaseVertex)(mode, count, type_, indices, instancecount, basevertex);
// }
// void goglMultiDrawElementsBaseVertex(GLenum mode, GLsizei* count, GLenum type_, GLvoid* const* indices, GLsizei drawcount, GLint* basevertex) {
// 	(*ptrglMultiDrawElementsBaseVertex)(mode, count, type_, indices, drawcount, basevertex);
// }
// //  ARB_draw_indirect
// void goglDrawArraysIndirect(GLenum mode, GLvoid* indirect) {
// 	(*ptrglDrawArraysIndirect)(mode, indirect);
// }
// void goglDrawElementsIndirect(GLenum mode, GLenum type_, GLvoid* indirect) {
// 	(*ptrglDrawElementsIndirect)(mode, type_, indirect);
// }
// //  ARB_draw_instanced
// void goglDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
// 	(*ptrglDrawArraysInstancedARB)(mode, first, count, primcount);
// }
// void goglDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type_, GLvoid* indices, GLsizei primcount) {
// 	(*ptrglDrawElementsInstancedARB)(mode, count, type_, indices, primcount);
// }
// //  ARB_framebuffer_no_attachments
// void goglFramebufferParameteri(GLenum target, GLenum pname, GLint param) {
// 	(*ptrglFramebufferParameteri)(target, pname, param);
// }
// void goglGetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params) {
// 	(*ptrglGetFramebufferParameteriv)(target, pname, params);
// }
// void goglNamedFramebufferParameteriEXT(GLuint framebuffer, GLenum pname, GLint param) {
// 	(*ptrglNamedFramebufferParameteriEXT)(framebuffer, pname, param);
// }
// void goglGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint* params) {
// 	(*ptrglGetNamedFramebufferParameterivEXT)(framebuffer, pname, params);
// }
// //  ARB_framebuffer_object
// GLboolean goglIsRenderbuffer(GLuint renderbuffer) {
// 	return (*ptrglIsRenderbuffer)(renderbuffer);
// }
// void goglBindRenderbuffer(GLenum target, GLuint renderbuffer) {
// 	(*ptrglBindRenderbuffer)(target, renderbuffer);
// }
// void goglDeleteRenderbuffers(GLsizei n, GLuint* renderbuffers) {
// 	(*ptrglDeleteRenderbuffers)(n, renderbuffers);
// }
// void goglGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
// 	(*ptrglGenRenderbuffers)(n, renderbuffers);
// }
// void goglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
// 	(*ptrglRenderbufferStorage)(target, internalformat, width, height);
// }
// void goglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) {
// 	(*ptrglGetRenderbufferParameteriv)(target, pname, params);
// }
// GLboolean goglIsFramebuffer(GLuint framebuffer) {
// 	return (*ptrglIsFramebuffer)(framebuffer);
// }
// void goglBindFramebuffer(GLenum target, GLuint framebuffer) {
// 	(*ptrglBindFramebuffer)(target, framebuffer);
// }
// void goglDeleteFramebuffers(GLsizei n, GLuint* framebuffers) {
// 	(*ptrglDeleteFramebuffers)(n, framebuffers);
// }
// void goglGenFramebuffers(GLsizei n, GLuint* framebuffers) {
// 	(*ptrglGenFramebuffers)(n, framebuffers);
// }
// GLenum goglCheckFramebufferStatus(GLenum target) {
// 	return (*ptrglCheckFramebufferStatus)(target);
// }
// void goglFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
// 	(*ptrglFramebufferTexture1D)(target, attachment, textarget, texture, level);
// }
// void goglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
// 	(*ptrglFramebufferTexture2D)(target, attachment, textarget, texture, level);
// }
// void goglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
// 	(*ptrglFramebufferTexture3D)(target, attachment, textarget, texture, level, zoffset);
// }
// void goglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
// 	(*ptrglFramebufferRenderbuffer)(target, attachment, renderbuffertarget, renderbuffer);
// }
// void goglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) {
// 	(*ptrglGetFramebufferAttachmentParameteriv)(target, attachment, pname, params);
// }
// void goglGenerateMipmap(GLenum target) {
// 	(*ptrglGenerateMipmap)(target);
// }
// void goglBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
// 	(*ptrglBlitFramebuffer)(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
// }
// void goglRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
// 	(*ptrglRenderbufferStorageMultisample)(target, samples, internalformat, width, height);
// }
// void goglFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
// 	(*ptrglFramebufferTextureLayer)(target, attachment, texture, level, layer);
// }
// //  ARB_geometry_shader4
// void goglProgramParameteriARB(GLuint program, GLenum pname, GLint value) {
// 	(*ptrglProgramParameteriARB)(program, pname, value);
// }
// void goglFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level) {
// 	(*ptrglFramebufferTextureARB)(target, attachment, texture, level);
// }
// void goglFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
// 	(*ptrglFramebufferTextureLayerARB)(target, attachment, texture, level, layer);
// }
// void goglFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) {
// 	(*ptrglFramebufferTextureFaceARB)(target, attachment, texture, level, face);
// }
// //  ARB_get_program_binary
// void goglGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) {
// 	(*ptrglGetProgramBinary)(program, bufSize, length, binaryFormat, binary);
// }
// void goglProgramBinary(GLuint program, GLenum binaryFormat, GLvoid* binary, GLsizei length) {
// 	(*ptrglProgramBinary)(program, binaryFormat, binary, length);
// }
// void goglProgramParameteri(GLuint program, GLenum pname, GLint value) {
// 	(*ptrglProgramParameteri)(program, pname, value);
// }
// //  ARB_gpu_shader_fp64
// void goglUniform1d(GLint location, GLdouble x) {
// 	(*ptrglUniform1d)(location, x);
// }
// void goglUniform2d(GLint location, GLdouble x, GLdouble y) {
// 	(*ptrglUniform2d)(location, x, y);
// }
// void goglUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z) {
// 	(*ptrglUniform3d)(location, x, y, z);
// }
// void goglUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
// 	(*ptrglUniform4d)(location, x, y, z, w);
// }
// void goglUniform1dv(GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglUniform1dv)(location, count, value);
// }
// void goglUniform2dv(GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglUniform2dv)(location, count, value);
// }
// void goglUniform3dv(GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglUniform3dv)(location, count, value);
// }
// void goglUniform4dv(GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglUniform4dv)(location, count, value);
// }
// void goglUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix2dv)(location, count, transpose, value);
// }
// void goglUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix3dv)(location, count, transpose, value);
// }
// void goglUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix4dv)(location, count, transpose, value);
// }
// void goglUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix2x3dv)(location, count, transpose, value);
// }
// void goglUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix2x4dv)(location, count, transpose, value);
// }
// void goglUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix3x2dv)(location, count, transpose, value);
// }
// void goglUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix3x4dv)(location, count, transpose, value);
// }
// void goglUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix4x2dv)(location, count, transpose, value);
// }
// void goglUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglUniformMatrix4x3dv)(location, count, transpose, value);
// }
// void goglGetUniformdv(GLuint program, GLint location, GLdouble* params) {
// 	(*ptrglGetUniformdv)(program, location, params);
// }
// //  ARB_instanced_arrays
// void goglVertexAttribDivisorARB(GLuint index, GLuint divisor) {
// 	(*ptrglVertexAttribDivisorARB)(index, divisor);
// }
// //  ARB_internalformat_query
// void goglGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) {
// 	(*ptrglGetInternalformativ)(target, internalformat, pname, bufSize, params);
// }
// //  ARB_internalformat_query2
// void goglGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params) {
// 	(*ptrglGetInternalformati64v)(target, internalformat, pname, bufSize, params);
// }
// //  ARB_invalidate_subdata
// void goglInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) {
// 	(*ptrglInvalidateTexSubImage)(texture, level, xoffset, yoffset, zoffset, width, height, depth);
// }
// void goglInvalidateTexImage(GLuint texture, GLint level) {
// 	(*ptrglInvalidateTexImage)(texture, level);
// }
// void goglInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length) {
// 	(*ptrglInvalidateBufferSubData)(buffer, offset, length);
// }
// void goglInvalidateBufferData(GLuint buffer) {
// 	(*ptrglInvalidateBufferData)(buffer);
// }
// void goglInvalidateFramebuffer(GLenum target, GLsizei numAttachments, GLenum* attachments) {
// 	(*ptrglInvalidateFramebuffer)(target, numAttachments, attachments);
// }
// void goglInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
// 	(*ptrglInvalidateSubFramebuffer)(target, numAttachments, attachments, x, y, width, height);
// }
// //  ARB_map_buffer_range
// GLvoid* goglMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
// 	return (*ptrglMapBufferRange)(target, offset, length, access);
// }
// void goglFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
// 	(*ptrglFlushMappedBufferRange)(target, offset, length);
// }
// //  ARB_matrix_palette
// void goglCurrentPaletteMatrixARB(GLint index) {
// 	(*ptrglCurrentPaletteMatrixARB)(index);
// }
// void goglMatrixIndexubvARB(GLint size, GLubyte* indices) {
// 	(*ptrglMatrixIndexubvARB)(size, indices);
// }
// void goglMatrixIndexusvARB(GLint size, GLushort* indices) {
// 	(*ptrglMatrixIndexusvARB)(size, indices);
// }
// void goglMatrixIndexuivARB(GLint size, GLuint* indices) {
// 	(*ptrglMatrixIndexuivARB)(size, indices);
// }
// void goglMatrixIndexPointerARB(GLint size, GLenum type_, GLsizei stride, GLvoid* pointer) {
// 	(*ptrglMatrixIndexPointerARB)(size, type_, stride, pointer);
// }
// //  ARB_multi_draw_indirect
// void goglMultiDrawArraysIndirect(GLenum mode, void* indirect, GLsizei drawcount, GLsizei stride) {
// 	(*ptrglMultiDrawArraysIndirect)(mode, indirect, drawcount, stride);
// }
// void goglMultiDrawElementsIndirect(GLenum mode, GLenum type_, void* indirect, GLsizei drawcount, GLsizei stride) {
// 	(*ptrglMultiDrawElementsIndirect)(mode, type_, indirect, drawcount, stride);
// }
// //  ARB_multisample
// void goglSampleCoverageARB(GLfloat value, GLboolean invert) {
// 	(*ptrglSampleCoverageARB)(value, invert);
// }
// //  ARB_multitexture
// void goglActiveTextureARB(GLenum texture) {
// 	(*ptrglActiveTextureARB)(texture);
// }
// void goglClientActiveTextureARB(GLenum texture) {
// 	(*ptrglClientActiveTextureARB)(texture);
// }
// void goglMultiTexCoord1dARB(GLenum target, GLdouble s) {
// 	(*ptrglMultiTexCoord1dARB)(target, s);
// }
// void goglMultiTexCoord1dvARB(GLenum target, GLdouble* v) {
// 	(*ptrglMultiTexCoord1dvARB)(target, v);
// }
// void goglMultiTexCoord1fARB(GLenum target, GLfloat s) {
// 	(*ptrglMultiTexCoord1fARB)(target, s);
// }
// void goglMultiTexCoord1fvARB(GLenum target, GLfloat* v) {
// 	(*ptrglMultiTexCoord1fvARB)(target, v);
// }
// void goglMultiTexCoord1iARB(GLenum target, GLint s) {
// 	(*ptrglMultiTexCoord1iARB)(target, s);
// }
// void goglMultiTexCoord1ivARB(GLenum target, GLint* v) {
// 	(*ptrglMultiTexCoord1ivARB)(target, v);
// }
// void goglMultiTexCoord1sARB(GLenum target, GLshort s) {
// 	(*ptrglMultiTexCoord1sARB)(target, s);
// }
// void goglMultiTexCoord1svARB(GLenum target, GLshort* v) {
// 	(*ptrglMultiTexCoord1svARB)(target, v);
// }
// void goglMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) {
// 	(*ptrglMultiTexCoord2dARB)(target, s, t);
// }
// void goglMultiTexCoord2dvARB(GLenum target, GLdouble* v) {
// 	(*ptrglMultiTexCoord2dvARB)(target, v);
// }
// void goglMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) {
// 	(*ptrglMultiTexCoord2fARB)(target, s, t);
// }
// void goglMultiTexCoord2fvARB(GLenum target, GLfloat* v) {
// 	(*ptrglMultiTexCoord2fvARB)(target, v);
// }
// void goglMultiTexCoord2iARB(GLenum target, GLint s, GLint t) {
// 	(*ptrglMultiTexCoord2iARB)(target, s, t);
// }
// void goglMultiTexCoord2ivARB(GLenum target, GLint* v) {
// 	(*ptrglMultiTexCoord2ivARB)(target, v);
// }
// void goglMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) {
// 	(*ptrglMultiTexCoord2sARB)(target, s, t);
// }
// void goglMultiTexCoord2svARB(GLenum target, GLshort* v) {
// 	(*ptrglMultiTexCoord2svARB)(target, v);
// }
// void goglMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r) {
// 	(*ptrglMultiTexCoord3dARB)(target, s, t, r);
// }
// void goglMultiTexCoord3dvARB(GLenum target, GLdouble* v) {
// 	(*ptrglMultiTexCoord3dvARB)(target, v);
// }
// void goglMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) {
// 	(*ptrglMultiTexCoord3fARB)(target, s, t, r);
// }
// void goglMultiTexCoord3fvARB(GLenum target, GLfloat* v) {
// 	(*ptrglMultiTexCoord3fvARB)(target, v);
// }
// void goglMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) {
// 	(*ptrglMultiTexCoord3iARB)(target, s, t, r);
// }
// void goglMultiTexCoord3ivARB(GLenum target, GLint* v) {
// 	(*ptrglMultiTexCoord3ivARB)(target, v);
// }
// void goglMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r) {
// 	(*ptrglMultiTexCoord3sARB)(target, s, t, r);
// }
// void goglMultiTexCoord3svARB(GLenum target, GLshort* v) {
// 	(*ptrglMultiTexCoord3svARB)(target, v);
// }
// void goglMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
// 	(*ptrglMultiTexCoord4dARB)(target, s, t, r, q);
// }
// void goglMultiTexCoord4dvARB(GLenum target, GLdouble* v) {
// 	(*ptrglMultiTexCoord4dvARB)(target, v);
// }
// void goglMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
// 	(*ptrglMultiTexCoord4fARB)(target, s, t, r, q);
// }
// void goglMultiTexCoord4fvARB(GLenum target, GLfloat* v) {
// 	(*ptrglMultiTexCoord4fvARB)(target, v);
// }
// void goglMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q) {
// 	(*ptrglMultiTexCoord4iARB)(target, s, t, r, q);
// }
// void goglMultiTexCoord4ivARB(GLenum target, GLint* v) {
// 	(*ptrglMultiTexCoord4ivARB)(target, v);
// }
// void goglMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {
// 	(*ptrglMultiTexCoord4sARB)(target, s, t, r, q);
// }
// void goglMultiTexCoord4svARB(GLenum target, GLshort* v) {
// 	(*ptrglMultiTexCoord4svARB)(target, v);
// }
// //  ARB_occlusion_query
// void goglGenQueriesARB(GLsizei n, GLuint* ids) {
// 	(*ptrglGenQueriesARB)(n, ids);
// }
// void goglDeleteQueriesARB(GLsizei n, GLuint* ids) {
// 	(*ptrglDeleteQueriesARB)(n, ids);
// }
// GLboolean goglIsQueryARB(GLuint id) {
// 	return (*ptrglIsQueryARB)(id);
// }
// void goglBeginQueryARB(GLenum target, GLuint id) {
// 	(*ptrglBeginQueryARB)(target, id);
// }
// void goglEndQueryARB(GLenum target) {
// 	(*ptrglEndQueryARB)(target);
// }
// void goglGetQueryivARB(GLenum target, GLenum pname, GLint* params) {
// 	(*ptrglGetQueryivARB)(target, pname, params);
// }
// void goglGetQueryObjectivARB(GLuint id, GLenum pname, GLint* params) {
// 	(*ptrglGetQueryObjectivARB)(id, pname, params);
// }
// void goglGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint* params) {
// 	(*ptrglGetQueryObjectuivARB)(id, pname, params);
// }
// //  ARB_point_parameters
// void goglPointParameterfARB(GLenum pname, GLfloat param) {
// 	(*ptrglPointParameterfARB)(pname, param);
// }
// void goglPointParameterfvARB(GLenum pname, GLfloat* params) {
// 	(*ptrglPointParameterfvARB)(pname, params);
// }
// //  ARB_program_interface_query
// void goglGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params) {
// 	(*ptrglGetProgramInterfaceiv)(program, programInterface, pname, params);
// }
// GLuint goglGetProgramResourceIndex(GLuint program, GLenum programInterface, GLchar* name) {
// 	return (*ptrglGetProgramResourceIndex)(program, programInterface, name);
// }
// void goglGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) {
// 	(*ptrglGetProgramResourceName)(program, programInterface, index, bufSize, length, name);
// }
// void goglGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params) {
// 	(*ptrglGetProgramResourceiv)(program, programInterface, index, propCount, props, bufSize, length, params);
// }
// GLint goglGetProgramResourceLocation(GLuint program, GLenum programInterface, GLchar* name) {
// 	return (*ptrglGetProgramResourceLocation)(program, programInterface, name);
// }
// GLint goglGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, GLchar* name) {
// 	return (*ptrglGetProgramResourceLocationIndex)(program, programInterface, name);
// }
// //  ARB_provoking_vertex
// void goglProvokingVertex(GLenum mode) {
// 	(*ptrglProvokingVertex)(mode);
// }
// //  ARB_robustness
// GLenum goglGetGraphicsResetStatusARB() {
// 	return (*ptrglGetGraphicsResetStatusARB)();
// }
// void goglGetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, GLdouble* v) {
// 	(*ptrglGetnMapdvARB)(target, query, bufSize, v);
// }
// void goglGetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, GLfloat* v) {
// 	(*ptrglGetnMapfvARB)(target, query, bufSize, v);
// }
// void goglGetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, GLint* v) {
// 	(*ptrglGetnMapivARB)(target, query, bufSize, v);
// }
// void goglGetnPixelMapfvARB(GLenum map_, GLsizei bufSize, GLfloat* values) {
// 	(*ptrglGetnPixelMapfvARB)(map_, bufSize, values);
// }
// void goglGetnPixelMapuivARB(GLenum map_, GLsizei bufSize, GLuint* values) {
// 	(*ptrglGetnPixelMapuivARB)(map_, bufSize, values);
// }
// void goglGetnPixelMapusvARB(GLenum map_, GLsizei bufSize, GLushort* values) {
// 	(*ptrglGetnPixelMapusvARB)(map_, bufSize, values);
// }
// void goglGetnPolygonStippleARB(GLsizei bufSize, GLubyte* pattern) {
// 	(*ptrglGetnPolygonStippleARB)(bufSize, pattern);
// }
// void goglGetnColorTableARB(GLenum target, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* table) {
// 	(*ptrglGetnColorTableARB)(target, format, type_, bufSize, table);
// }
// void goglGetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* image) {
// 	(*ptrglGetnConvolutionFilterARB)(target, format, type_, bufSize, image);
// }
// void goglGetnSeparableFilterARB(GLenum target, GLenum format, GLenum type_, GLsizei rowBufSize, GLvoid* row, GLsizei columnBufSize, GLvoid* column, GLvoid* span) {
// 	(*ptrglGetnSeparableFilterARB)(target, format, type_, rowBufSize, row, columnBufSize, column, span);
// }
// void goglGetnHistogramARB(GLenum target, GLboolean reset, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* values) {
// 	(*ptrglGetnHistogramARB)(target, reset, format, type_, bufSize, values);
// }
// void goglGetnMinmaxARB(GLenum target, GLboolean reset, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* values) {
// 	(*ptrglGetnMinmaxARB)(target, reset, format, type_, bufSize, values);
// }
// void goglGetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* img) {
// 	(*ptrglGetnTexImageARB)(target, level, format, type_, bufSize, img);
// }
// void goglReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type_, GLsizei bufSize, GLvoid* data) {
// 	(*ptrglReadnPixelsARB)(x, y, width, height, format, type_, bufSize, data);
// }
// void goglGetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, GLvoid* img) {
// 	(*ptrglGetnCompressedTexImageARB)(target, lod, bufSize, img);
// }
// void goglGetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, GLfloat* params) {
// 	(*ptrglGetnUniformfvARB)(program, location, bufSize, params);
// }
// void goglGetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, GLint* params) {
// 	(*ptrglGetnUniformivARB)(program, location, bufSize, params);
// }
// void goglGetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, GLuint* params) {
// 	(*ptrglGetnUniformuivARB)(program, location, bufSize, params);
// }
// void goglGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble* params) {
// 	(*ptrglGetnUniformdvARB)(program, location, bufSize, params);
// }
// //  ARB_sample_shading
// void goglMinSampleShadingARB(GLfloat value) {
// 	(*ptrglMinSampleShadingARB)(value);
// }
// //  ARB_sampler_objects
// void goglGenSamplers(GLsizei count, GLuint* samplers) {
// 	(*ptrglGenSamplers)(count, samplers);
// }
// void goglDeleteSamplers(GLsizei count, GLuint* samplers) {
// 	(*ptrglDeleteSamplers)(count, samplers);
// }
// GLboolean goglIsSampler(GLuint sampler) {
// 	return (*ptrglIsSampler)(sampler);
// }
// void goglBindSampler(GLuint unit, GLuint sampler) {
// 	(*ptrglBindSampler)(unit, sampler);
// }
// void goglSamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
// 	(*ptrglSamplerParameteri)(sampler, pname, param);
// }
// void goglSamplerParameteriv(GLuint sampler, GLenum pname, GLint* param) {
// 	(*ptrglSamplerParameteriv)(sampler, pname, param);
// }
// void goglSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
// 	(*ptrglSamplerParameterf)(sampler, pname, param);
// }
// void goglSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* param) {
// 	(*ptrglSamplerParameterfv)(sampler, pname, param);
// }
// void goglSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* param) {
// 	(*ptrglSamplerParameterIiv)(sampler, pname, param);
// }
// void goglSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* param) {
// 	(*ptrglSamplerParameterIuiv)(sampler, pname, param);
// }
// void goglGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
// 	(*ptrglGetSamplerParameteriv)(sampler, pname, params);
// }
// void goglGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint* params) {
// 	(*ptrglGetSamplerParameterIiv)(sampler, pname, params);
// }
// void goglGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
// 	(*ptrglGetSamplerParameterfv)(sampler, pname, params);
// }
// void goglGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint* params) {
// 	(*ptrglGetSamplerParameterIuiv)(sampler, pname, params);
// }
// //  ARB_separate_shader_objects
// void goglUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) {
// 	(*ptrglUseProgramStages)(pipeline, stages, program);
// }
// void goglActiveShaderProgram(GLuint pipeline, GLuint program) {
// 	(*ptrglActiveShaderProgram)(pipeline, program);
// }
// GLuint goglCreateShaderProgramv(GLenum type_, GLsizei count, GLchar* const* strings) {
// 	return (*ptrglCreateShaderProgramv)(type_, count, strings);
// }
// void goglBindProgramPipeline(GLuint pipeline) {
// 	(*ptrglBindProgramPipeline)(pipeline);
// }
// void goglDeleteProgramPipelines(GLsizei n, GLuint* pipelines) {
// 	(*ptrglDeleteProgramPipelines)(n, pipelines);
// }
// void goglGenProgramPipelines(GLsizei n, GLuint* pipelines) {
// 	(*ptrglGenProgramPipelines)(n, pipelines);
// }
// GLboolean goglIsProgramPipeline(GLuint pipeline) {
// 	return (*ptrglIsProgramPipeline)(pipeline);
// }
// void goglGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params) {
// 	(*ptrglGetProgramPipelineiv)(pipeline, pname, params);
// }
// void goglProgramUniform1i(GLuint program, GLint location, GLint v0) {
// 	(*ptrglProgramUniform1i)(program, location, v0);
// }
// void goglProgramUniform1iv(GLuint program, GLint location, GLsizei count, GLint* value) {
// 	(*ptrglProgramUniform1iv)(program, location, count, value);
// }
// void goglProgramUniform1f(GLuint program, GLint location, GLfloat v0) {
// 	(*ptrglProgramUniform1f)(program, location, v0);
// }
// void goglProgramUniform1fv(GLuint program, GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglProgramUniform1fv)(program, location, count, value);
// }
// void goglProgramUniform1d(GLuint program, GLint location, GLdouble v0) {
// 	(*ptrglProgramUniform1d)(program, location, v0);
// }
// void goglProgramUniform1dv(GLuint program, GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglProgramUniform1dv)(program, location, count, value);
// }
// void goglProgramUniform1ui(GLuint program, GLint location, GLuint v0) {
// 	(*ptrglProgramUniform1ui)(program, location, v0);
// }
// void goglProgramUniform1uiv(GLuint program, GLint location, GLsizei count, GLuint* value) {
// 	(*ptrglProgramUniform1uiv)(program, location, count, value);
// }
// void goglProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) {
// 	(*ptrglProgramUniform2i)(program, location, v0, v1);
// }
// void goglProgramUniform2iv(GLuint program, GLint location, GLsizei count, GLint* value) {
// 	(*ptrglProgramUniform2iv)(program, location, count, value);
// }
// void goglProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) {
// 	(*ptrglProgramUniform2f)(program, location, v0, v1);
// }
// void goglProgramUniform2fv(GLuint program, GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglProgramUniform2fv)(program, location, count, value);
// }
// void goglProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1) {
// 	(*ptrglProgramUniform2d)(program, location, v0, v1);
// }
// void goglProgramUniform2dv(GLuint program, GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglProgramUniform2dv)(program, location, count, value);
// }
// void goglProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) {
// 	(*ptrglProgramUniform2ui)(program, location, v0, v1);
// }
// void goglProgramUniform2uiv(GLuint program, GLint location, GLsizei count, GLuint* value) {
// 	(*ptrglProgramUniform2uiv)(program, location, count, value);
// }
// void goglProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {
// 	(*ptrglProgramUniform3i)(program, location, v0, v1, v2);
// }
// void goglProgramUniform3iv(GLuint program, GLint location, GLsizei count, GLint* value) {
// 	(*ptrglProgramUniform3iv)(program, location, count, value);
// }
// void goglProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
// 	(*ptrglProgramUniform3f)(program, location, v0, v1, v2);
// }
// void goglProgramUniform3fv(GLuint program, GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglProgramUniform3fv)(program, location, count, value);
// }
// void goglProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) {
// 	(*ptrglProgramUniform3d)(program, location, v0, v1, v2);
// }
// void goglProgramUniform3dv(GLuint program, GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglProgramUniform3dv)(program, location, count, value);
// }
// void goglProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) {
// 	(*ptrglProgramUniform3ui)(program, location, v0, v1, v2);
// }
// void goglProgramUniform3uiv(GLuint program, GLint location, GLsizei count, GLuint* value) {
// 	(*ptrglProgramUniform3uiv)(program, location, count, value);
// }
// void goglProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
// 	(*ptrglProgramUniform4i)(program, location, v0, v1, v2, v3);
// }
// void goglProgramUniform4iv(GLuint program, GLint location, GLsizei count, GLint* value) {
// 	(*ptrglProgramUniform4iv)(program, location, count, value);
// }
// void goglProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
// 	(*ptrglProgramUniform4f)(program, location, v0, v1, v2, v3);
// }
// void goglProgramUniform4fv(GLuint program, GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglProgramUniform4fv)(program, location, count, value);
// }
// void goglProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {
// 	(*ptrglProgramUniform4d)(program, location, v0, v1, v2, v3);
// }
// void goglProgramUniform4dv(GLuint program, GLint location, GLsizei count, GLdouble* value) {
// 	(*ptrglProgramUniform4dv)(program, location, count, value);
// }
// void goglProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
// 	(*ptrglProgramUniform4ui)(program, location, v0, v1, v2, v3);
// }
// void goglProgramUniform4uiv(GLuint program, GLint location, GLsizei count, GLuint* value) {
// 	(*ptrglProgramUniform4uiv)(program, location, count, value);
// }
// void goglProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix2fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix3fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix4fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix2dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix3dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix4dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix2x3fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix3x2fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix2x4fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix4x2fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix3x4fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglProgramUniformMatrix4x3fv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix2x3dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix3x2dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix2x4dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix4x2dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix3x4dv)(program, location, count, transpose, value);
// }
// void goglProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value) {
// 	(*ptrglProgramUniformMatrix4x3dv)(program, location, count, transpose, value);
// }
// void goglValidateProgramPipeline(GLuint pipeline) {
// 	(*ptrglValidateProgramPipeline)(pipeline);
// }
// void goglGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
// 	(*ptrglGetProgramPipelineInfoLog)(pipeline, bufSize, length, infoLog);
// }
// //  ARB_shader_atomic_counters
// void goglGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint* params) {
// 	(*ptrglGetActiveAtomicCounterBufferiv)(program, bufferIndex, pname, params);
// }
// //  ARB_shader_image_load_store
// void goglBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
// 	(*ptrglBindImageTexture)(unit, texture, level, layered, layer, access, format);
// }
// void goglMemoryBarrier(GLbitfield barriers) {
// 	(*ptrglMemoryBarrier)(barriers);
// }
// //  ARB_shader_objects
// void goglDeleteObjectARB(GLhandleARB obj) {
// 	(*ptrglDeleteObjectARB)(obj);
// }
// GLhandleARB goglGetHandleARB(GLenum pname) {
// 	return (*ptrglGetHandleARB)(pname);
// }
// void goglDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj) {
// 	(*ptrglDetachObjectARB)(containerObj, attachedObj);
// }
// GLhandleARB goglCreateShaderObjectARB(GLenum shaderType) {
// 	return (*ptrglCreateShaderObjectARB)(shaderType);
// }
// void goglShaderSourceARB(GLhandleARB shaderObj, GLsizei count, GLcharARB** string_, GLint* length) {
// 	(*ptrglShaderSourceARB)(shaderObj, count, string_, length);
// }
// void goglCompileShaderARB(GLhandleARB shaderObj) {
// 	(*ptrglCompileShaderARB)(shaderObj);
// }
// GLhandleARB goglCreateProgramObjectARB() {
// 	return (*ptrglCreateProgramObjectARB)();
// }
// void goglAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj) {
// 	(*ptrglAttachObjectARB)(containerObj, obj);
// }
// void goglLinkProgramARB(GLhandleARB programObj) {
// 	(*ptrglLinkProgramARB)(programObj);
// }
// void goglUseProgramObjectARB(GLhandleARB programObj) {
// 	(*ptrglUseProgramObjectARB)(programObj);
// }
// void goglValidateProgramARB(GLhandleARB programObj) {
// 	(*ptrglValidateProgramARB)(programObj);
// }
// void goglUniform1fARB(GLint location, GLfloat v0) {
// 	(*ptrglUniform1fARB)(location, v0);
// }
// void goglUniform2fARB(GLint location, GLfloat v0, GLfloat v1) {
// 	(*ptrglUniform2fARB)(location, v0, v1);
// }
// void goglUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
// 	(*ptrglUniform3fARB)(location, v0, v1, v2);
// }
// void goglUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
// 	(*ptrglUniform4fARB)(location, v0, v1, v2, v3);
// }
// void goglUniform1iARB(GLint location, GLint v0) {
// 	(*ptrglUniform1iARB)(location, v0);
// }
// void goglUniform2iARB(GLint location, GLint v0, GLint v1) {
// 	(*ptrglUniform2iARB)(location, v0, v1);
// }
// void goglUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2) {
// 	(*ptrglUniform3iARB)(location, v0, v1, v2);
// }
// void goglUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
// 	(*ptrglUniform4iARB)(location, v0, v1, v2, v3);
// }
// void goglUniform1fvARB(GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglUniform1fvARB)(location, count, value);
// }
// void goglUniform2fvARB(GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglUniform2fvARB)(location, count, value);
// }
// void goglUniform3fvARB(GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglUniform3fvARB)(location, count, value);
// }
// void goglUniform4fvARB(GLint location, GLsizei count, GLfloat* value) {
// 	(*ptrglUniform4fvARB)(location, count, value);
// }
// void goglUniform1ivARB(GLint location, GLsizei count, GLint* value) {
// 	(*ptrglUniform1ivARB)(location, count, value);
// }
// void goglUniform2ivARB(GLint location, GLsizei count, GLint* value) {
// 	(*ptrglUniform2ivARB)(location, count, value);
// }
// void goglUniform3ivARB(GLint location, GLsizei count, GLint* value) {
// 	(*ptrglUniform3ivARB)(location, count, value);
// }
// void goglUniform4ivARB(GLint location, GLsizei count, GLint* value) {
// 	(*ptrglUniform4ivARB)(location, count, value);
// }
// void goglUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglUniformMatrix2fvARB)(location, count, transpose, value);
// }
// void goglUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglUniformMatrix3fvARB)(location, count, transpose, value);
// }
// void goglUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat* value) {
// 	(*ptrglUniformMatrix4fvARB)(location, count, transpose, value);
// }
// void goglGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat* params) {
// 	(*ptrglGetObjectParameterfvARB)(obj, pname, params);
// }
// void goglGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint* params) {
// 	(*ptrglGetObjectParameterivARB)(obj, pname, params);
// }
// void goglGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog) {
// 	(*ptrglGetInfoLogARB)(obj, maxLength, length, infoLog);
// }
// void goglGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj) {
// 	(*ptrglGetAttachedObjectsARB)(containerObj, maxCount, count, obj);
// }
// GLint goglGetUniformLocationARB(GLhandleARB programObj, GLcharARB* name) {
// 	return (*ptrglGetUniformLocationARB)(programObj, name);
// }
// void goglGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type_, GLcharARB* name) {
// 	(*ptrglGetActiveUniformARB)(programObj, index, maxLength, length, size, type_, name);
// }
// void goglGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat* params) {
// 	(*ptrglGetUniformfvARB)(programObj, location, params);
// }
// void goglGetUniformivARB(GLhandleARB programObj, GLint location, GLint* params) {
// 	(*ptrglGetUniformivARB)(programObj, location, params);
// }
// void goglGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* source) {
// 	(*ptrglGetShaderSourceARB)(obj, maxLength, length, source);
// }
// //  ARB_shader_storage_buffer_object
// void goglShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) {
// 	(*ptrglShaderStorageBlockBinding)(program, storageBlockIndex, storageBlockBinding);
// }
// //  ARB_shader_subroutine
// GLint goglGetSubroutineUniformLocation(GLuint program, GLenum shadertype, GLchar* name) {
// 	return (*ptrglGetSubroutineUniformLocation)(program, shadertype, name);
// }
// GLuint goglGetSubroutineIndex(GLuint program, GLenum shadertype, GLchar* name) {
// 	return (*ptrglGetSubroutineIndex)(program, shadertype, name);
// }
// void goglGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values) {
// 	(*ptrglGetActiveSubroutineUniformiv)(program, shadertype, index, pname, values);
// }
// void goglGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name) {
// 	(*ptrglGetActiveSubroutineUniformName)(program, shadertype, index, bufsize, length, name);
// }
// void goglGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name) {
// 	(*ptrglGetActiveSubroutineName)(program, shadertype, index, bufsize, length, name);
// }
// void goglUniformSubroutinesuiv(GLenum shadertype, GLsizei count, GLuint* indices) {
// 	(*ptrglUniformSubroutinesuiv)(shadertype, count, indices);
// }
// void goglGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint* params) {
// 	(*ptrglGetUniformSubroutineuiv)(shadertype, location, params);
// }
// void goglGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint* values) {
// 	(*ptrglGetProgramStageiv)(program, shadertype, pname, values);
// }
// //  ARB_shading_language_include
// void goglNamedStringARB(GLenum type_, GLint namelen, GLchar* name, GLint stringlen, GLchar* string_) {
// 	(*ptrglNamedStringARB)(type_, namelen, name, stringlen, string_);
// }
// void goglDeleteNamedStringARB(GLint namelen, GLchar* name) {
// 	(*ptrglDeleteNamedStringARB)(namelen, name);
// }
// void goglCompileShaderIncludeARB(GLuint shader, GLsizei count, GLchar** path, GLint* length) {
// 	(*ptrglCompileShaderIncludeARB)(shader, count, path, length);
// }
// GLboolean goglIsNamedStringARB(GLint namelen, GLchar* name) {
// 	return (*ptrglIsNamedStringARB)(namelen, name);
// }
// void goglGetNamedStringARB(GLint namelen, GLchar* name, GLsizei bufSize, GLint* stringlen, GLchar* string_) {
// 	(*ptrglGetNamedStringARB)(namelen, name, bufSize, stringlen, string_);
// }
// void goglGetNamedStringivARB(GLint namelen, GLchar* name, GLenum pname, GLint* params) {
// 	(*ptrglGetNamedStringivARB)(namelen, name, pname, params);
// }
// //  ARB_sync
// GLsync goglFenceSync(GLenum condition, GLbitfield flags) {
// 	return (*ptrglFenceSync)(condition, flags);
// }
// GLboolean goglIsSync(GLsync sync) {
// 	return (*ptrglIsSync)(sync);
// }
// void goglDeleteSync(GLsync sync) {
// 	(*ptrglDeleteSync)(sync);
// }
// GLenum goglClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
// 	return (*ptrglClientWaitSync)(sync, flags, timeout);
// }
// void goglWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
// 	(*ptrglWaitSync)(sync, flags, timeout);
// }
// void goglGetInteger64v(GLenum pname, GLint64* params) {
// 	(*ptrglGetInteger64v)(pname, params);
// }
// void goglGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) {
// 	(*ptrglGetSynciv)(sync, pname, bufSize, length, values);
// }
// //  ARB_tessellation_shader
// void goglPatchParameteri(GLenum pname, GLint value) {
// 	(*ptrglPatchParameteri)(pname, value);
// }
// void goglPatchParameterfv(GLenum pname, GLfloat* values) {
// 	(*ptrglPatchParameterfv)(pname, values);
// }
// //  ARB_texture_buffer_object
// void goglTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer) {
// 	(*ptrglTexBufferARB)(target, internalformat, buffer);
// }
// //  ARB_texture_buffer_range
// void goglTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
// 	(*ptrglTexBufferRange)(target, internalformat, buffer, offset, size);
// }
// void goglTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
// 	(*ptrglTextureBufferRangeEXT)(texture, target, internalformat, buffer, offset, size);
// }
// //  ARB_texture_compression
// void goglCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexImage3DARB)(target, level, internalformat, width, height, depth, border, imageSize, data);
// }
// void goglCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexImage2DARB)(target, level, internalformat, width, height, border, imageSize, data);
// }
// void goglCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexImage1DARB)(target, level, internalformat, width, border, imageSize, data);
// }
// void goglCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexSubImage3DARB)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
// }
// void goglCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexSubImage2DARB)(target, level, xoffset, yoffset, width, height, format, imageSize, data);
// }
// void goglCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* data) {
// 	(*ptrglCompressedTexSubImage1DARB)(target, level, xoffset, width, format, imageSize, data);
// }
// void goglGetCompressedTexImageARB(GLenum target, GLint level, GLvoid* img) {
// 	(*ptrglGetCompressedTexImageARB)(target, level, img);
// }
// //  ARB_texture_multisample
// void goglTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
// 	(*ptrglTexImage2DMultisample)(target, samples, internalformat, width, height, fixedsamplelocations);
// }
// void goglTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
// 	(*ptrglTexImage3DMultisample)(target, samples, internalformat, width, height, depth, fixedsamplelocations);
// }
// void goglGetMultisamplefv(GLenum pname, GLuint index, GLfloat* val) {
// 	(*ptrglGetMultisamplefv)(pname, index, val);
// }
// void goglSampleMaski(GLuint index, GLbitfield mask) {
// 	(*ptrglSampleMaski)(index, mask);
// }
// //  ARB_texture_storage
// void goglTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) {
// 	(*ptrglTexStorage1D)(target, levels, internalformat, width);
// }
// void goglTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
// 	(*ptrglTexStorage2D)(target, levels, internalformat, width, height);
// }
// void goglTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
// 	(*ptrglTexStorage3D)(target, levels, internalformat, width, height, depth);
// }
// void goglTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) {
// 	(*ptrglTextureStorage1DEXT)(texture, target, levels, internalformat, width);
// }
// void goglTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
// 	(*ptrglTextureStorage2DEXT)(texture, target, levels, internalformat, width, height);
// }
// void goglTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
// 	(*ptrglTextureStorage3DEXT)(texture, target, levels, internalformat, width, height, depth);
// }
// //  ARB_texture_storage_multisample
// void goglTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
// 	(*ptrglTexStorage2DMultisample)(target, samples, internalformat, width, height, fixedsamplelocations);
// }
// void goglTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
// 	(*ptrglTexStorage3DMultisample)(target, samples, internalformat, width, height, depth, fixedsamplelocations);
// }
// void goglTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
// 	(*ptrglTextureStorage2DMultisampleEXT)(texture, target, samples, internalformat, width, height, fixedsamplelocations);
// }
// void goglTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
// 	(*ptrglTextureStorage3DMultisampleEXT)(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
// }
// //  ARB_texture_view
// void goglTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
// 	(*ptrglTextureView)(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
// }
// //  ARB_timer_query
// void goglQueryCounter(GLuint id, GLenum target) {
// 	(*ptrglQueryCounter)(id, target);
// }
// void goglGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
// 	(*ptrglGetQueryObjecti64v)(id, pname, params);
// }
// void goglGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
// 	(*ptrglGetQueryObjectui64v)(id, pname, params);
// }
// //  ARB_transform_feedback2
// void goglBindTransformFeedback(GLenum target, GLuint id) {
// 	(*ptrglBindTransformFeedback)(target, id);
// }
// void goglDeleteTransformFeedbacks(GLsizei n, GLuint* ids) {
// 	(*ptrglDeleteTransformFeedbacks)(n, ids);
// }
// void goglGenTransformFeedbacks(GLsizei n, GLuint* ids) {
// 	(*ptrglGenTransformFeedbacks)(n, ids);
// }
// GLboolean goglIsTransformFeedback(GLuint id) {
// 	return (*ptrglIsTransformFeedback)(id);
// }
// void goglPauseTransformFeedback() {
// 	(*ptrglPauseTransformFeedback)();
// }
// void goglResumeTransformFeedback() {
// 	(*ptrglResumeTransformFeedback)();
// }
// void goglDrawTransformFeedback(GLenum mode, GLuint id) {
// 	(*ptrglDrawTransformFeedback)(mode, id);
// }
// //  ARB_transform_feedback3
// void goglDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream) {
// 	(*ptrglDrawTransformFeedbackStream)(mode, id, stream);
// }
// void goglBeginQueryIndexed(GLenum target, GLuint index, GLuint id) {
// 	(*ptrglBeginQueryIndexed)(target, index, id);
// }
// void goglEndQueryIndexed(GLenum target, GLuint index) {
// 	(*ptrglEndQueryIndexed)(target, index);
// }
// void goglGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint* params) {
// 	(*ptrglGetQueryIndexediv)(target, index, pname, params);
// }
// //  ARB_transform_feedback_instanced
// void goglDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount) {
// 	(*ptrglDrawTransformFeedbackInstanced)(mode, id, instancecount);
// }
// void goglDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) {
// 	(*ptrglDrawTransformFeedbackStreamInstanced)(mode, id, stream, instancecount);
// }
// //  ARB_transpose_matrix
// void goglLoadTransposeMatrixfARB(GLfloat* m) {
// 	(*ptrglLoadTransposeMatrixfARB)(m);
// }
// void goglLoadTransposeMatrixdARB(GLdouble* m) {
// 	(*ptrglLoadTransposeMatrixdARB)(m);
// }
// void goglMultTransposeMatrixfARB(GLfloat* m) {
// 	(*ptrglMultTransposeMatrixfARB)(m);
// }
// void goglMultTransposeMatrixdARB(GLdouble* m) {
// 	(*ptrglMultTransposeMatrixdARB)(m);
// }
// //  ARB_uniform_buffer_object
// void goglGetUniformIndices(GLuint program, GLsizei uniformCount, GLchar* const* uniformNames, GLuint* uniformIndices) {
// 	(*ptrglGetUniformIndices)(program, uniformCount, uniformNames, uniformIndices);
// }
// void goglGetActiveUniformsiv(GLuint program, GLsizei uniformCount, GLuint* uniformIndices, GLenum pname, GLint* params) {
// 	(*ptrglGetActiveUniformsiv)(program, uniformCount, uniformIndices, pname, params);
// }
// void goglGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName) {
// 	(*ptrglGetActiveUniformName)(program, uniformIndex, bufSize, length, uniformName);
// }
// GLuint goglGetUniformBlockIndex(GLuint program, GLchar* uniformBlockName) {
// 	return (*ptrglGetUniformBlockIndex)(program, uniformBlockName);
// }
// void goglGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) {
// 	(*ptrglGetActiveUniformBlockiv)(program, uniformBlockIndex, pname, params);
// }
// void goglGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) {
// 	(*ptrglGetActiveUniformBlockName)(program, uniformBlockIndex, bufSize, length, uniformBlockName);
// }
// void goglUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
// 	(*ptrglUniformBlockBinding)(program, uniformBlockIndex, uniformBlockBinding);
// }
// //  ARB_vertex_array_object
// void goglBindVertexArray(GLuint array) {
// 	(*ptrglBindVertexArray)(array);
// }
// void goglDeleteVertexArrays(GLsizei n, GLuint* arrays) {
// 	(*ptrglDeleteVertexArrays)(n, arrays);
// }
// void goglGenVertexArrays(GLsizei n, GLuint* arrays) {
// 	(*ptrglGenVertexArrays)(n, arrays);
// }
// GLboolean goglIsVertexArray(GLuint array) {
// 	return (*ptrglIsVertexArray)(array);
// }
// //  ARB_vertex_attrib_64bit
// void goglVertexAttribL1d(GLuint index, GLdouble x) {
// 	(*ptrglVertexAttribL1d)(index, x);
// }
// void goglVertexAttribL2d(GLuint index, GLdouble x, GLdouble y) {
// 	(*ptrglVertexAttribL2d)(index, x, y);
// }
// void goglVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) {
// 	(*ptrglVertexAttribL3d)(index, x, y, z);
// }
// void goglVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
// 	(*ptrglVertexAttribL4d)(index, x, y, z, w);
// }
// void goglVertexAttribL1dv(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttribL1dv)(index, v);
// }
// void goglVertexAttribL2dv(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttribL2dv)(index, v);
// }
// void goglVertexAttribL3dv(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttribL3dv)(index, v);
// }
// void goglVertexAttribL4dv(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttribL4dv)(index, v);
// }
// void goglVertexAttribLPointer(GLuint index, GLint size, GLenum type_, GLsizei stride, GLvoid* pointer) {
// 	(*ptrglVertexAttribLPointer)(index, size, type_, stride, pointer);
// }
// void goglGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble* params) {
// 	(*ptrglGetVertexAttribLdv)(index, pname, params);
// }
// //  ARB_vertex_attrib_binding
// void goglBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
// 	(*ptrglBindVertexBuffer)(bindingindex, buffer, offset, stride);
// }
// void goglVertexAttribFormat(GLuint attribindex, GLint size, GLenum type_, GLboolean normalized, GLuint relativeoffset) {
// 	(*ptrglVertexAttribFormat)(attribindex, size, type_, normalized, relativeoffset);
// }
// void goglVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type_, GLuint relativeoffset) {
// 	(*ptrglVertexAttribIFormat)(attribindex, size, type_, relativeoffset);
// }
// void goglVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type_, GLuint relativeoffset) {
// 	(*ptrglVertexAttribLFormat)(attribindex, size, type_, relativeoffset);
// }
// void goglVertexAttribBinding(GLuint attribindex, GLuint bindingindex) {
// 	(*ptrglVertexAttribBinding)(attribindex, bindingindex);
// }
// void goglVertexBindingDivisor(GLuint bindingindex, GLuint divisor) {
// 	(*ptrglVertexBindingDivisor)(bindingindex, divisor);
// }
// void goglVertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
// 	(*ptrglVertexArrayBindVertexBufferEXT)(vaobj, bindingindex, buffer, offset, stride);
// }
// void goglVertexArrayVertexAttribFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type_, GLboolean normalized, GLuint relativeoffset) {
// 	(*ptrglVertexArrayVertexAttribFormatEXT)(vaobj, attribindex, size, type_, normalized, relativeoffset);
// }
// void goglVertexArrayVertexAttribIFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type_, GLuint relativeoffset) {
// 	(*ptrglVertexArrayVertexAttribIFormatEXT)(vaobj, attribindex, size, type_, relativeoffset);
// }
// void goglVertexArrayVertexAttribLFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type_, GLuint relativeoffset) {
// 	(*ptrglVertexArrayVertexAttribLFormatEXT)(vaobj, attribindex, size, type_, relativeoffset);
// }
// void goglVertexArrayVertexAttribBindingEXT(GLuint vaobj, GLuint attribindex, GLuint bindingindex) {
// 	(*ptrglVertexArrayVertexAttribBindingEXT)(vaobj, attribindex, bindingindex);
// }
// void goglVertexArrayVertexBindingDivisorEXT(GLuint vaobj, GLuint bindingindex, GLuint divisor) {
// 	(*ptrglVertexArrayVertexBindingDivisorEXT)(vaobj, bindingindex, divisor);
// }
// //  ARB_vertex_blend
// void goglWeightbvARB(GLint size, GLbyte* weights) {
// 	(*ptrglWeightbvARB)(size, weights);
// }
// void goglWeightsvARB(GLint size, GLshort* weights) {
// 	(*ptrglWeightsvARB)(size, weights);
// }
// void goglWeightivARB(GLint size, GLint* weights) {
// 	(*ptrglWeightivARB)(size, weights);
// }
// void goglWeightfvARB(GLint size, GLfloat* weights) {
// 	(*ptrglWeightfvARB)(size, weights);
// }
// void goglWeightdvARB(GLint size, GLdouble* weights) {
// 	(*ptrglWeightdvARB)(size, weights);
// }
// void goglWeightubvARB(GLint size, GLubyte* weights) {
// 	(*ptrglWeightubvARB)(size, weights);
// }
// void goglWeightusvARB(GLint size, GLushort* weights) {
// 	(*ptrglWeightusvARB)(size, weights);
// }
// void goglWeightuivARB(GLint size, GLuint* weights) {
// 	(*ptrglWeightuivARB)(size, weights);
// }
// void goglWeightPointerARB(GLint size, GLenum type_, GLsizei stride, GLvoid* pointer) {
// 	(*ptrglWeightPointerARB)(size, type_, stride, pointer);
// }
// void goglVertexBlendARB(GLint count) {
// 	(*ptrglVertexBlendARB)(count);
// }
// //  ARB_vertex_buffer_object
// void goglBindBufferARB(GLenum target, GLuint buffer) {
// 	(*ptrglBindBufferARB)(target, buffer);
// }
// void goglDeleteBuffersARB(GLsizei n, GLuint* buffers) {
// 	(*ptrglDeleteBuffersARB)(n, buffers);
// }
// void goglGenBuffersARB(GLsizei n, GLuint* buffers) {
// 	(*ptrglGenBuffersARB)(n, buffers);
// }
// GLboolean goglIsBufferARB(GLuint buffer) {
// 	return (*ptrglIsBufferARB)(buffer);
// }
// void goglBufferDataARB(GLenum target, GLsizeiptrARB size, GLvoid* data, GLenum usage) {
// 	(*ptrglBufferDataARB)(target, size, data, usage);
// }
// void goglBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data) {
// 	(*ptrglBufferSubDataARB)(target, offset, size, data);
// }
// void goglGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data) {
// 	(*ptrglGetBufferSubDataARB)(target, offset, size, data);
// }
// GLvoid* goglMapBufferARB(GLenum target, GLenum access) {
// 	return (*ptrglMapBufferARB)(target, access);
// }
// GLboolean goglUnmapBufferARB(GLenum target) {
// 	return (*ptrglUnmapBufferARB)(target);
// }
// void goglGetBufferParameterivARB(GLenum target, GLenum pname, GLint* params) {
// 	(*ptrglGetBufferParameterivARB)(target, pname, params);
// }
// void goglGetBufferPointervARB(GLenum target, GLenum pname, GLvoid** params) {
// 	(*ptrglGetBufferPointervARB)(target, pname, params);
// }
// //  ARB_vertex_program
// void goglVertexAttrib1dARB(GLuint index, GLdouble x) {
// 	(*ptrglVertexAttrib1dARB)(index, x);
// }
// void goglVertexAttrib1dvARB(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttrib1dvARB)(index, v);
// }
// void goglVertexAttrib1fARB(GLuint index, GLfloat x) {
// 	(*ptrglVertexAttrib1fARB)(index, x);
// }
// void goglVertexAttrib1fvARB(GLuint index, GLfloat* v) {
// 	(*ptrglVertexAttrib1fvARB)(index, v);
// }
// void goglVertexAttrib1sARB(GLuint index, GLshort x) {
// 	(*ptrglVertexAttrib1sARB)(index, x);
// }
// void goglVertexAttrib1svARB(GLuint index, GLshort* v) {
// 	(*ptrglVertexAttrib1svARB)(index, v);
// }
// void goglVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y) {
// 	(*ptrglVertexAttrib2dARB)(index, x, y);
// }
// void goglVertexAttrib2dvARB(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttrib2dvARB)(index, v);
// }
// void goglVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) {
// 	(*ptrglVertexAttrib2fARB)(index, x, y);
// }
// void goglVertexAttrib2fvARB(GLuint index, GLfloat* v) {
// 	(*ptrglVertexAttrib2fvARB)(index, v);
// }
// void goglVertexAttrib2sARB(GLuint index, GLshort x, GLshort y) {
// 	(*ptrglVertexAttrib2sARB)(index, x, y);
// }
// void goglVertexAttrib2svARB(GLuint index, GLshort* v) {
// 	(*ptrglVertexAttrib2svARB)(index, v);
// }
// void goglVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z) {
// 	(*ptrglVertexAttrib3dARB)(index, x, y, z);
// }
// void goglVertexAttrib3dvARB(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttrib3dvARB)(index, v);
// }
// void goglVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
// 	(*ptrglVertexAttrib3fARB)(index, x, y, z);
// }
// void goglVertexAttrib3fvARB(GLuint index, GLfloat* v) {
// 	(*ptrglVertexAttrib3fvARB)(index, v);
// }
// void goglVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z) {
// 	(*ptrglVertexAttrib3sARB)(index, x, y, z);
// }
// void goglVertexAttrib3svARB(GLuint index, GLshort* v) {
// 	(*ptrglVertexAttrib3svARB)(index, v);
// }
// void goglVertexAttrib4NbvARB(GLuint index, GLbyte* v) {
// 	(*ptrglVertexAttrib4NbvARB)(index, v);
// }
// void goglVertexAttrib4NivARB(GLuint index, GLint* v) {
// 	(*ptrglVertexAttrib4NivARB)(index, v);
// }
// void goglVertexAttrib4NsvARB(GLuint index, GLshort* v) {
// 	(*ptrglVertexAttrib4NsvARB)(index, v);
// }
// void goglVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
// 	(*ptrglVertexAttrib4NubARB)(index, x, y, z, w);
// }
// void goglVertexAttrib4NubvARB(GLuint index, GLubyte* v) {
// 	(*ptrglVertexAttrib4NubvARB)(index, v);
// }
// void goglVertexAttrib4NuivARB(GLuint index, GLuint* v) {
// 	(*ptrglVertexAttrib4NuivARB)(index, v);
// }
// void goglVertexAttrib4NusvARB(GLuint index, GLushort* v) {
// 	(*ptrglVertexAttrib4NusvARB)(index, v);
// }
// void goglVertexAttrib4bvARB(GLuint index, GLbyte* v) {
// 	(*ptrglVertexAttrib4bvARB)(index, v);
// }
// void goglVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
// 	(*ptrglVertexAttrib4dARB)(index, x, y, z, w);
// }
// void goglVertexAttrib4dvARB(GLuint index, GLdouble* v) {
// 	(*ptrglVertexAttrib4dvARB)(index, v);
// }
// void goglVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
// 	(*ptrglVertexAttrib4fARB)(index, x, y, z, w);
// }
// void goglVertexAttrib4fvARB(GLuint index, GLfloat* v) {
// 	(*ptrglVertexAttrib4fvARB)(index, v);
// }
// void goglVertexAttrib4ivARB(GLuint index, GLint* v) {
// 	(*ptrglVertexAttrib4ivARB)(index, v);
// }
// void goglVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
// 	(*ptrglVertexAttrib4sARB)(index, x, y, z, w);
// }
// void goglVertexAttrib4svARB(GLuint index, GLshort* v) {
// 	(*ptrglVertexAttrib4svARB)(index, v);
// }
// void goglVertexAttrib4ubvARB(GLuint index, GLubyte* v) {
// 	(*ptrglVertexAttrib4ubvARB)(index, v);
// }
// void goglVertexAttrib4uivARB(GLuint index, GLuint* v) {
// 	(*ptrglVertexAttrib4uivARB)(index, v);
// }
// void goglVertexAttrib4usvARB(GLuint index, GLushort* v) {
// 	(*ptrglVertexAttrib4usvARB)(index, v);
// }
// void goglVertexAttribPointerARB(GLuint index, GLint size, GLenum type_, GLboolean normalized, GLsizei stride, GLvoid* pointer) {
// 	(*ptrglVertexAttribPointerARB)(index, size, type_, normalized, stride, pointer);
// }
// void goglEnableVertexAttribArrayARB(GLuint index) {
// 	(*ptrglEnableVertexAttribArrayARB)(index);
// }
// void goglDisableVertexAttribArrayARB(GLuint index) {
// 	(*ptrglDisableVertexAttribArrayARB)(index);
// }
// void goglProgramStringARB(GLenum target, GLenum format, GLsizei len, GLvoid* string_) {
// 	(*ptrglProgramStringARB)(target, format, len, string_);
// }
// void goglBindProgramARB(GLenum target, GLuint program) {
// 	(*ptrglBindProgramARB)(target, program);
// }
// void goglDeleteProgramsARB(GLsizei n, GLuint* programs) {
// 	(*ptrglDeleteProgramsARB)(n, programs);
// }
// void goglGenProgramsARB(GLsizei n, GLuint* programs) {
// 	(*ptrglGenProgramsARB)(n, programs);
// }
// void goglProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
// 	(*ptrglProgramEnvParameter4dARB)(target, index, x, y, z, w);
// }
// void goglProgramEnvParameter4dvARB(GLenum target, GLuint index, GLdouble* params) {
// 	(*ptrglProgramEnvParameter4dvARB)(target, index, params);
// }
// void goglProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
// 	(*ptrglProgramEnvParameter4fARB)(target, index, x, y, z, w);
// }
// void goglProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat* params) {
// 	(*ptrglProgramEnvParameter4fvARB)(target, index, params);
// }
// void goglProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
// 	(*ptrglProgramLocalParameter4dARB)(target, index, x, y, z, w);
// }
// void goglProgramLocalParameter4dvARB(GLenum target, GLuint index, GLdouble* params) {
// 	(*ptrglProgramLocalParameter4dvARB)(target, index, params);
// }
// void goglProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
// 	(*ptrglProgramLocalParameter4fARB)(target, index, x, y, z, w);
// }
// void goglProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat* params) {
// 	(*ptrglProgramLocalParameter4fvARB)(target, index, params);
// }
// void goglGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble* params) {
// 	(*ptrglGetProgramEnvParameterdvARB)(target, index, params);
// }
// void goglGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat* params) {
// 	(*ptrglGetProgramEnvParameterfvARB)(target, index, params);
// }
// void goglGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble* params) {
// 	(*ptrglGetProgramLocalParameterdvARB)(target, index, params);
// }
// void goglGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat* params) {
// 	(*ptrglGetProgramLocalParameterfvARB)(target, index, params);
// }
// void goglGetProgramivARB(GLenum target, GLenum pname, GLint* params) {
// 	(*ptrglGetProgramivARB)(target, pname, params);
// }
// void goglGetProgramStringARB(GLenum target, GLenum pname, GLvoid* string_) {
// 	(*ptrglGetProgramStringARB)(target, pname, string_);
// }
// void goglGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble* params) {
// 	(*ptrglGetVertexAttribdvARB)(index, pname, params);
// }
// void goglGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat* params) {
// 	(*ptrglGetVertexAttribfvARB)(index, pname, params);
// }
// void goglGetVertexAttribivARB(GLuint index, GLenum pname, GLint* params) {
// 	(*ptrglGetVertexAttribivARB)(index, pname, params);
// }
// void goglGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid** pointer) {
// 	(*ptrglGetVertexAttribPointervARB)(index, pname, pointer);
// }
// GLboolean goglIsProgramARB(GLuint program) {
// 	return (*ptrglIsProgramARB)(program);
// }
// //  ARB_vertex_shader
// void goglBindAttribLocationARB(GLhandleARB programObj, GLuint index, GLcharARB* name) {
// 	(*ptrglBindAttribLocationARB)(programObj, index, name);
// }
// void goglGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type_, GLcharARB* name) {
// 	(*ptrglGetActiveAttribARB)(programObj, index, maxLength, length, size, type_, name);
// }
// GLint goglGetAttribLocationARB(GLhandleARB programObj, GLcharARB* name) {
// 	return (*ptrglGetAttribLocationARB)(programObj, name);
// }
// //  ARB_vertex_type_2_10_10_10_rev
// void goglVertexP2ui(GLenum type_, GLuint value) {
// 	(*ptrglVertexP2ui)(type_, value);
// }
// void goglVertexP2uiv(GLenum type_, GLuint* value) {
// 	(*ptrglVertexP2uiv)(type_, value);
// }
// void goglVertexP3ui(GLenum type_, GLuint value) {
// 	(*ptrglVertexP3ui)(type_, value);
// }
// void goglVertexP3uiv(GLenum type_, GLuint* value) {
// 	(*ptrglVertexP3uiv)(type_, value);
// }
// void goglVertexP4ui(GLenum type_, GLuint value) {
// 	(*ptrglVertexP4ui)(type_, value);
// }
// void goglVertexP4uiv(GLenum type_, GLuint* value) {
// 	(*ptrglVertexP4uiv)(type_, value);
// }
// void goglTexCoordP1ui(GLenum type_, GLuint coords) {
// 	(*ptrglTexCoordP1ui)(type_, coords);
// }
// void goglTexCoordP1uiv(GLenum type_, GLuint* coords) {
// 	(*ptrglTexCoordP1uiv)(type_, coords);
// }
// void goglTexCoordP2ui(GLenum type_, GLuint coords) {
// 	(*ptrglTexCoordP2ui)(type_, coords);
// }
// void goglTexCoordP2uiv(GLenum type_, GLuint* coords) {
// 	(*ptrglTexCoordP2uiv)(type_, coords);
// }
// void goglTexCoordP3ui(GLenum type_, GLuint coords) {
// 	(*ptrglTexCoordP3ui)(type_, coords);
// }
// void goglTexCoordP3uiv(GLenum type_, GLuint* coords) {
// 	(*ptrglTexCoordP3uiv)(type_, coords);
// }
// void goglTexCoordP4ui(GLenum type_, GLuint coords) {
// 	(*ptrglTexCoordP4ui)(type_, coords);
// }
// void goglTexCoordP4uiv(GLenum type_, GLuint* coords) {
// 	(*ptrglTexCoordP4uiv)(type_, coords);
// }
// void goglMultiTexCoordP1ui(GLenum texture, GLenum type_, GLuint coords) {
// 	(*ptrglMultiTexCoordP1ui)(texture, type_, coords);
// }
// void goglMultiTexCoordP1uiv(GLenum texture, GLenum type_, GLuint* coords) {
// 	(*ptrglMultiTexCoordP1uiv)(texture, type_, coords);
// }
// void goglMultiTexCoordP2ui(GLenum texture, GLenum type_, GLuint coords) {
// 	(*ptrglMultiTexCoordP2ui)(texture, type_, coords);
// }
// void goglMultiTexCoordP2uiv(GLenum texture, GLenum type_, GLuint* coords) {
// 	(*ptrglMultiTexCoordP2uiv)(texture, type_, coords);
// }
// void goglMultiTexCoordP3ui(GLenum texture, GLenum type_, GLuint coords) {
// 	(*ptrglMultiTexCoordP3ui)(texture, type_, coords);
// }
// void goglMultiTexCoordP3uiv(GLenum texture, GLenum type_, GLuint* coords) {
// 	(*ptrglMultiTexCoordP3uiv)(texture, type_, coords);
// }
// void goglMultiTexCoordP4ui(GLenum texture, GLenum type_, GLuint coords) {
// 	(*ptrglMultiTexCoordP4ui)(texture, type_, coords);
// }
// void goglMultiTexCoordP4uiv(GLenum texture, GLenum type_, GLuint* coords) {
// 	(*ptrglMultiTexCoordP4uiv)(texture, type_, coords);
// }
// void goglNormalP3ui(GLenum type_, GLuint coords) {
// 	(*ptrglNormalP3ui)(type_, coords);
// }
// void goglNormalP3uiv(GLenum type_, GLuint* coords) {
// 	(*ptrglNormalP3uiv)(type_, coords);
// }
// void goglColorP3ui(GLenum type_, GLuint color) {
// 	(*ptrglColorP3ui)(type_, color);
// }
// void goglColorP3uiv(GLenum type_, GLuint* color) {
// 	(*ptrglColorP3uiv)(type_, color);
// }
// void goglColorP4ui(GLenum type_, GLuint color) {
// 	(*ptrglColorP4ui)(type_, color);
// }
// void goglColorP4uiv(GLenum type_, GLuint* color) {
// 	(*ptrglColorP4uiv)(type_, color);
// }
// void goglSecondaryColorP3ui(GLenum type_, GLuint color) {
// 	(*ptrglSecondaryColorP3ui)(type_, color);
// }
// void goglSecondaryColorP3uiv(GLenum type_, GLuint* color) {
// 	(*ptrglSecondaryColorP3uiv)(type_, color);
// }
// void goglVertexAttribP1ui(GLuint index, GLenum type_, GLboolean normalized, GLuint value) {
// 	(*ptrglVertexAttribP1ui)(index, type_, normalized, value);
// }
// void goglVertexAttribP1uiv(GLuint index, GLenum type_, GLboolean normalized, GLuint* value) {
// 	(*ptrglVertexAttribP1uiv)(index, type_, normalized, value);
// }
// void goglVertexAttribP2ui(GLuint index, GLenum type_, GLboolean normalized, GLuint value) {
// 	(*ptrglVertexAttribP2ui)(index, type_, normalized, value);
// }
// void goglVertexAttribP2uiv(GLuint index, GLenum type_, GLboolean normalized, GLuint* value) {
// 	(*ptrglVertexAttribP2uiv)(index, type_, normalized, value);
// }
// void goglVertexAttribP3ui(GLuint index, GLenum type_, GLboolean normalized, GLuint value) {
// 	(*ptrglVertexAttribP3ui)(index, type_, normalized, value);
// }
// void goglVertexAttribP3uiv(GLuint index, GLenum type_, GLboolean normalized, GLuint* value) {
// 	(*ptrglVertexAttribP3uiv)(index, type_, normalized, value);
// }
// void goglVertexAttribP4ui(GLuint index, GLenum type_, GLboolean normalized, GLuint value) {
// 	(*ptrglVertexAttribP4ui)(index, type_, normalized, value);
// }
// void goglVertexAttribP4uiv(GLuint index, GLenum type_, GLboolean normalized, GLuint* value) {
// 	(*ptrglVertexAttribP4uiv)(index, type_, normalized, value);
// }
// //  ARB_viewport_array
// void goglViewportArrayv(GLuint first, GLsizei count, GLfloat* v) {
// 	(*ptrglViewportArrayv)(first, count, v);
// }
// void goglViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
// 	(*ptrglViewportIndexedf)(index, x, y, w, h);
// }
// void goglViewportIndexedfv(GLuint index, GLfloat* v) {
// 	(*ptrglViewportIndexedfv)(index, v);
// }
// void goglScissorArrayv(GLuint first, GLsizei count, GLint* v) {
// 	(*ptrglScissorArrayv)(first, count, v);
// }
// void goglScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
// 	(*ptrglScissorIndexed)(index, left, bottom, width, height);
// }
// void goglScissorIndexedv(GLuint index, GLint* v) {
// 	(*ptrglScissorIndexedv)(index, v);
// }
// void goglDepthRangeArrayv(GLuint first, GLsizei count, GLdouble* v) {
// 	(*ptrglDepthRangeArrayv)(first, count, v);
// }
// void goglDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f) {
// 	(*ptrglDepthRangeIndexed)(index, n, f);
// }
// void goglGetFloati_v(GLenum target, GLuint index, GLfloat* data) {
// 	(*ptrglGetFloati_v)(target, index, data);
// }
// void goglGetDoublei_v(GLenum target, GLuint index, GLdouble* data) {
// 	(*ptrglGetDoublei_v)(target, index, data);
// }
// //  ARB_window_pos
// void goglWindowPos2dARB(GLdouble x, GLdouble y) {
// 	(*ptrglWindowPos2dARB)(x, y);
// }
// void goglWindowPos2dvARB(GLdouble* v) {
// 	(*ptrglWindowPos2dvARB)(v);
// }
// void goglWindowPos2fARB(GLfloat x, GLfloat y) {
// 	(*ptrglWindowPos2fARB)(x, y);
// }
// void goglWindowPos2fvARB(GLfloat* v) {
// 	(*ptrglWindowPos2fvARB)(v);
// }
// void goglWindowPos2iARB(GLint x, GLint y) {
// 	(*ptrglWindowPos2iARB)(x, y);
// }
// void goglWindowPos2ivARB(GLint* v) {
// 	(*ptrglWindowPos2ivARB)(v);
// }
// void goglWindowPos2sARB(GLshort x, GLshort y) {
// 	(*ptrglWindowPos2sARB)(x, y);
// }
// void goglWindowPos2svARB(GLshort* v) {
// 	(*ptrglWindowPos2svARB)(v);
// }
// void goglWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z) {
// 	(*ptrglWindowPos3dARB)(x, y, z);
// }
// void goglWindowPos3dvARB(GLdouble* v) {
// 	(*ptrglWindowPos3dvARB)(v);
// }
// void goglWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z) {
// 	(*ptrglWindowPos3fARB)(x, y, z);
// }
// void goglWindowPos3fvARB(GLfloat* v) {
// 	(*ptrglWindowPos3fvARB)(v);
// }
// void goglWindowPos3iARB(GLint x, GLint y, GLint z) {
// 	(*ptrglWindowPos3iARB)(x, y, z);
// }
// void goglWindowPos3ivARB(GLint* v) {
// 	(*ptrglWindowPos3ivARB)(v);
// }
// void goglWindowPos3sARB(GLshort x, GLshort y, GLshort z) {
// 	(*ptrglWindowPos3sARB)(x, y, z);
// }
// void goglWindowPos3svARB(GLshort* v) {
// 	(*ptrglWindowPos3svARB)(v);
// }
// 
// int init_ARB_ES2_compatibility() {
// 	ptrglReleaseShaderCompiler = goglGetProcAddress("glReleaseShaderCompiler");
// 	if(ptrglReleaseShaderCompiler == NULL) return 1;
// 	ptrglShaderBinary = goglGetProcAddress("glShaderBinary");
// 	if(ptrglShaderBinary == NULL) return 1;
// 	ptrglGetShaderPrecisionFormat = goglGetProcAddress("glGetShaderPrecisionFormat");
// 	if(ptrglGetShaderPrecisionFormat == NULL) return 1;
// 	ptrglDepthRangef = goglGetProcAddress("glDepthRangef");
// 	if(ptrglDepthRangef == NULL) return 1;
// 	ptrglClearDepthf = goglGetProcAddress("glClearDepthf");
// 	if(ptrglClearDepthf == NULL) return 1;
// 	return 0;
// }
// int init_ARB_base_instance() {
// 	ptrglDrawArraysInstancedBaseInstance = goglGetProcAddress("glDrawArraysInstancedBaseInstance");
// 	if(ptrglDrawArraysInstancedBaseInstance == NULL) return 1;
// 	ptrglDrawElementsInstancedBaseInstance = goglGetProcAddress("glDrawElementsInstancedBaseInstance");
// 	if(ptrglDrawElementsInstancedBaseInstance == NULL) return 1;
// 	ptrglDrawElementsInstancedBaseVertexBaseInstance = goglGetProcAddress("glDrawElementsInstancedBaseVertexBaseInstance");
// 	if(ptrglDrawElementsInstancedBaseVertexBaseInstance == NULL) return 1;
// 	return 0;
// }
// int init_ARB_blend_func_extended() {
// 	ptrglBindFragDataLocationIndexed = goglGetProcAddress("glBindFragDataLocationIndexed");
// 	if(ptrglBindFragDataLocationIndexed == NULL) return 1;
// 	ptrglGetFragDataIndex = goglGetProcAddress("glGetFragDataIndex");
// 	if(ptrglGetFragDataIndex == NULL) return 1;
// 	return 0;
// }
// int init_ARB_cl_event() {
// 	ptrglCreateSyncFromCLeventARB = goglGetProcAddress("glCreateSyncFromCLeventARB");
// 	if(ptrglCreateSyncFromCLeventARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_clear_buffer_object() {
// 	ptrglClearBufferData = goglGetProcAddress("glClearBufferData");
// 	if(ptrglClearBufferData == NULL) return 1;
// 	ptrglClearBufferSubData = goglGetProcAddress("glClearBufferSubData");
// 	if(ptrglClearBufferSubData == NULL) return 1;
// 	ptrglClearNamedBufferDataEXT = goglGetProcAddress("glClearNamedBufferDataEXT");
// 	if(ptrglClearNamedBufferDataEXT == NULL) return 1;
// 	ptrglClearNamedBufferSubDataEXT = goglGetProcAddress("glClearNamedBufferSubDataEXT");
// 	if(ptrglClearNamedBufferSubDataEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_color_buffer_float() {
// 	ptrglClampColorARB = goglGetProcAddress("glClampColorARB");
// 	if(ptrglClampColorARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_compute_shader() {
// 	ptrglDispatchCompute = goglGetProcAddress("glDispatchCompute");
// 	if(ptrglDispatchCompute == NULL) return 1;
// 	ptrglDispatchComputeIndirect = goglGetProcAddress("glDispatchComputeIndirect");
// 	if(ptrglDispatchComputeIndirect == NULL) return 1;
// 	return 0;
// }
// int init_ARB_copy_buffer() {
// 	ptrglCopyBufferSubData = goglGetProcAddress("glCopyBufferSubData");
// 	if(ptrglCopyBufferSubData == NULL) return 1;
// 	return 0;
// }
// int init_ARB_copy_image() {
// 	ptrglCopyImageSubData = goglGetProcAddress("glCopyImageSubData");
// 	if(ptrglCopyImageSubData == NULL) return 1;
// 	return 0;
// }
// int init_ARB_debug_output() {
// 	ptrglDebugMessageControlARB = goglGetProcAddress("glDebugMessageControlARB");
// 	if(ptrglDebugMessageControlARB == NULL) return 1;
// 	ptrglDebugMessageInsertARB = goglGetProcAddress("glDebugMessageInsertARB");
// 	if(ptrglDebugMessageInsertARB == NULL) return 1;
// 	ptrglDebugMessageCallbackARB = goglGetProcAddress("glDebugMessageCallbackARB");
// 	if(ptrglDebugMessageCallbackARB == NULL) return 1;
// 	ptrglGetDebugMessageLogARB = goglGetProcAddress("glGetDebugMessageLogARB");
// 	if(ptrglGetDebugMessageLogARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_draw_buffers() {
// 	ptrglDrawBuffersARB = goglGetProcAddress("glDrawBuffersARB");
// 	if(ptrglDrawBuffersARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_draw_buffers_blend() {
// 	ptrglBlendEquationiARB = goglGetProcAddress("glBlendEquationiARB");
// 	if(ptrglBlendEquationiARB == NULL) return 1;
// 	ptrglBlendEquationSeparateiARB = goglGetProcAddress("glBlendEquationSeparateiARB");
// 	if(ptrglBlendEquationSeparateiARB == NULL) return 1;
// 	ptrglBlendFunciARB = goglGetProcAddress("glBlendFunciARB");
// 	if(ptrglBlendFunciARB == NULL) return 1;
// 	ptrglBlendFuncSeparateiARB = goglGetProcAddress("glBlendFuncSeparateiARB");
// 	if(ptrglBlendFuncSeparateiARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_draw_elements_base_vertex() {
// 	ptrglDrawElementsBaseVertex = goglGetProcAddress("glDrawElementsBaseVertex");
// 	if(ptrglDrawElementsBaseVertex == NULL) return 1;
// 	ptrglDrawRangeElementsBaseVertex = goglGetProcAddress("glDrawRangeElementsBaseVertex");
// 	if(ptrglDrawRangeElementsBaseVertex == NULL) return 1;
// 	ptrglDrawElementsInstancedBaseVertex = goglGetProcAddress("glDrawElementsInstancedBaseVertex");
// 	if(ptrglDrawElementsInstancedBaseVertex == NULL) return 1;
// 	ptrglMultiDrawElementsBaseVertex = goglGetProcAddress("glMultiDrawElementsBaseVertex");
// 	if(ptrglMultiDrawElementsBaseVertex == NULL) return 1;
// 	return 0;
// }
// int init_ARB_draw_indirect() {
// 	ptrglDrawArraysIndirect = goglGetProcAddress("glDrawArraysIndirect");
// 	if(ptrglDrawArraysIndirect == NULL) return 1;
// 	ptrglDrawElementsIndirect = goglGetProcAddress("glDrawElementsIndirect");
// 	if(ptrglDrawElementsIndirect == NULL) return 1;
// 	return 0;
// }
// int init_ARB_draw_instanced() {
// 	ptrglDrawArraysInstancedARB = goglGetProcAddress("glDrawArraysInstancedARB");
// 	if(ptrglDrawArraysInstancedARB == NULL) return 1;
// 	ptrglDrawElementsInstancedARB = goglGetProcAddress("glDrawElementsInstancedARB");
// 	if(ptrglDrawElementsInstancedARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_framebuffer_no_attachments() {
// 	ptrglFramebufferParameteri = goglGetProcAddress("glFramebufferParameteri");
// 	if(ptrglFramebufferParameteri == NULL) return 1;
// 	ptrglGetFramebufferParameteriv = goglGetProcAddress("glGetFramebufferParameteriv");
// 	if(ptrglGetFramebufferParameteriv == NULL) return 1;
// 	ptrglNamedFramebufferParameteriEXT = goglGetProcAddress("glNamedFramebufferParameteriEXT");
// 	if(ptrglNamedFramebufferParameteriEXT == NULL) return 1;
// 	ptrglGetNamedFramebufferParameterivEXT = goglGetProcAddress("glGetNamedFramebufferParameterivEXT");
// 	if(ptrglGetNamedFramebufferParameterivEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_framebuffer_object() {
// 	ptrglIsRenderbuffer = goglGetProcAddress("glIsRenderbuffer");
// 	if(ptrglIsRenderbuffer == NULL) return 1;
// 	ptrglBindRenderbuffer = goglGetProcAddress("glBindRenderbuffer");
// 	if(ptrglBindRenderbuffer == NULL) return 1;
// 	ptrglDeleteRenderbuffers = goglGetProcAddress("glDeleteRenderbuffers");
// 	if(ptrglDeleteRenderbuffers == NULL) return 1;
// 	ptrglGenRenderbuffers = goglGetProcAddress("glGenRenderbuffers");
// 	if(ptrglGenRenderbuffers == NULL) return 1;
// 	ptrglRenderbufferStorage = goglGetProcAddress("glRenderbufferStorage");
// 	if(ptrglRenderbufferStorage == NULL) return 1;
// 	ptrglGetRenderbufferParameteriv = goglGetProcAddress("glGetRenderbufferParameteriv");
// 	if(ptrglGetRenderbufferParameteriv == NULL) return 1;
// 	ptrglIsFramebuffer = goglGetProcAddress("glIsFramebuffer");
// 	if(ptrglIsFramebuffer == NULL) return 1;
// 	ptrglBindFramebuffer = goglGetProcAddress("glBindFramebuffer");
// 	if(ptrglBindFramebuffer == NULL) return 1;
// 	ptrglDeleteFramebuffers = goglGetProcAddress("glDeleteFramebuffers");
// 	if(ptrglDeleteFramebuffers == NULL) return 1;
// 	ptrglGenFramebuffers = goglGetProcAddress("glGenFramebuffers");
// 	if(ptrglGenFramebuffers == NULL) return 1;
// 	ptrglCheckFramebufferStatus = goglGetProcAddress("glCheckFramebufferStatus");
// 	if(ptrglCheckFramebufferStatus == NULL) return 1;
// 	ptrglFramebufferTexture1D = goglGetProcAddress("glFramebufferTexture1D");
// 	if(ptrglFramebufferTexture1D == NULL) return 1;
// 	ptrglFramebufferTexture2D = goglGetProcAddress("glFramebufferTexture2D");
// 	if(ptrglFramebufferTexture2D == NULL) return 1;
// 	ptrglFramebufferTexture3D = goglGetProcAddress("glFramebufferTexture3D");
// 	if(ptrglFramebufferTexture3D == NULL) return 1;
// 	ptrglFramebufferRenderbuffer = goglGetProcAddress("glFramebufferRenderbuffer");
// 	if(ptrglFramebufferRenderbuffer == NULL) return 1;
// 	ptrglGetFramebufferAttachmentParameteriv = goglGetProcAddress("glGetFramebufferAttachmentParameteriv");
// 	if(ptrglGetFramebufferAttachmentParameteriv == NULL) return 1;
// 	ptrglGenerateMipmap = goglGetProcAddress("glGenerateMipmap");
// 	if(ptrglGenerateMipmap == NULL) return 1;
// 	ptrglBlitFramebuffer = goglGetProcAddress("glBlitFramebuffer");
// 	if(ptrglBlitFramebuffer == NULL) return 1;
// 	ptrglRenderbufferStorageMultisample = goglGetProcAddress("glRenderbufferStorageMultisample");
// 	if(ptrglRenderbufferStorageMultisample == NULL) return 1;
// 	ptrglFramebufferTextureLayer = goglGetProcAddress("glFramebufferTextureLayer");
// 	if(ptrglFramebufferTextureLayer == NULL) return 1;
// 	return 0;
// }
// int init_ARB_geometry_shader4() {
// 	ptrglProgramParameteriARB = goglGetProcAddress("glProgramParameteriARB");
// 	if(ptrglProgramParameteriARB == NULL) return 1;
// 	ptrglFramebufferTextureARB = goglGetProcAddress("glFramebufferTextureARB");
// 	if(ptrglFramebufferTextureARB == NULL) return 1;
// 	ptrglFramebufferTextureLayerARB = goglGetProcAddress("glFramebufferTextureLayerARB");
// 	if(ptrglFramebufferTextureLayerARB == NULL) return 1;
// 	ptrglFramebufferTextureFaceARB = goglGetProcAddress("glFramebufferTextureFaceARB");
// 	if(ptrglFramebufferTextureFaceARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_get_program_binary() {
// 	ptrglGetProgramBinary = goglGetProcAddress("glGetProgramBinary");
// 	if(ptrglGetProgramBinary == NULL) return 1;
// 	ptrglProgramBinary = goglGetProcAddress("glProgramBinary");
// 	if(ptrglProgramBinary == NULL) return 1;
// 	ptrglProgramParameteri = goglGetProcAddress("glProgramParameteri");
// 	if(ptrglProgramParameteri == NULL) return 1;
// 	return 0;
// }
// int init_ARB_gpu_shader_fp64() {
// 	ptrglUniform1d = goglGetProcAddress("glUniform1d");
// 	if(ptrglUniform1d == NULL) return 1;
// 	ptrglUniform2d = goglGetProcAddress("glUniform2d");
// 	if(ptrglUniform2d == NULL) return 1;
// 	ptrglUniform3d = goglGetProcAddress("glUniform3d");
// 	if(ptrglUniform3d == NULL) return 1;
// 	ptrglUniform4d = goglGetProcAddress("glUniform4d");
// 	if(ptrglUniform4d == NULL) return 1;
// 	ptrglUniform1dv = goglGetProcAddress("glUniform1dv");
// 	if(ptrglUniform1dv == NULL) return 1;
// 	ptrglUniform2dv = goglGetProcAddress("glUniform2dv");
// 	if(ptrglUniform2dv == NULL) return 1;
// 	ptrglUniform3dv = goglGetProcAddress("glUniform3dv");
// 	if(ptrglUniform3dv == NULL) return 1;
// 	ptrglUniform4dv = goglGetProcAddress("glUniform4dv");
// 	if(ptrglUniform4dv == NULL) return 1;
// 	ptrglUniformMatrix2dv = goglGetProcAddress("glUniformMatrix2dv");
// 	if(ptrglUniformMatrix2dv == NULL) return 1;
// 	ptrglUniformMatrix3dv = goglGetProcAddress("glUniformMatrix3dv");
// 	if(ptrglUniformMatrix3dv == NULL) return 1;
// 	ptrglUniformMatrix4dv = goglGetProcAddress("glUniformMatrix4dv");
// 	if(ptrglUniformMatrix4dv == NULL) return 1;
// 	ptrglUniformMatrix2x3dv = goglGetProcAddress("glUniformMatrix2x3dv");
// 	if(ptrglUniformMatrix2x3dv == NULL) return 1;
// 	ptrglUniformMatrix2x4dv = goglGetProcAddress("glUniformMatrix2x4dv");
// 	if(ptrglUniformMatrix2x4dv == NULL) return 1;
// 	ptrglUniformMatrix3x2dv = goglGetProcAddress("glUniformMatrix3x2dv");
// 	if(ptrglUniformMatrix3x2dv == NULL) return 1;
// 	ptrglUniformMatrix3x4dv = goglGetProcAddress("glUniformMatrix3x4dv");
// 	if(ptrglUniformMatrix3x4dv == NULL) return 1;
// 	ptrglUniformMatrix4x2dv = goglGetProcAddress("glUniformMatrix4x2dv");
// 	if(ptrglUniformMatrix4x2dv == NULL) return 1;
// 	ptrglUniformMatrix4x3dv = goglGetProcAddress("glUniformMatrix4x3dv");
// 	if(ptrglUniformMatrix4x3dv == NULL) return 1;
// 	ptrglGetUniformdv = goglGetProcAddress("glGetUniformdv");
// 	if(ptrglGetUniformdv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_instanced_arrays() {
// 	ptrglVertexAttribDivisorARB = goglGetProcAddress("glVertexAttribDivisorARB");
// 	if(ptrglVertexAttribDivisorARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_internalformat_query() {
// 	ptrglGetInternalformativ = goglGetProcAddress("glGetInternalformativ");
// 	if(ptrglGetInternalformativ == NULL) return 1;
// 	return 0;
// }
// int init_ARB_internalformat_query2() {
// 	ptrglGetInternalformati64v = goglGetProcAddress("glGetInternalformati64v");
// 	if(ptrglGetInternalformati64v == NULL) return 1;
// 	return 0;
// }
// int init_ARB_invalidate_subdata() {
// 	ptrglInvalidateTexSubImage = goglGetProcAddress("glInvalidateTexSubImage");
// 	if(ptrglInvalidateTexSubImage == NULL) return 1;
// 	ptrglInvalidateTexImage = goglGetProcAddress("glInvalidateTexImage");
// 	if(ptrglInvalidateTexImage == NULL) return 1;
// 	ptrglInvalidateBufferSubData = goglGetProcAddress("glInvalidateBufferSubData");
// 	if(ptrglInvalidateBufferSubData == NULL) return 1;
// 	ptrglInvalidateBufferData = goglGetProcAddress("glInvalidateBufferData");
// 	if(ptrglInvalidateBufferData == NULL) return 1;
// 	ptrglInvalidateFramebuffer = goglGetProcAddress("glInvalidateFramebuffer");
// 	if(ptrglInvalidateFramebuffer == NULL) return 1;
// 	ptrglInvalidateSubFramebuffer = goglGetProcAddress("glInvalidateSubFramebuffer");
// 	if(ptrglInvalidateSubFramebuffer == NULL) return 1;
// 	return 0;
// }
// int init_ARB_map_buffer_range() {
// 	ptrglMapBufferRange = goglGetProcAddress("glMapBufferRange");
// 	if(ptrglMapBufferRange == NULL) return 1;
// 	ptrglFlushMappedBufferRange = goglGetProcAddress("glFlushMappedBufferRange");
// 	if(ptrglFlushMappedBufferRange == NULL) return 1;
// 	return 0;
// }
// int init_ARB_matrix_palette() {
// 	ptrglCurrentPaletteMatrixARB = goglGetProcAddress("glCurrentPaletteMatrixARB");
// 	if(ptrglCurrentPaletteMatrixARB == NULL) return 1;
// 	ptrglMatrixIndexubvARB = goglGetProcAddress("glMatrixIndexubvARB");
// 	if(ptrglMatrixIndexubvARB == NULL) return 1;
// 	ptrglMatrixIndexusvARB = goglGetProcAddress("glMatrixIndexusvARB");
// 	if(ptrglMatrixIndexusvARB == NULL) return 1;
// 	ptrglMatrixIndexuivARB = goglGetProcAddress("glMatrixIndexuivARB");
// 	if(ptrglMatrixIndexuivARB == NULL) return 1;
// 	ptrglMatrixIndexPointerARB = goglGetProcAddress("glMatrixIndexPointerARB");
// 	if(ptrglMatrixIndexPointerARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_multi_draw_indirect() {
// 	ptrglMultiDrawArraysIndirect = goglGetProcAddress("glMultiDrawArraysIndirect");
// 	if(ptrglMultiDrawArraysIndirect == NULL) return 1;
// 	ptrglMultiDrawElementsIndirect = goglGetProcAddress("glMultiDrawElementsIndirect");
// 	if(ptrglMultiDrawElementsIndirect == NULL) return 1;
// 	return 0;
// }
// int init_ARB_multisample() {
// 	ptrglSampleCoverageARB = goglGetProcAddress("glSampleCoverageARB");
// 	if(ptrglSampleCoverageARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_multitexture() {
// 	ptrglActiveTextureARB = goglGetProcAddress("glActiveTextureARB");
// 	if(ptrglActiveTextureARB == NULL) return 1;
// 	ptrglClientActiveTextureARB = goglGetProcAddress("glClientActiveTextureARB");
// 	if(ptrglClientActiveTextureARB == NULL) return 1;
// 	ptrglMultiTexCoord1dARB = goglGetProcAddress("glMultiTexCoord1dARB");
// 	if(ptrglMultiTexCoord1dARB == NULL) return 1;
// 	ptrglMultiTexCoord1dvARB = goglGetProcAddress("glMultiTexCoord1dvARB");
// 	if(ptrglMultiTexCoord1dvARB == NULL) return 1;
// 	ptrglMultiTexCoord1fARB = goglGetProcAddress("glMultiTexCoord1fARB");
// 	if(ptrglMultiTexCoord1fARB == NULL) return 1;
// 	ptrglMultiTexCoord1fvARB = goglGetProcAddress("glMultiTexCoord1fvARB");
// 	if(ptrglMultiTexCoord1fvARB == NULL) return 1;
// 	ptrglMultiTexCoord1iARB = goglGetProcAddress("glMultiTexCoord1iARB");
// 	if(ptrglMultiTexCoord1iARB == NULL) return 1;
// 	ptrglMultiTexCoord1ivARB = goglGetProcAddress("glMultiTexCoord1ivARB");
// 	if(ptrglMultiTexCoord1ivARB == NULL) return 1;
// 	ptrglMultiTexCoord1sARB = goglGetProcAddress("glMultiTexCoord1sARB");
// 	if(ptrglMultiTexCoord1sARB == NULL) return 1;
// 	ptrglMultiTexCoord1svARB = goglGetProcAddress("glMultiTexCoord1svARB");
// 	if(ptrglMultiTexCoord1svARB == NULL) return 1;
// 	ptrglMultiTexCoord2dARB = goglGetProcAddress("glMultiTexCoord2dARB");
// 	if(ptrglMultiTexCoord2dARB == NULL) return 1;
// 	ptrglMultiTexCoord2dvARB = goglGetProcAddress("glMultiTexCoord2dvARB");
// 	if(ptrglMultiTexCoord2dvARB == NULL) return 1;
// 	ptrglMultiTexCoord2fARB = goglGetProcAddress("glMultiTexCoord2fARB");
// 	if(ptrglMultiTexCoord2fARB == NULL) return 1;
// 	ptrglMultiTexCoord2fvARB = goglGetProcAddress("glMultiTexCoord2fvARB");
// 	if(ptrglMultiTexCoord2fvARB == NULL) return 1;
// 	ptrglMultiTexCoord2iARB = goglGetProcAddress("glMultiTexCoord2iARB");
// 	if(ptrglMultiTexCoord2iARB == NULL) return 1;
// 	ptrglMultiTexCoord2ivARB = goglGetProcAddress("glMultiTexCoord2ivARB");
// 	if(ptrglMultiTexCoord2ivARB == NULL) return 1;
// 	ptrglMultiTexCoord2sARB = goglGetProcAddress("glMultiTexCoord2sARB");
// 	if(ptrglMultiTexCoord2sARB == NULL) return 1;
// 	ptrglMultiTexCoord2svARB = goglGetProcAddress("glMultiTexCoord2svARB");
// 	if(ptrglMultiTexCoord2svARB == NULL) return 1;
// 	ptrglMultiTexCoord3dARB = goglGetProcAddress("glMultiTexCoord3dARB");
// 	if(ptrglMultiTexCoord3dARB == NULL) return 1;
// 	ptrglMultiTexCoord3dvARB = goglGetProcAddress("glMultiTexCoord3dvARB");
// 	if(ptrglMultiTexCoord3dvARB == NULL) return 1;
// 	ptrglMultiTexCoord3fARB = goglGetProcAddress("glMultiTexCoord3fARB");
// 	if(ptrglMultiTexCoord3fARB == NULL) return 1;
// 	ptrglMultiTexCoord3fvARB = goglGetProcAddress("glMultiTexCoord3fvARB");
// 	if(ptrglMultiTexCoord3fvARB == NULL) return 1;
// 	ptrglMultiTexCoord3iARB = goglGetProcAddress("glMultiTexCoord3iARB");
// 	if(ptrglMultiTexCoord3iARB == NULL) return 1;
// 	ptrglMultiTexCoord3ivARB = goglGetProcAddress("glMultiTexCoord3ivARB");
// 	if(ptrglMultiTexCoord3ivARB == NULL) return 1;
// 	ptrglMultiTexCoord3sARB = goglGetProcAddress("glMultiTexCoord3sARB");
// 	if(ptrglMultiTexCoord3sARB == NULL) return 1;
// 	ptrglMultiTexCoord3svARB = goglGetProcAddress("glMultiTexCoord3svARB");
// 	if(ptrglMultiTexCoord3svARB == NULL) return 1;
// 	ptrglMultiTexCoord4dARB = goglGetProcAddress("glMultiTexCoord4dARB");
// 	if(ptrglMultiTexCoord4dARB == NULL) return 1;
// 	ptrglMultiTexCoord4dvARB = goglGetProcAddress("glMultiTexCoord4dvARB");
// 	if(ptrglMultiTexCoord4dvARB == NULL) return 1;
// 	ptrglMultiTexCoord4fARB = goglGetProcAddress("glMultiTexCoord4fARB");
// 	if(ptrglMultiTexCoord4fARB == NULL) return 1;
// 	ptrglMultiTexCoord4fvARB = goglGetProcAddress("glMultiTexCoord4fvARB");
// 	if(ptrglMultiTexCoord4fvARB == NULL) return 1;
// 	ptrglMultiTexCoord4iARB = goglGetProcAddress("glMultiTexCoord4iARB");
// 	if(ptrglMultiTexCoord4iARB == NULL) return 1;
// 	ptrglMultiTexCoord4ivARB = goglGetProcAddress("glMultiTexCoord4ivARB");
// 	if(ptrglMultiTexCoord4ivARB == NULL) return 1;
// 	ptrglMultiTexCoord4sARB = goglGetProcAddress("glMultiTexCoord4sARB");
// 	if(ptrglMultiTexCoord4sARB == NULL) return 1;
// 	ptrglMultiTexCoord4svARB = goglGetProcAddress("glMultiTexCoord4svARB");
// 	if(ptrglMultiTexCoord4svARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_occlusion_query() {
// 	ptrglGenQueriesARB = goglGetProcAddress("glGenQueriesARB");
// 	if(ptrglGenQueriesARB == NULL) return 1;
// 	ptrglDeleteQueriesARB = goglGetProcAddress("glDeleteQueriesARB");
// 	if(ptrglDeleteQueriesARB == NULL) return 1;
// 	ptrglIsQueryARB = goglGetProcAddress("glIsQueryARB");
// 	if(ptrglIsQueryARB == NULL) return 1;
// 	ptrglBeginQueryARB = goglGetProcAddress("glBeginQueryARB");
// 	if(ptrglBeginQueryARB == NULL) return 1;
// 	ptrglEndQueryARB = goglGetProcAddress("glEndQueryARB");
// 	if(ptrglEndQueryARB == NULL) return 1;
// 	ptrglGetQueryivARB = goglGetProcAddress("glGetQueryivARB");
// 	if(ptrglGetQueryivARB == NULL) return 1;
// 	ptrglGetQueryObjectivARB = goglGetProcAddress("glGetQueryObjectivARB");
// 	if(ptrglGetQueryObjectivARB == NULL) return 1;
// 	ptrglGetQueryObjectuivARB = goglGetProcAddress("glGetQueryObjectuivARB");
// 	if(ptrglGetQueryObjectuivARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_point_parameters() {
// 	ptrglPointParameterfARB = goglGetProcAddress("glPointParameterfARB");
// 	if(ptrglPointParameterfARB == NULL) return 1;
// 	ptrglPointParameterfvARB = goglGetProcAddress("glPointParameterfvARB");
// 	if(ptrglPointParameterfvARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_program_interface_query() {
// 	ptrglGetProgramInterfaceiv = goglGetProcAddress("glGetProgramInterfaceiv");
// 	if(ptrglGetProgramInterfaceiv == NULL) return 1;
// 	ptrglGetProgramResourceIndex = goglGetProcAddress("glGetProgramResourceIndex");
// 	if(ptrglGetProgramResourceIndex == NULL) return 1;
// 	ptrglGetProgramResourceName = goglGetProcAddress("glGetProgramResourceName");
// 	if(ptrglGetProgramResourceName == NULL) return 1;
// 	ptrglGetProgramResourceiv = goglGetProcAddress("glGetProgramResourceiv");
// 	if(ptrglGetProgramResourceiv == NULL) return 1;
// 	ptrglGetProgramResourceLocation = goglGetProcAddress("glGetProgramResourceLocation");
// 	if(ptrglGetProgramResourceLocation == NULL) return 1;
// 	ptrglGetProgramResourceLocationIndex = goglGetProcAddress("glGetProgramResourceLocationIndex");
// 	if(ptrglGetProgramResourceLocationIndex == NULL) return 1;
// 	return 0;
// }
// int init_ARB_provoking_vertex() {
// 	ptrglProvokingVertex = goglGetProcAddress("glProvokingVertex");
// 	if(ptrglProvokingVertex == NULL) return 1;
// 	return 0;
// }
// int init_ARB_robustness() {
// 	ptrglGetGraphicsResetStatusARB = goglGetProcAddress("glGetGraphicsResetStatusARB");
// 	if(ptrglGetGraphicsResetStatusARB == NULL) return 1;
// 	ptrglGetnMapdvARB = goglGetProcAddress("glGetnMapdvARB");
// 	if(ptrglGetnMapdvARB == NULL) return 1;
// 	ptrglGetnMapfvARB = goglGetProcAddress("glGetnMapfvARB");
// 	if(ptrglGetnMapfvARB == NULL) return 1;
// 	ptrglGetnMapivARB = goglGetProcAddress("glGetnMapivARB");
// 	if(ptrglGetnMapivARB == NULL) return 1;
// 	ptrglGetnPixelMapfvARB = goglGetProcAddress("glGetnPixelMapfvARB");
// 	if(ptrglGetnPixelMapfvARB == NULL) return 1;
// 	ptrglGetnPixelMapuivARB = goglGetProcAddress("glGetnPixelMapuivARB");
// 	if(ptrglGetnPixelMapuivARB == NULL) return 1;
// 	ptrglGetnPixelMapusvARB = goglGetProcAddress("glGetnPixelMapusvARB");
// 	if(ptrglGetnPixelMapusvARB == NULL) return 1;
// 	ptrglGetnPolygonStippleARB = goglGetProcAddress("glGetnPolygonStippleARB");
// 	if(ptrglGetnPolygonStippleARB == NULL) return 1;
// 	ptrglGetnColorTableARB = goglGetProcAddress("glGetnColorTableARB");
// 	if(ptrglGetnColorTableARB == NULL) return 1;
// 	ptrglGetnConvolutionFilterARB = goglGetProcAddress("glGetnConvolutionFilterARB");
// 	if(ptrglGetnConvolutionFilterARB == NULL) return 1;
// 	ptrglGetnSeparableFilterARB = goglGetProcAddress("glGetnSeparableFilterARB");
// 	if(ptrglGetnSeparableFilterARB == NULL) return 1;
// 	ptrglGetnHistogramARB = goglGetProcAddress("glGetnHistogramARB");
// 	if(ptrglGetnHistogramARB == NULL) return 1;
// 	ptrglGetnMinmaxARB = goglGetProcAddress("glGetnMinmaxARB");
// 	if(ptrglGetnMinmaxARB == NULL) return 1;
// 	ptrglGetnTexImageARB = goglGetProcAddress("glGetnTexImageARB");
// 	if(ptrglGetnTexImageARB == NULL) return 1;
// 	ptrglReadnPixelsARB = goglGetProcAddress("glReadnPixelsARB");
// 	if(ptrglReadnPixelsARB == NULL) return 1;
// 	ptrglGetnCompressedTexImageARB = goglGetProcAddress("glGetnCompressedTexImageARB");
// 	if(ptrglGetnCompressedTexImageARB == NULL) return 1;
// 	ptrglGetnUniformfvARB = goglGetProcAddress("glGetnUniformfvARB");
// 	if(ptrglGetnUniformfvARB == NULL) return 1;
// 	ptrglGetnUniformivARB = goglGetProcAddress("glGetnUniformivARB");
// 	if(ptrglGetnUniformivARB == NULL) return 1;
// 	ptrglGetnUniformuivARB = goglGetProcAddress("glGetnUniformuivARB");
// 	if(ptrglGetnUniformuivARB == NULL) return 1;
// 	ptrglGetnUniformdvARB = goglGetProcAddress("glGetnUniformdvARB");
// 	if(ptrglGetnUniformdvARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_sample_shading() {
// 	ptrglMinSampleShadingARB = goglGetProcAddress("glMinSampleShadingARB");
// 	if(ptrglMinSampleShadingARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_sampler_objects() {
// 	ptrglGenSamplers = goglGetProcAddress("glGenSamplers");
// 	if(ptrglGenSamplers == NULL) return 1;
// 	ptrglDeleteSamplers = goglGetProcAddress("glDeleteSamplers");
// 	if(ptrglDeleteSamplers == NULL) return 1;
// 	ptrglIsSampler = goglGetProcAddress("glIsSampler");
// 	if(ptrglIsSampler == NULL) return 1;
// 	ptrglBindSampler = goglGetProcAddress("glBindSampler");
// 	if(ptrglBindSampler == NULL) return 1;
// 	ptrglSamplerParameteri = goglGetProcAddress("glSamplerParameteri");
// 	if(ptrglSamplerParameteri == NULL) return 1;
// 	ptrglSamplerParameteriv = goglGetProcAddress("glSamplerParameteriv");
// 	if(ptrglSamplerParameteriv == NULL) return 1;
// 	ptrglSamplerParameterf = goglGetProcAddress("glSamplerParameterf");
// 	if(ptrglSamplerParameterf == NULL) return 1;
// 	ptrglSamplerParameterfv = goglGetProcAddress("glSamplerParameterfv");
// 	if(ptrglSamplerParameterfv == NULL) return 1;
// 	ptrglSamplerParameterIiv = goglGetProcAddress("glSamplerParameterIiv");
// 	if(ptrglSamplerParameterIiv == NULL) return 1;
// 	ptrglSamplerParameterIuiv = goglGetProcAddress("glSamplerParameterIuiv");
// 	if(ptrglSamplerParameterIuiv == NULL) return 1;
// 	ptrglGetSamplerParameteriv = goglGetProcAddress("glGetSamplerParameteriv");
// 	if(ptrglGetSamplerParameteriv == NULL) return 1;
// 	ptrglGetSamplerParameterIiv = goglGetProcAddress("glGetSamplerParameterIiv");
// 	if(ptrglGetSamplerParameterIiv == NULL) return 1;
// 	ptrglGetSamplerParameterfv = goglGetProcAddress("glGetSamplerParameterfv");
// 	if(ptrglGetSamplerParameterfv == NULL) return 1;
// 	ptrglGetSamplerParameterIuiv = goglGetProcAddress("glGetSamplerParameterIuiv");
// 	if(ptrglGetSamplerParameterIuiv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_separate_shader_objects() {
// 	ptrglUseProgramStages = goglGetProcAddress("glUseProgramStages");
// 	if(ptrglUseProgramStages == NULL) return 1;
// 	ptrglActiveShaderProgram = goglGetProcAddress("glActiveShaderProgram");
// 	if(ptrglActiveShaderProgram == NULL) return 1;
// 	ptrglCreateShaderProgramv = goglGetProcAddress("glCreateShaderProgramv");
// 	if(ptrglCreateShaderProgramv == NULL) return 1;
// 	ptrglBindProgramPipeline = goglGetProcAddress("glBindProgramPipeline");
// 	if(ptrglBindProgramPipeline == NULL) return 1;
// 	ptrglDeleteProgramPipelines = goglGetProcAddress("glDeleteProgramPipelines");
// 	if(ptrglDeleteProgramPipelines == NULL) return 1;
// 	ptrglGenProgramPipelines = goglGetProcAddress("glGenProgramPipelines");
// 	if(ptrglGenProgramPipelines == NULL) return 1;
// 	ptrglIsProgramPipeline = goglGetProcAddress("glIsProgramPipeline");
// 	if(ptrglIsProgramPipeline == NULL) return 1;
// 	ptrglGetProgramPipelineiv = goglGetProcAddress("glGetProgramPipelineiv");
// 	if(ptrglGetProgramPipelineiv == NULL) return 1;
// 	ptrglProgramUniform1i = goglGetProcAddress("glProgramUniform1i");
// 	if(ptrglProgramUniform1i == NULL) return 1;
// 	ptrglProgramUniform1iv = goglGetProcAddress("glProgramUniform1iv");
// 	if(ptrglProgramUniform1iv == NULL) return 1;
// 	ptrglProgramUniform1f = goglGetProcAddress("glProgramUniform1f");
// 	if(ptrglProgramUniform1f == NULL) return 1;
// 	ptrglProgramUniform1fv = goglGetProcAddress("glProgramUniform1fv");
// 	if(ptrglProgramUniform1fv == NULL) return 1;
// 	ptrglProgramUniform1d = goglGetProcAddress("glProgramUniform1d");
// 	if(ptrglProgramUniform1d == NULL) return 1;
// 	ptrglProgramUniform1dv = goglGetProcAddress("glProgramUniform1dv");
// 	if(ptrglProgramUniform1dv == NULL) return 1;
// 	ptrglProgramUniform1ui = goglGetProcAddress("glProgramUniform1ui");
// 	if(ptrglProgramUniform1ui == NULL) return 1;
// 	ptrglProgramUniform1uiv = goglGetProcAddress("glProgramUniform1uiv");
// 	if(ptrglProgramUniform1uiv == NULL) return 1;
// 	ptrglProgramUniform2i = goglGetProcAddress("glProgramUniform2i");
// 	if(ptrglProgramUniform2i == NULL) return 1;
// 	ptrglProgramUniform2iv = goglGetProcAddress("glProgramUniform2iv");
// 	if(ptrglProgramUniform2iv == NULL) return 1;
// 	ptrglProgramUniform2f = goglGetProcAddress("glProgramUniform2f");
// 	if(ptrglProgramUniform2f == NULL) return 1;
// 	ptrglProgramUniform2fv = goglGetProcAddress("glProgramUniform2fv");
// 	if(ptrglProgramUniform2fv == NULL) return 1;
// 	ptrglProgramUniform2d = goglGetProcAddress("glProgramUniform2d");
// 	if(ptrglProgramUniform2d == NULL) return 1;
// 	ptrglProgramUniform2dv = goglGetProcAddress("glProgramUniform2dv");
// 	if(ptrglProgramUniform2dv == NULL) return 1;
// 	ptrglProgramUniform2ui = goglGetProcAddress("glProgramUniform2ui");
// 	if(ptrglProgramUniform2ui == NULL) return 1;
// 	ptrglProgramUniform2uiv = goglGetProcAddress("glProgramUniform2uiv");
// 	if(ptrglProgramUniform2uiv == NULL) return 1;
// 	ptrglProgramUniform3i = goglGetProcAddress("glProgramUniform3i");
// 	if(ptrglProgramUniform3i == NULL) return 1;
// 	ptrglProgramUniform3iv = goglGetProcAddress("glProgramUniform3iv");
// 	if(ptrglProgramUniform3iv == NULL) return 1;
// 	ptrglProgramUniform3f = goglGetProcAddress("glProgramUniform3f");
// 	if(ptrglProgramUniform3f == NULL) return 1;
// 	ptrglProgramUniform3fv = goglGetProcAddress("glProgramUniform3fv");
// 	if(ptrglProgramUniform3fv == NULL) return 1;
// 	ptrglProgramUniform3d = goglGetProcAddress("glProgramUniform3d");
// 	if(ptrglProgramUniform3d == NULL) return 1;
// 	ptrglProgramUniform3dv = goglGetProcAddress("glProgramUniform3dv");
// 	if(ptrglProgramUniform3dv == NULL) return 1;
// 	ptrglProgramUniform3ui = goglGetProcAddress("glProgramUniform3ui");
// 	if(ptrglProgramUniform3ui == NULL) return 1;
// 	ptrglProgramUniform3uiv = goglGetProcAddress("glProgramUniform3uiv");
// 	if(ptrglProgramUniform3uiv == NULL) return 1;
// 	ptrglProgramUniform4i = goglGetProcAddress("glProgramUniform4i");
// 	if(ptrglProgramUniform4i == NULL) return 1;
// 	ptrglProgramUniform4iv = goglGetProcAddress("glProgramUniform4iv");
// 	if(ptrglProgramUniform4iv == NULL) return 1;
// 	ptrglProgramUniform4f = goglGetProcAddress("glProgramUniform4f");
// 	if(ptrglProgramUniform4f == NULL) return 1;
// 	ptrglProgramUniform4fv = goglGetProcAddress("glProgramUniform4fv");
// 	if(ptrglProgramUniform4fv == NULL) return 1;
// 	ptrglProgramUniform4d = goglGetProcAddress("glProgramUniform4d");
// 	if(ptrglProgramUniform4d == NULL) return 1;
// 	ptrglProgramUniform4dv = goglGetProcAddress("glProgramUniform4dv");
// 	if(ptrglProgramUniform4dv == NULL) return 1;
// 	ptrglProgramUniform4ui = goglGetProcAddress("glProgramUniform4ui");
// 	if(ptrglProgramUniform4ui == NULL) return 1;
// 	ptrglProgramUniform4uiv = goglGetProcAddress("glProgramUniform4uiv");
// 	if(ptrglProgramUniform4uiv == NULL) return 1;
// 	ptrglProgramUniformMatrix2fv = goglGetProcAddress("glProgramUniformMatrix2fv");
// 	if(ptrglProgramUniformMatrix2fv == NULL) return 1;
// 	ptrglProgramUniformMatrix3fv = goglGetProcAddress("glProgramUniformMatrix3fv");
// 	if(ptrglProgramUniformMatrix3fv == NULL) return 1;
// 	ptrglProgramUniformMatrix4fv = goglGetProcAddress("glProgramUniformMatrix4fv");
// 	if(ptrglProgramUniformMatrix4fv == NULL) return 1;
// 	ptrglProgramUniformMatrix2dv = goglGetProcAddress("glProgramUniformMatrix2dv");
// 	if(ptrglProgramUniformMatrix2dv == NULL) return 1;
// 	ptrglProgramUniformMatrix3dv = goglGetProcAddress("glProgramUniformMatrix3dv");
// 	if(ptrglProgramUniformMatrix3dv == NULL) return 1;
// 	ptrglProgramUniformMatrix4dv = goglGetProcAddress("glProgramUniformMatrix4dv");
// 	if(ptrglProgramUniformMatrix4dv == NULL) return 1;
// 	ptrglProgramUniformMatrix2x3fv = goglGetProcAddress("glProgramUniformMatrix2x3fv");
// 	if(ptrglProgramUniformMatrix2x3fv == NULL) return 1;
// 	ptrglProgramUniformMatrix3x2fv = goglGetProcAddress("glProgramUniformMatrix3x2fv");
// 	if(ptrglProgramUniformMatrix3x2fv == NULL) return 1;
// 	ptrglProgramUniformMatrix2x4fv = goglGetProcAddress("glProgramUniformMatrix2x4fv");
// 	if(ptrglProgramUniformMatrix2x4fv == NULL) return 1;
// 	ptrglProgramUniformMatrix4x2fv = goglGetProcAddress("glProgramUniformMatrix4x2fv");
// 	if(ptrglProgramUniformMatrix4x2fv == NULL) return 1;
// 	ptrglProgramUniformMatrix3x4fv = goglGetProcAddress("glProgramUniformMatrix3x4fv");
// 	if(ptrglProgramUniformMatrix3x4fv == NULL) return 1;
// 	ptrglProgramUniformMatrix4x3fv = goglGetProcAddress("glProgramUniformMatrix4x3fv");
// 	if(ptrglProgramUniformMatrix4x3fv == NULL) return 1;
// 	ptrglProgramUniformMatrix2x3dv = goglGetProcAddress("glProgramUniformMatrix2x3dv");
// 	if(ptrglProgramUniformMatrix2x3dv == NULL) return 1;
// 	ptrglProgramUniformMatrix3x2dv = goglGetProcAddress("glProgramUniformMatrix3x2dv");
// 	if(ptrglProgramUniformMatrix3x2dv == NULL) return 1;
// 	ptrglProgramUniformMatrix2x4dv = goglGetProcAddress("glProgramUniformMatrix2x4dv");
// 	if(ptrglProgramUniformMatrix2x4dv == NULL) return 1;
// 	ptrglProgramUniformMatrix4x2dv = goglGetProcAddress("glProgramUniformMatrix4x2dv");
// 	if(ptrglProgramUniformMatrix4x2dv == NULL) return 1;
// 	ptrglProgramUniformMatrix3x4dv = goglGetProcAddress("glProgramUniformMatrix3x4dv");
// 	if(ptrglProgramUniformMatrix3x4dv == NULL) return 1;
// 	ptrglProgramUniformMatrix4x3dv = goglGetProcAddress("glProgramUniformMatrix4x3dv");
// 	if(ptrglProgramUniformMatrix4x3dv == NULL) return 1;
// 	ptrglValidateProgramPipeline = goglGetProcAddress("glValidateProgramPipeline");
// 	if(ptrglValidateProgramPipeline == NULL) return 1;
// 	ptrglGetProgramPipelineInfoLog = goglGetProcAddress("glGetProgramPipelineInfoLog");
// 	if(ptrglGetProgramPipelineInfoLog == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shader_atomic_counters() {
// 	ptrglGetActiveAtomicCounterBufferiv = goglGetProcAddress("glGetActiveAtomicCounterBufferiv");
// 	if(ptrglGetActiveAtomicCounterBufferiv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shader_image_load_store() {
// 	ptrglBindImageTexture = goglGetProcAddress("glBindImageTexture");
// 	if(ptrglBindImageTexture == NULL) return 1;
// 	ptrglMemoryBarrier = goglGetProcAddress("glMemoryBarrier");
// 	if(ptrglMemoryBarrier == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shader_objects() {
// 	ptrglDeleteObjectARB = goglGetProcAddress("glDeleteObjectARB");
// 	if(ptrglDeleteObjectARB == NULL) return 1;
// 	ptrglGetHandleARB = goglGetProcAddress("glGetHandleARB");
// 	if(ptrglGetHandleARB == NULL) return 1;
// 	ptrglDetachObjectARB = goglGetProcAddress("glDetachObjectARB");
// 	if(ptrglDetachObjectARB == NULL) return 1;
// 	ptrglCreateShaderObjectARB = goglGetProcAddress("glCreateShaderObjectARB");
// 	if(ptrglCreateShaderObjectARB == NULL) return 1;
// 	ptrglShaderSourceARB = goglGetProcAddress("glShaderSourceARB");
// 	if(ptrglShaderSourceARB == NULL) return 1;
// 	ptrglCompileShaderARB = goglGetProcAddress("glCompileShaderARB");
// 	if(ptrglCompileShaderARB == NULL) return 1;
// 	ptrglCreateProgramObjectARB = goglGetProcAddress("glCreateProgramObjectARB");
// 	if(ptrglCreateProgramObjectARB == NULL) return 1;
// 	ptrglAttachObjectARB = goglGetProcAddress("glAttachObjectARB");
// 	if(ptrglAttachObjectARB == NULL) return 1;
// 	ptrglLinkProgramARB = goglGetProcAddress("glLinkProgramARB");
// 	if(ptrglLinkProgramARB == NULL) return 1;
// 	ptrglUseProgramObjectARB = goglGetProcAddress("glUseProgramObjectARB");
// 	if(ptrglUseProgramObjectARB == NULL) return 1;
// 	ptrglValidateProgramARB = goglGetProcAddress("glValidateProgramARB");
// 	if(ptrglValidateProgramARB == NULL) return 1;
// 	ptrglUniform1fARB = goglGetProcAddress("glUniform1fARB");
// 	if(ptrglUniform1fARB == NULL) return 1;
// 	ptrglUniform2fARB = goglGetProcAddress("glUniform2fARB");
// 	if(ptrglUniform2fARB == NULL) return 1;
// 	ptrglUniform3fARB = goglGetProcAddress("glUniform3fARB");
// 	if(ptrglUniform3fARB == NULL) return 1;
// 	ptrglUniform4fARB = goglGetProcAddress("glUniform4fARB");
// 	if(ptrglUniform4fARB == NULL) return 1;
// 	ptrglUniform1iARB = goglGetProcAddress("glUniform1iARB");
// 	if(ptrglUniform1iARB == NULL) return 1;
// 	ptrglUniform2iARB = goglGetProcAddress("glUniform2iARB");
// 	if(ptrglUniform2iARB == NULL) return 1;
// 	ptrglUniform3iARB = goglGetProcAddress("glUniform3iARB");
// 	if(ptrglUniform3iARB == NULL) return 1;
// 	ptrglUniform4iARB = goglGetProcAddress("glUniform4iARB");
// 	if(ptrglUniform4iARB == NULL) return 1;
// 	ptrglUniform1fvARB = goglGetProcAddress("glUniform1fvARB");
// 	if(ptrglUniform1fvARB == NULL) return 1;
// 	ptrglUniform2fvARB = goglGetProcAddress("glUniform2fvARB");
// 	if(ptrglUniform2fvARB == NULL) return 1;
// 	ptrglUniform3fvARB = goglGetProcAddress("glUniform3fvARB");
// 	if(ptrglUniform3fvARB == NULL) return 1;
// 	ptrglUniform4fvARB = goglGetProcAddress("glUniform4fvARB");
// 	if(ptrglUniform4fvARB == NULL) return 1;
// 	ptrglUniform1ivARB = goglGetProcAddress("glUniform1ivARB");
// 	if(ptrglUniform1ivARB == NULL) return 1;
// 	ptrglUniform2ivARB = goglGetProcAddress("glUniform2ivARB");
// 	if(ptrglUniform2ivARB == NULL) return 1;
// 	ptrglUniform3ivARB = goglGetProcAddress("glUniform3ivARB");
// 	if(ptrglUniform3ivARB == NULL) return 1;
// 	ptrglUniform4ivARB = goglGetProcAddress("glUniform4ivARB");
// 	if(ptrglUniform4ivARB == NULL) return 1;
// 	ptrglUniformMatrix2fvARB = goglGetProcAddress("glUniformMatrix2fvARB");
// 	if(ptrglUniformMatrix2fvARB == NULL) return 1;
// 	ptrglUniformMatrix3fvARB = goglGetProcAddress("glUniformMatrix3fvARB");
// 	if(ptrglUniformMatrix3fvARB == NULL) return 1;
// 	ptrglUniformMatrix4fvARB = goglGetProcAddress("glUniformMatrix4fvARB");
// 	if(ptrglUniformMatrix4fvARB == NULL) return 1;
// 	ptrglGetObjectParameterfvARB = goglGetProcAddress("glGetObjectParameterfvARB");
// 	if(ptrglGetObjectParameterfvARB == NULL) return 1;
// 	ptrglGetObjectParameterivARB = goglGetProcAddress("glGetObjectParameterivARB");
// 	if(ptrglGetObjectParameterivARB == NULL) return 1;
// 	ptrglGetInfoLogARB = goglGetProcAddress("glGetInfoLogARB");
// 	if(ptrglGetInfoLogARB == NULL) return 1;
// 	ptrglGetAttachedObjectsARB = goglGetProcAddress("glGetAttachedObjectsARB");
// 	if(ptrglGetAttachedObjectsARB == NULL) return 1;
// 	ptrglGetUniformLocationARB = goglGetProcAddress("glGetUniformLocationARB");
// 	if(ptrglGetUniformLocationARB == NULL) return 1;
// 	ptrglGetActiveUniformARB = goglGetProcAddress("glGetActiveUniformARB");
// 	if(ptrglGetActiveUniformARB == NULL) return 1;
// 	ptrglGetUniformfvARB = goglGetProcAddress("glGetUniformfvARB");
// 	if(ptrglGetUniformfvARB == NULL) return 1;
// 	ptrglGetUniformivARB = goglGetProcAddress("glGetUniformivARB");
// 	if(ptrglGetUniformivARB == NULL) return 1;
// 	ptrglGetShaderSourceARB = goglGetProcAddress("glGetShaderSourceARB");
// 	if(ptrglGetShaderSourceARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shader_storage_buffer_object() {
// 	ptrglShaderStorageBlockBinding = goglGetProcAddress("glShaderStorageBlockBinding");
// 	if(ptrglShaderStorageBlockBinding == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shader_subroutine() {
// 	ptrglGetSubroutineUniformLocation = goglGetProcAddress("glGetSubroutineUniformLocation");
// 	if(ptrglGetSubroutineUniformLocation == NULL) return 1;
// 	ptrglGetSubroutineIndex = goglGetProcAddress("glGetSubroutineIndex");
// 	if(ptrglGetSubroutineIndex == NULL) return 1;
// 	ptrglGetActiveSubroutineUniformiv = goglGetProcAddress("glGetActiveSubroutineUniformiv");
// 	if(ptrglGetActiveSubroutineUniformiv == NULL) return 1;
// 	ptrglGetActiveSubroutineUniformName = goglGetProcAddress("glGetActiveSubroutineUniformName");
// 	if(ptrglGetActiveSubroutineUniformName == NULL) return 1;
// 	ptrglGetActiveSubroutineName = goglGetProcAddress("glGetActiveSubroutineName");
// 	if(ptrglGetActiveSubroutineName == NULL) return 1;
// 	ptrglUniformSubroutinesuiv = goglGetProcAddress("glUniformSubroutinesuiv");
// 	if(ptrglUniformSubroutinesuiv == NULL) return 1;
// 	ptrglGetUniformSubroutineuiv = goglGetProcAddress("glGetUniformSubroutineuiv");
// 	if(ptrglGetUniformSubroutineuiv == NULL) return 1;
// 	ptrglGetProgramStageiv = goglGetProcAddress("glGetProgramStageiv");
// 	if(ptrglGetProgramStageiv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_shading_language_include() {
// 	ptrglNamedStringARB = goglGetProcAddress("glNamedStringARB");
// 	if(ptrglNamedStringARB == NULL) return 1;
// 	ptrglDeleteNamedStringARB = goglGetProcAddress("glDeleteNamedStringARB");
// 	if(ptrglDeleteNamedStringARB == NULL) return 1;
// 	ptrglCompileShaderIncludeARB = goglGetProcAddress("glCompileShaderIncludeARB");
// 	if(ptrglCompileShaderIncludeARB == NULL) return 1;
// 	ptrglIsNamedStringARB = goglGetProcAddress("glIsNamedStringARB");
// 	if(ptrglIsNamedStringARB == NULL) return 1;
// 	ptrglGetNamedStringARB = goglGetProcAddress("glGetNamedStringARB");
// 	if(ptrglGetNamedStringARB == NULL) return 1;
// 	ptrglGetNamedStringivARB = goglGetProcAddress("glGetNamedStringivARB");
// 	if(ptrglGetNamedStringivARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_sync() {
// 	ptrglFenceSync = goglGetProcAddress("glFenceSync");
// 	if(ptrglFenceSync == NULL) return 1;
// 	ptrglIsSync = goglGetProcAddress("glIsSync");
// 	if(ptrglIsSync == NULL) return 1;
// 	ptrglDeleteSync = goglGetProcAddress("glDeleteSync");
// 	if(ptrglDeleteSync == NULL) return 1;
// 	ptrglClientWaitSync = goglGetProcAddress("glClientWaitSync");
// 	if(ptrglClientWaitSync == NULL) return 1;
// 	ptrglWaitSync = goglGetProcAddress("glWaitSync");
// 	if(ptrglWaitSync == NULL) return 1;
// 	ptrglGetInteger64v = goglGetProcAddress("glGetInteger64v");
// 	if(ptrglGetInteger64v == NULL) return 1;
// 	ptrglGetSynciv = goglGetProcAddress("glGetSynciv");
// 	if(ptrglGetSynciv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_tessellation_shader() {
// 	ptrglPatchParameteri = goglGetProcAddress("glPatchParameteri");
// 	if(ptrglPatchParameteri == NULL) return 1;
// 	ptrglPatchParameterfv = goglGetProcAddress("glPatchParameterfv");
// 	if(ptrglPatchParameterfv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_buffer_object() {
// 	ptrglTexBufferARB = goglGetProcAddress("glTexBufferARB");
// 	if(ptrglTexBufferARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_buffer_range() {
// 	ptrglTexBufferRange = goglGetProcAddress("glTexBufferRange");
// 	if(ptrglTexBufferRange == NULL) return 1;
// 	ptrglTextureBufferRangeEXT = goglGetProcAddress("glTextureBufferRangeEXT");
// 	if(ptrglTextureBufferRangeEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_compression() {
// 	ptrglCompressedTexImage3DARB = goglGetProcAddress("glCompressedTexImage3DARB");
// 	if(ptrglCompressedTexImage3DARB == NULL) return 1;
// 	ptrglCompressedTexImage2DARB = goglGetProcAddress("glCompressedTexImage2DARB");
// 	if(ptrglCompressedTexImage2DARB == NULL) return 1;
// 	ptrglCompressedTexImage1DARB = goglGetProcAddress("glCompressedTexImage1DARB");
// 	if(ptrglCompressedTexImage1DARB == NULL) return 1;
// 	ptrglCompressedTexSubImage3DARB = goglGetProcAddress("glCompressedTexSubImage3DARB");
// 	if(ptrglCompressedTexSubImage3DARB == NULL) return 1;
// 	ptrglCompressedTexSubImage2DARB = goglGetProcAddress("glCompressedTexSubImage2DARB");
// 	if(ptrglCompressedTexSubImage2DARB == NULL) return 1;
// 	ptrglCompressedTexSubImage1DARB = goglGetProcAddress("glCompressedTexSubImage1DARB");
// 	if(ptrglCompressedTexSubImage1DARB == NULL) return 1;
// 	ptrglGetCompressedTexImageARB = goglGetProcAddress("glGetCompressedTexImageARB");
// 	if(ptrglGetCompressedTexImageARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_multisample() {
// 	ptrglTexImage2DMultisample = goglGetProcAddress("glTexImage2DMultisample");
// 	if(ptrglTexImage2DMultisample == NULL) return 1;
// 	ptrglTexImage3DMultisample = goglGetProcAddress("glTexImage3DMultisample");
// 	if(ptrglTexImage3DMultisample == NULL) return 1;
// 	ptrglGetMultisamplefv = goglGetProcAddress("glGetMultisamplefv");
// 	if(ptrglGetMultisamplefv == NULL) return 1;
// 	ptrglSampleMaski = goglGetProcAddress("glSampleMaski");
// 	if(ptrglSampleMaski == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_storage() {
// 	ptrglTexStorage1D = goglGetProcAddress("glTexStorage1D");
// 	if(ptrglTexStorage1D == NULL) return 1;
// 	ptrglTexStorage2D = goglGetProcAddress("glTexStorage2D");
// 	if(ptrglTexStorage2D == NULL) return 1;
// 	ptrglTexStorage3D = goglGetProcAddress("glTexStorage3D");
// 	if(ptrglTexStorage3D == NULL) return 1;
// 	ptrglTextureStorage1DEXT = goglGetProcAddress("glTextureStorage1DEXT");
// 	if(ptrglTextureStorage1DEXT == NULL) return 1;
// 	ptrglTextureStorage2DEXT = goglGetProcAddress("glTextureStorage2DEXT");
// 	if(ptrglTextureStorage2DEXT == NULL) return 1;
// 	ptrglTextureStorage3DEXT = goglGetProcAddress("glTextureStorage3DEXT");
// 	if(ptrglTextureStorage3DEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_storage_multisample() {
// 	ptrglTexStorage2DMultisample = goglGetProcAddress("glTexStorage2DMultisample");
// 	if(ptrglTexStorage2DMultisample == NULL) return 1;
// 	ptrglTexStorage3DMultisample = goglGetProcAddress("glTexStorage3DMultisample");
// 	if(ptrglTexStorage3DMultisample == NULL) return 1;
// 	ptrglTextureStorage2DMultisampleEXT = goglGetProcAddress("glTextureStorage2DMultisampleEXT");
// 	if(ptrglTextureStorage2DMultisampleEXT == NULL) return 1;
// 	ptrglTextureStorage3DMultisampleEXT = goglGetProcAddress("glTextureStorage3DMultisampleEXT");
// 	if(ptrglTextureStorage3DMultisampleEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_texture_view() {
// 	ptrglTextureView = goglGetProcAddress("glTextureView");
// 	if(ptrglTextureView == NULL) return 1;
// 	return 0;
// }
// int init_ARB_timer_query() {
// 	ptrglQueryCounter = goglGetProcAddress("glQueryCounter");
// 	if(ptrglQueryCounter == NULL) return 1;
// 	ptrglGetQueryObjecti64v = goglGetProcAddress("glGetQueryObjecti64v");
// 	if(ptrglGetQueryObjecti64v == NULL) return 1;
// 	ptrglGetQueryObjectui64v = goglGetProcAddress("glGetQueryObjectui64v");
// 	if(ptrglGetQueryObjectui64v == NULL) return 1;
// 	return 0;
// }
// int init_ARB_transform_feedback2() {
// 	ptrglBindTransformFeedback = goglGetProcAddress("glBindTransformFeedback");
// 	if(ptrglBindTransformFeedback == NULL) return 1;
// 	ptrglDeleteTransformFeedbacks = goglGetProcAddress("glDeleteTransformFeedbacks");
// 	if(ptrglDeleteTransformFeedbacks == NULL) return 1;
// 	ptrglGenTransformFeedbacks = goglGetProcAddress("glGenTransformFeedbacks");
// 	if(ptrglGenTransformFeedbacks == NULL) return 1;
// 	ptrglIsTransformFeedback = goglGetProcAddress("glIsTransformFeedback");
// 	if(ptrglIsTransformFeedback == NULL) return 1;
// 	ptrglPauseTransformFeedback = goglGetProcAddress("glPauseTransformFeedback");
// 	if(ptrglPauseTransformFeedback == NULL) return 1;
// 	ptrglResumeTransformFeedback = goglGetProcAddress("glResumeTransformFeedback");
// 	if(ptrglResumeTransformFeedback == NULL) return 1;
// 	ptrglDrawTransformFeedback = goglGetProcAddress("glDrawTransformFeedback");
// 	if(ptrglDrawTransformFeedback == NULL) return 1;
// 	return 0;
// }
// int init_ARB_transform_feedback3() {
// 	ptrglDrawTransformFeedbackStream = goglGetProcAddress("glDrawTransformFeedbackStream");
// 	if(ptrglDrawTransformFeedbackStream == NULL) return 1;
// 	ptrglBeginQueryIndexed = goglGetProcAddress("glBeginQueryIndexed");
// 	if(ptrglBeginQueryIndexed == NULL) return 1;
// 	ptrglEndQueryIndexed = goglGetProcAddress("glEndQueryIndexed");
// 	if(ptrglEndQueryIndexed == NULL) return 1;
// 	ptrglGetQueryIndexediv = goglGetProcAddress("glGetQueryIndexediv");
// 	if(ptrglGetQueryIndexediv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_transform_feedback_instanced() {
// 	ptrglDrawTransformFeedbackInstanced = goglGetProcAddress("glDrawTransformFeedbackInstanced");
// 	if(ptrglDrawTransformFeedbackInstanced == NULL) return 1;
// 	ptrglDrawTransformFeedbackStreamInstanced = goglGetProcAddress("glDrawTransformFeedbackStreamInstanced");
// 	if(ptrglDrawTransformFeedbackStreamInstanced == NULL) return 1;
// 	return 0;
// }
// int init_ARB_transpose_matrix() {
// 	ptrglLoadTransposeMatrixfARB = goglGetProcAddress("glLoadTransposeMatrixfARB");
// 	if(ptrglLoadTransposeMatrixfARB == NULL) return 1;
// 	ptrglLoadTransposeMatrixdARB = goglGetProcAddress("glLoadTransposeMatrixdARB");
// 	if(ptrglLoadTransposeMatrixdARB == NULL) return 1;
// 	ptrglMultTransposeMatrixfARB = goglGetProcAddress("glMultTransposeMatrixfARB");
// 	if(ptrglMultTransposeMatrixfARB == NULL) return 1;
// 	ptrglMultTransposeMatrixdARB = goglGetProcAddress("glMultTransposeMatrixdARB");
// 	if(ptrglMultTransposeMatrixdARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_uniform_buffer_object() {
// 	ptrglGetUniformIndices = goglGetProcAddress("glGetUniformIndices");
// 	if(ptrglGetUniformIndices == NULL) return 1;
// 	ptrglGetActiveUniformsiv = goglGetProcAddress("glGetActiveUniformsiv");
// 	if(ptrglGetActiveUniformsiv == NULL) return 1;
// 	ptrglGetActiveUniformName = goglGetProcAddress("glGetActiveUniformName");
// 	if(ptrglGetActiveUniformName == NULL) return 1;
// 	ptrglGetUniformBlockIndex = goglGetProcAddress("glGetUniformBlockIndex");
// 	if(ptrglGetUniformBlockIndex == NULL) return 1;
// 	ptrglGetActiveUniformBlockiv = goglGetProcAddress("glGetActiveUniformBlockiv");
// 	if(ptrglGetActiveUniformBlockiv == NULL) return 1;
// 	ptrglGetActiveUniformBlockName = goglGetProcAddress("glGetActiveUniformBlockName");
// 	if(ptrglGetActiveUniformBlockName == NULL) return 1;
// 	ptrglUniformBlockBinding = goglGetProcAddress("glUniformBlockBinding");
// 	if(ptrglUniformBlockBinding == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_array_object() {
// 	ptrglBindVertexArray = goglGetProcAddress("glBindVertexArray");
// 	if(ptrglBindVertexArray == NULL) return 1;
// 	ptrglDeleteVertexArrays = goglGetProcAddress("glDeleteVertexArrays");
// 	if(ptrglDeleteVertexArrays == NULL) return 1;
// 	ptrglGenVertexArrays = goglGetProcAddress("glGenVertexArrays");
// 	if(ptrglGenVertexArrays == NULL) return 1;
// 	ptrglIsVertexArray = goglGetProcAddress("glIsVertexArray");
// 	if(ptrglIsVertexArray == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_attrib_64bit() {
// 	ptrglVertexAttribL1d = goglGetProcAddress("glVertexAttribL1d");
// 	if(ptrglVertexAttribL1d == NULL) return 1;
// 	ptrglVertexAttribL2d = goglGetProcAddress("glVertexAttribL2d");
// 	if(ptrglVertexAttribL2d == NULL) return 1;
// 	ptrglVertexAttribL3d = goglGetProcAddress("glVertexAttribL3d");
// 	if(ptrglVertexAttribL3d == NULL) return 1;
// 	ptrglVertexAttribL4d = goglGetProcAddress("glVertexAttribL4d");
// 	if(ptrglVertexAttribL4d == NULL) return 1;
// 	ptrglVertexAttribL1dv = goglGetProcAddress("glVertexAttribL1dv");
// 	if(ptrglVertexAttribL1dv == NULL) return 1;
// 	ptrglVertexAttribL2dv = goglGetProcAddress("glVertexAttribL2dv");
// 	if(ptrglVertexAttribL2dv == NULL) return 1;
// 	ptrglVertexAttribL3dv = goglGetProcAddress("glVertexAttribL3dv");
// 	if(ptrglVertexAttribL3dv == NULL) return 1;
// 	ptrglVertexAttribL4dv = goglGetProcAddress("glVertexAttribL4dv");
// 	if(ptrglVertexAttribL4dv == NULL) return 1;
// 	ptrglVertexAttribLPointer = goglGetProcAddress("glVertexAttribLPointer");
// 	if(ptrglVertexAttribLPointer == NULL) return 1;
// 	ptrglGetVertexAttribLdv = goglGetProcAddress("glGetVertexAttribLdv");
// 	if(ptrglGetVertexAttribLdv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_attrib_binding() {
// 	ptrglBindVertexBuffer = goglGetProcAddress("glBindVertexBuffer");
// 	if(ptrglBindVertexBuffer == NULL) return 1;
// 	ptrglVertexAttribFormat = goglGetProcAddress("glVertexAttribFormat");
// 	if(ptrglVertexAttribFormat == NULL) return 1;
// 	ptrglVertexAttribIFormat = goglGetProcAddress("glVertexAttribIFormat");
// 	if(ptrglVertexAttribIFormat == NULL) return 1;
// 	ptrglVertexAttribLFormat = goglGetProcAddress("glVertexAttribLFormat");
// 	if(ptrglVertexAttribLFormat == NULL) return 1;
// 	ptrglVertexAttribBinding = goglGetProcAddress("glVertexAttribBinding");
// 	if(ptrglVertexAttribBinding == NULL) return 1;
// 	ptrglVertexBindingDivisor = goglGetProcAddress("glVertexBindingDivisor");
// 	if(ptrglVertexBindingDivisor == NULL) return 1;
// 	ptrglVertexArrayBindVertexBufferEXT = goglGetProcAddress("glVertexArrayBindVertexBufferEXT");
// 	if(ptrglVertexArrayBindVertexBufferEXT == NULL) return 1;
// 	ptrglVertexArrayVertexAttribFormatEXT = goglGetProcAddress("glVertexArrayVertexAttribFormatEXT");
// 	if(ptrglVertexArrayVertexAttribFormatEXT == NULL) return 1;
// 	ptrglVertexArrayVertexAttribIFormatEXT = goglGetProcAddress("glVertexArrayVertexAttribIFormatEXT");
// 	if(ptrglVertexArrayVertexAttribIFormatEXT == NULL) return 1;
// 	ptrglVertexArrayVertexAttribLFormatEXT = goglGetProcAddress("glVertexArrayVertexAttribLFormatEXT");
// 	if(ptrglVertexArrayVertexAttribLFormatEXT == NULL) return 1;
// 	ptrglVertexArrayVertexAttribBindingEXT = goglGetProcAddress("glVertexArrayVertexAttribBindingEXT");
// 	if(ptrglVertexArrayVertexAttribBindingEXT == NULL) return 1;
// 	ptrglVertexArrayVertexBindingDivisorEXT = goglGetProcAddress("glVertexArrayVertexBindingDivisorEXT");
// 	if(ptrglVertexArrayVertexBindingDivisorEXT == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_blend() {
// 	ptrglWeightbvARB = goglGetProcAddress("glWeightbvARB");
// 	if(ptrglWeightbvARB == NULL) return 1;
// 	ptrglWeightsvARB = goglGetProcAddress("glWeightsvARB");
// 	if(ptrglWeightsvARB == NULL) return 1;
// 	ptrglWeightivARB = goglGetProcAddress("glWeightivARB");
// 	if(ptrglWeightivARB == NULL) return 1;
// 	ptrglWeightfvARB = goglGetProcAddress("glWeightfvARB");
// 	if(ptrglWeightfvARB == NULL) return 1;
// 	ptrglWeightdvARB = goglGetProcAddress("glWeightdvARB");
// 	if(ptrglWeightdvARB == NULL) return 1;
// 	ptrglWeightubvARB = goglGetProcAddress("glWeightubvARB");
// 	if(ptrglWeightubvARB == NULL) return 1;
// 	ptrglWeightusvARB = goglGetProcAddress("glWeightusvARB");
// 	if(ptrglWeightusvARB == NULL) return 1;
// 	ptrglWeightuivARB = goglGetProcAddress("glWeightuivARB");
// 	if(ptrglWeightuivARB == NULL) return 1;
// 	ptrglWeightPointerARB = goglGetProcAddress("glWeightPointerARB");
// 	if(ptrglWeightPointerARB == NULL) return 1;
// 	ptrglVertexBlendARB = goglGetProcAddress("glVertexBlendARB");
// 	if(ptrglVertexBlendARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_buffer_object() {
// 	ptrglBindBufferARB = goglGetProcAddress("glBindBufferARB");
// 	if(ptrglBindBufferARB == NULL) return 1;
// 	ptrglDeleteBuffersARB = goglGetProcAddress("glDeleteBuffersARB");
// 	if(ptrglDeleteBuffersARB == NULL) return 1;
// 	ptrglGenBuffersARB = goglGetProcAddress("glGenBuffersARB");
// 	if(ptrglGenBuffersARB == NULL) return 1;
// 	ptrglIsBufferARB = goglGetProcAddress("glIsBufferARB");
// 	if(ptrglIsBufferARB == NULL) return 1;
// 	ptrglBufferDataARB = goglGetProcAddress("glBufferDataARB");
// 	if(ptrglBufferDataARB == NULL) return 1;
// 	ptrglBufferSubDataARB = goglGetProcAddress("glBufferSubDataARB");
// 	if(ptrglBufferSubDataARB == NULL) return 1;
// 	ptrglGetBufferSubDataARB = goglGetProcAddress("glGetBufferSubDataARB");
// 	if(ptrglGetBufferSubDataARB == NULL) return 1;
// 	ptrglMapBufferARB = goglGetProcAddress("glMapBufferARB");
// 	if(ptrglMapBufferARB == NULL) return 1;
// 	ptrglUnmapBufferARB = goglGetProcAddress("glUnmapBufferARB");
// 	if(ptrglUnmapBufferARB == NULL) return 1;
// 	ptrglGetBufferParameterivARB = goglGetProcAddress("glGetBufferParameterivARB");
// 	if(ptrglGetBufferParameterivARB == NULL) return 1;
// 	ptrglGetBufferPointervARB = goglGetProcAddress("glGetBufferPointervARB");
// 	if(ptrglGetBufferPointervARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_program() {
// 	ptrglVertexAttrib1dARB = goglGetProcAddress("glVertexAttrib1dARB");
// 	if(ptrglVertexAttrib1dARB == NULL) return 1;
// 	ptrglVertexAttrib1dvARB = goglGetProcAddress("glVertexAttrib1dvARB");
// 	if(ptrglVertexAttrib1dvARB == NULL) return 1;
// 	ptrglVertexAttrib1fARB = goglGetProcAddress("glVertexAttrib1fARB");
// 	if(ptrglVertexAttrib1fARB == NULL) return 1;
// 	ptrglVertexAttrib1fvARB = goglGetProcAddress("glVertexAttrib1fvARB");
// 	if(ptrglVertexAttrib1fvARB == NULL) return 1;
// 	ptrglVertexAttrib1sARB = goglGetProcAddress("glVertexAttrib1sARB");
// 	if(ptrglVertexAttrib1sARB == NULL) return 1;
// 	ptrglVertexAttrib1svARB = goglGetProcAddress("glVertexAttrib1svARB");
// 	if(ptrglVertexAttrib1svARB == NULL) return 1;
// 	ptrglVertexAttrib2dARB = goglGetProcAddress("glVertexAttrib2dARB");
// 	if(ptrglVertexAttrib2dARB == NULL) return 1;
// 	ptrglVertexAttrib2dvARB = goglGetProcAddress("glVertexAttrib2dvARB");
// 	if(ptrglVertexAttrib2dvARB == NULL) return 1;
// 	ptrglVertexAttrib2fARB = goglGetProcAddress("glVertexAttrib2fARB");
// 	if(ptrglVertexAttrib2fARB == NULL) return 1;
// 	ptrglVertexAttrib2fvARB = goglGetProcAddress("glVertexAttrib2fvARB");
// 	if(ptrglVertexAttrib2fvARB == NULL) return 1;
// 	ptrglVertexAttrib2sARB = goglGetProcAddress("glVertexAttrib2sARB");
// 	if(ptrglVertexAttrib2sARB == NULL) return 1;
// 	ptrglVertexAttrib2svARB = goglGetProcAddress("glVertexAttrib2svARB");
// 	if(ptrglVertexAttrib2svARB == NULL) return 1;
// 	ptrglVertexAttrib3dARB = goglGetProcAddress("glVertexAttrib3dARB");
// 	if(ptrglVertexAttrib3dARB == NULL) return 1;
// 	ptrglVertexAttrib3dvARB = goglGetProcAddress("glVertexAttrib3dvARB");
// 	if(ptrglVertexAttrib3dvARB == NULL) return 1;
// 	ptrglVertexAttrib3fARB = goglGetProcAddress("glVertexAttrib3fARB");
// 	if(ptrglVertexAttrib3fARB == NULL) return 1;
// 	ptrglVertexAttrib3fvARB = goglGetProcAddress("glVertexAttrib3fvARB");
// 	if(ptrglVertexAttrib3fvARB == NULL) return 1;
// 	ptrglVertexAttrib3sARB = goglGetProcAddress("glVertexAttrib3sARB");
// 	if(ptrglVertexAttrib3sARB == NULL) return 1;
// 	ptrglVertexAttrib3svARB = goglGetProcAddress("glVertexAttrib3svARB");
// 	if(ptrglVertexAttrib3svARB == NULL) return 1;
// 	ptrglVertexAttrib4NbvARB = goglGetProcAddress("glVertexAttrib4NbvARB");
// 	if(ptrglVertexAttrib4NbvARB == NULL) return 1;
// 	ptrglVertexAttrib4NivARB = goglGetProcAddress("glVertexAttrib4NivARB");
// 	if(ptrglVertexAttrib4NivARB == NULL) return 1;
// 	ptrglVertexAttrib4NsvARB = goglGetProcAddress("glVertexAttrib4NsvARB");
// 	if(ptrglVertexAttrib4NsvARB == NULL) return 1;
// 	ptrglVertexAttrib4NubARB = goglGetProcAddress("glVertexAttrib4NubARB");
// 	if(ptrglVertexAttrib4NubARB == NULL) return 1;
// 	ptrglVertexAttrib4NubvARB = goglGetProcAddress("glVertexAttrib4NubvARB");
// 	if(ptrglVertexAttrib4NubvARB == NULL) return 1;
// 	ptrglVertexAttrib4NuivARB = goglGetProcAddress("glVertexAttrib4NuivARB");
// 	if(ptrglVertexAttrib4NuivARB == NULL) return 1;
// 	ptrglVertexAttrib4NusvARB = goglGetProcAddress("glVertexAttrib4NusvARB");
// 	if(ptrglVertexAttrib4NusvARB == NULL) return 1;
// 	ptrglVertexAttrib4bvARB = goglGetProcAddress("glVertexAttrib4bvARB");
// 	if(ptrglVertexAttrib4bvARB == NULL) return 1;
// 	ptrglVertexAttrib4dARB = goglGetProcAddress("glVertexAttrib4dARB");
// 	if(ptrglVertexAttrib4dARB == NULL) return 1;
// 	ptrglVertexAttrib4dvARB = goglGetProcAddress("glVertexAttrib4dvARB");
// 	if(ptrglVertexAttrib4dvARB == NULL) return 1;
// 	ptrglVertexAttrib4fARB = goglGetProcAddress("glVertexAttrib4fARB");
// 	if(ptrglVertexAttrib4fARB == NULL) return 1;
// 	ptrglVertexAttrib4fvARB = goglGetProcAddress("glVertexAttrib4fvARB");
// 	if(ptrglVertexAttrib4fvARB == NULL) return 1;
// 	ptrglVertexAttrib4ivARB = goglGetProcAddress("glVertexAttrib4ivARB");
// 	if(ptrglVertexAttrib4ivARB == NULL) return 1;
// 	ptrglVertexAttrib4sARB = goglGetProcAddress("glVertexAttrib4sARB");
// 	if(ptrglVertexAttrib4sARB == NULL) return 1;
// 	ptrglVertexAttrib4svARB = goglGetProcAddress("glVertexAttrib4svARB");
// 	if(ptrglVertexAttrib4svARB == NULL) return 1;
// 	ptrglVertexAttrib4ubvARB = goglGetProcAddress("glVertexAttrib4ubvARB");
// 	if(ptrglVertexAttrib4ubvARB == NULL) return 1;
// 	ptrglVertexAttrib4uivARB = goglGetProcAddress("glVertexAttrib4uivARB");
// 	if(ptrglVertexAttrib4uivARB == NULL) return 1;
// 	ptrglVertexAttrib4usvARB = goglGetProcAddress("glVertexAttrib4usvARB");
// 	if(ptrglVertexAttrib4usvARB == NULL) return 1;
// 	ptrglVertexAttribPointerARB = goglGetProcAddress("glVertexAttribPointerARB");
// 	if(ptrglVertexAttribPointerARB == NULL) return 1;
// 	ptrglEnableVertexAttribArrayARB = goglGetProcAddress("glEnableVertexAttribArrayARB");
// 	if(ptrglEnableVertexAttribArrayARB == NULL) return 1;
// 	ptrglDisableVertexAttribArrayARB = goglGetProcAddress("glDisableVertexAttribArrayARB");
// 	if(ptrglDisableVertexAttribArrayARB == NULL) return 1;
// 	ptrglProgramStringARB = goglGetProcAddress("glProgramStringARB");
// 	if(ptrglProgramStringARB == NULL) return 1;
// 	ptrglBindProgramARB = goglGetProcAddress("glBindProgramARB");
// 	if(ptrglBindProgramARB == NULL) return 1;
// 	ptrglDeleteProgramsARB = goglGetProcAddress("glDeleteProgramsARB");
// 	if(ptrglDeleteProgramsARB == NULL) return 1;
// 	ptrglGenProgramsARB = goglGetProcAddress("glGenProgramsARB");
// 	if(ptrglGenProgramsARB == NULL) return 1;
// 	ptrglProgramEnvParameter4dARB = goglGetProcAddress("glProgramEnvParameter4dARB");
// 	if(ptrglProgramEnvParameter4dARB == NULL) return 1;
// 	ptrglProgramEnvParameter4dvARB = goglGetProcAddress("glProgramEnvParameter4dvARB");
// 	if(ptrglProgramEnvParameter4dvARB == NULL) return 1;
// 	ptrglProgramEnvParameter4fARB = goglGetProcAddress("glProgramEnvParameter4fARB");
// 	if(ptrglProgramEnvParameter4fARB == NULL) return 1;
// 	ptrglProgramEnvParameter4fvARB = goglGetProcAddress("glProgramEnvParameter4fvARB");
// 	if(ptrglProgramEnvParameter4fvARB == NULL) return 1;
// 	ptrglProgramLocalParameter4dARB = goglGetProcAddress("glProgramLocalParameter4dARB");
// 	if(ptrglProgramLocalParameter4dARB == NULL) return 1;
// 	ptrglProgramLocalParameter4dvARB = goglGetProcAddress("glProgramLocalParameter4dvARB");
// 	if(ptrglProgramLocalParameter4dvARB == NULL) return 1;
// 	ptrglProgramLocalParameter4fARB = goglGetProcAddress("glProgramLocalParameter4fARB");
// 	if(ptrglProgramLocalParameter4fARB == NULL) return 1;
// 	ptrglProgramLocalParameter4fvARB = goglGetProcAddress("glProgramLocalParameter4fvARB");
// 	if(ptrglProgramLocalParameter4fvARB == NULL) return 1;
// 	ptrglGetProgramEnvParameterdvARB = goglGetProcAddress("glGetProgramEnvParameterdvARB");
// 	if(ptrglGetProgramEnvParameterdvARB == NULL) return 1;
// 	ptrglGetProgramEnvParameterfvARB = goglGetProcAddress("glGetProgramEnvParameterfvARB");
// 	if(ptrglGetProgramEnvParameterfvARB == NULL) return 1;
// 	ptrglGetProgramLocalParameterdvARB = goglGetProcAddress("glGetProgramLocalParameterdvARB");
// 	if(ptrglGetProgramLocalParameterdvARB == NULL) return 1;
// 	ptrglGetProgramLocalParameterfvARB = goglGetProcAddress("glGetProgramLocalParameterfvARB");
// 	if(ptrglGetProgramLocalParameterfvARB == NULL) return 1;
// 	ptrglGetProgramivARB = goglGetProcAddress("glGetProgramivARB");
// 	if(ptrglGetProgramivARB == NULL) return 1;
// 	ptrglGetProgramStringARB = goglGetProcAddress("glGetProgramStringARB");
// 	if(ptrglGetProgramStringARB == NULL) return 1;
// 	ptrglGetVertexAttribdvARB = goglGetProcAddress("glGetVertexAttribdvARB");
// 	if(ptrglGetVertexAttribdvARB == NULL) return 1;
// 	ptrglGetVertexAttribfvARB = goglGetProcAddress("glGetVertexAttribfvARB");
// 	if(ptrglGetVertexAttribfvARB == NULL) return 1;
// 	ptrglGetVertexAttribivARB = goglGetProcAddress("glGetVertexAttribivARB");
// 	if(ptrglGetVertexAttribivARB == NULL) return 1;
// 	ptrglGetVertexAttribPointervARB = goglGetProcAddress("glGetVertexAttribPointervARB");
// 	if(ptrglGetVertexAttribPointervARB == NULL) return 1;
// 	ptrglIsProgramARB = goglGetProcAddress("glIsProgramARB");
// 	if(ptrglIsProgramARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_shader() {
// 	ptrglBindAttribLocationARB = goglGetProcAddress("glBindAttribLocationARB");
// 	if(ptrglBindAttribLocationARB == NULL) return 1;
// 	ptrglGetActiveAttribARB = goglGetProcAddress("glGetActiveAttribARB");
// 	if(ptrglGetActiveAttribARB == NULL) return 1;
// 	ptrglGetAttribLocationARB = goglGetProcAddress("glGetAttribLocationARB");
// 	if(ptrglGetAttribLocationARB == NULL) return 1;
// 	return 0;
// }
// int init_ARB_vertex_type_2_10_10_10_rev() {
// 	ptrglVertexP2ui = goglGetProcAddress("glVertexP2ui");
// 	if(ptrglVertexP2ui == NULL) return 1;
// 	ptrglVertexP2uiv = goglGetProcAddress("glVertexP2uiv");
// 	if(ptrglVertexP2uiv == NULL) return 1;
// 	ptrglVertexP3ui = goglGetProcAddress("glVertexP3ui");
// 	if(ptrglVertexP3ui == NULL) return 1;
// 	ptrglVertexP3uiv = goglGetProcAddress("glVertexP3uiv");
// 	if(ptrglVertexP3uiv == NULL) return 1;
// 	ptrglVertexP4ui = goglGetProcAddress("glVertexP4ui");
// 	if(ptrglVertexP4ui == NULL) return 1;
// 	ptrglVertexP4uiv = goglGetProcAddress("glVertexP4uiv");
// 	if(ptrglVertexP4uiv == NULL) return 1;
// 	ptrglTexCoordP1ui = goglGetProcAddress("glTexCoordP1ui");
// 	if(ptrglTexCoordP1ui == NULL) return 1;
// 	ptrglTexCoordP1uiv = goglGetProcAddress("glTexCoordP1uiv");
// 	if(ptrglTexCoordP1uiv == NULL) return 1;
// 	ptrglTexCoordP2ui = goglGetProcAddress("glTexCoordP2ui");
// 	if(ptrglTexCoordP2ui == NULL) return 1;
// 	ptrglTexCoordP2uiv = goglGetProcAddress("glTexCoordP2uiv");
// 	if(ptrglTexCoordP2uiv == NULL) return 1;
// 	ptrglTexCoordP3ui = goglGetProcAddress("glTexCoordP3ui");
// 	if(ptrglTexCoordP3ui == NULL) return 1;
// 	ptrglTexCoordP3uiv = goglGetProcAddress("glTexCoordP3uiv");
// 	if(ptrglTexCoordP3uiv == NULL) return 1;
// 	ptrglTexCoordP4ui = goglGetProcAddress("glTexCoordP4ui");
// 	if(ptrglTexCoordP4ui == NULL) return 1;
// 	ptrglTexCoordP4uiv = goglGetProcAddress("glTexCoordP4uiv");
// 	if(ptrglTexCoordP4uiv == NULL) return 1;
// 	ptrglMultiTexCoordP1ui = goglGetProcAddress("glMultiTexCoordP1ui");
// 	if(ptrglMultiTexCoordP1ui == NULL) return 1;
// 	ptrglMultiTexCoordP1uiv = goglGetProcAddress("glMultiTexCoordP1uiv");
// 	if(ptrglMultiTexCoordP1uiv == NULL) return 1;
// 	ptrglMultiTexCoordP2ui = goglGetProcAddress("glMultiTexCoordP2ui");
// 	if(ptrglMultiTexCoordP2ui == NULL) return 1;
// 	ptrglMultiTexCoordP2uiv = goglGetProcAddress("glMultiTexCoordP2uiv");
// 	if(ptrglMultiTexCoordP2uiv == NULL) return 1;
// 	ptrglMultiTexCoordP3ui = goglGetProcAddress("glMultiTexCoordP3ui");
// 	if(ptrglMultiTexCoordP3ui == NULL) return 1;
// 	ptrglMultiTexCoordP3uiv = goglGetProcAddress("glMultiTexCoordP3uiv");
// 	if(ptrglMultiTexCoordP3uiv == NULL) return 1;
// 	ptrglMultiTexCoordP4ui = goglGetProcAddress("glMultiTexCoordP4ui");
// 	if(ptrglMultiTexCoordP4ui == NULL) return 1;
// 	ptrglMultiTexCoordP4uiv = goglGetProcAddress("glMultiTexCoordP4uiv");
// 	if(ptrglMultiTexCoordP4uiv == NULL) return 1;
// 	ptrglNormalP3ui = goglGetProcAddress("glNormalP3ui");
// 	if(ptrglNormalP3ui == NULL) return 1;
// 	ptrglNormalP3uiv = goglGetProcAddress("glNormalP3uiv");
// 	if(ptrglNormalP3uiv == NULL) return 1;
// 	ptrglColorP3ui = goglGetProcAddress("glColorP3ui");
// 	if(ptrglColorP3ui == NULL) return 1;
// 	ptrglColorP3uiv = goglGetProcAddress("glColorP3uiv");
// 	if(ptrglColorP3uiv == NULL) return 1;
// 	ptrglColorP4ui = goglGetProcAddress("glColorP4ui");
// 	if(ptrglColorP4ui == NULL) return 1;
// 	ptrglColorP4uiv = goglGetProcAddress("glColorP4uiv");
// 	if(ptrglColorP4uiv == NULL) return 1;
// 	ptrglSecondaryColorP3ui = goglGetProcAddress("glSecondaryColorP3ui");
// 	if(ptrglSecondaryColorP3ui == NULL) return 1;
// 	ptrglSecondaryColorP3uiv = goglGetProcAddress("glSecondaryColorP3uiv");
// 	if(ptrglSecondaryColorP3uiv == NULL) return 1;
// 	ptrglVertexAttribP1ui = goglGetProcAddress("glVertexAttribP1ui");
// 	if(ptrglVertexAttribP1ui == NULL) return 1;
// 	ptrglVertexAttribP1uiv = goglGetProcAddress("glVertexAttribP1uiv");
// 	if(ptrglVertexAttribP1uiv == NULL) return 1;
// 	ptrglVertexAttribP2ui = goglGetProcAddress("glVertexAttribP2ui");
// 	if(ptrglVertexAttribP2ui == NULL) return 1;
// 	ptrglVertexAttribP2uiv = goglGetProcAddress("glVertexAttribP2uiv");
// 	if(ptrglVertexAttribP2uiv == NULL) return 1;
// 	ptrglVertexAttribP3ui = goglGetProcAddress("glVertexAttribP3ui");
// 	if(ptrglVertexAttribP3ui == NULL) return 1;
// 	ptrglVertexAttribP3uiv = goglGetProcAddress("glVertexAttribP3uiv");
// 	if(ptrglVertexAttribP3uiv == NULL) return 1;
// 	ptrglVertexAttribP4ui = goglGetProcAddress("glVertexAttribP4ui");
// 	if(ptrglVertexAttribP4ui == NULL) return 1;
// 	ptrglVertexAttribP4uiv = goglGetProcAddress("glVertexAttribP4uiv");
// 	if(ptrglVertexAttribP4uiv == NULL) return 1;
// 	return 0;
// }
// int init_ARB_viewport_array() {
// 	ptrglViewportArrayv = goglGetProcAddress("glViewportArrayv");
// 	if(ptrglViewportArrayv == NULL) return 1;
// 	ptrglViewportIndexedf = goglGetProcAddress("glViewportIndexedf");
// 	if(ptrglViewportIndexedf == NULL) return 1;
// 	ptrglViewportIndexedfv = goglGetProcAddress("glViewportIndexedfv");
// 	if(ptrglViewportIndexedfv == NULL) return 1;
// 	ptrglScissorArrayv = goglGetProcAddress("glScissorArrayv");
// 	if(ptrglScissorArrayv == NULL) return 1;
// 	ptrglScissorIndexed = goglGetProcAddress("glScissorIndexed");
// 	if(ptrglScissorIndexed == NULL) return 1;
// 	ptrglScissorIndexedv = goglGetProcAddress("glScissorIndexedv");
// 	if(ptrglScissorIndexedv == NULL) return 1;
// 	ptrglDepthRangeArrayv = goglGetProcAddress("glDepthRangeArrayv");
// 	if(ptrglDepthRangeArrayv == NULL) return 1;
// 	ptrglDepthRangeIndexed = goglGetProcAddress("glDepthRangeIndexed");
// 	if(ptrglDepthRangeIndexed == NULL) return 1;
// 	ptrglGetFloati_v = goglGetProcAddress("glGetFloati_v");
// 	if(ptrglGetFloati_v == NULL) return 1;
// 	ptrglGetDoublei_v = goglGetProcAddress("glGetDoublei_v");
// 	if(ptrglGetDoublei_v == NULL) return 1;
// 	return 0;
// }
// int init_ARB_window_pos() {
// 	ptrglWindowPos2dARB = goglGetProcAddress("glWindowPos2dARB");
// 	if(ptrglWindowPos2dARB == NULL) return 1;
// 	ptrglWindowPos2dvARB = goglGetProcAddress("glWindowPos2dvARB");
// 	if(ptrglWindowPos2dvARB == NULL) return 1;
// 	ptrglWindowPos2fARB = goglGetProcAddress("glWindowPos2fARB");
// 	if(ptrglWindowPos2fARB == NULL) return 1;
// 	ptrglWindowPos2fvARB = goglGetProcAddress("glWindowPos2fvARB");
// 	if(ptrglWindowPos2fvARB == NULL) return 1;
// 	ptrglWindowPos2iARB = goglGetProcAddress("glWindowPos2iARB");
// 	if(ptrglWindowPos2iARB == NULL) return 1;
// 	ptrglWindowPos2ivARB = goglGetProcAddress("glWindowPos2ivARB");
// 	if(ptrglWindowPos2ivARB == NULL) return 1;
// 	ptrglWindowPos2sARB = goglGetProcAddress("glWindowPos2sARB");
// 	if(ptrglWindowPos2sARB == NULL) return 1;
// 	ptrglWindowPos2svARB = goglGetProcAddress("glWindowPos2svARB");
// 	if(ptrglWindowPos2svARB == NULL) return 1;
// 	ptrglWindowPos3dARB = goglGetProcAddress("glWindowPos3dARB");
// 	if(ptrglWindowPos3dARB == NULL) return 1;
// 	ptrglWindowPos3dvARB = goglGetProcAddress("glWindowPos3dvARB");
// 	if(ptrglWindowPos3dvARB == NULL) return 1;
// 	ptrglWindowPos3fARB = goglGetProcAddress("glWindowPos3fARB");
// 	if(ptrglWindowPos3fARB == NULL) return 1;
// 	ptrglWindowPos3fvARB = goglGetProcAddress("glWindowPos3fvARB");
// 	if(ptrglWindowPos3fvARB == NULL) return 1;
// 	ptrglWindowPos3iARB = goglGetProcAddress("glWindowPos3iARB");
// 	if(ptrglWindowPos3iARB == NULL) return 1;
// 	ptrglWindowPos3ivARB = goglGetProcAddress("glWindowPos3ivARB");
// 	if(ptrglWindowPos3ivARB == NULL) return 1;
// 	ptrglWindowPos3sARB = goglGetProcAddress("glWindowPos3sARB");
// 	if(ptrglWindowPos3sARB == NULL) return 1;
// 	ptrglWindowPos3svARB = goglGetProcAddress("glWindowPos3svARB");
// 	if(ptrglWindowPos3svARB == NULL) return 1;
// 	return 0;
// }
// 
import "C"
import "unsafe"
import "errors"

type (
	Enum     C.GLenum
	Boolean  C.GLboolean
	Bitfield C.GLbitfield
	Byte     C.GLbyte
	Short    C.GLshort
	Int      C.GLint
	Sizei    C.GLsizei
	Ubyte    C.GLubyte
	Ushort   C.GLushort
	Uint     C.GLuint
	Half     C.GLhalf
	Float    C.GLfloat
	Clampf   C.GLclampf
	Double   C.GLdouble
	Clampd   C.GLclampd
	Char     C.GLchar
	Pointer  unsafe.Pointer
	Sync     C.GLsync
	Int64    C.GLint64
	Uint64   C.GLuint64
	Intptr   C.GLintptr
	Sizeiptr C.GLsizeiptr
)

// ARB_ES2_compatibility
const (
	FIXED = 0x140C
	HIGH_FLOAT = 0x8DF2
	HIGH_INT = 0x8DF5
	IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B
	IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A
	LOW_FLOAT = 0x8DF0
	LOW_INT = 0x8DF3
	MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD
	MAX_VARYING_VECTORS = 0x8DFC
	MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB
	MEDIUM_FLOAT = 0x8DF1
	MEDIUM_INT = 0x8DF4
	NUM_SHADER_BINARY_FORMATS = 0x8DF9
	RGB565 = 0x8D62
	SHADER_BINARY_FORMATS = 0x8DF8
	SHADER_COMPILER = 0x8DFA
)
// ARB_ES3_compatibility
const (
	ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A
	COMPRESSED_R11_EAC = 0x9270
	COMPRESSED_RG11_EAC = 0x9272
	COMPRESSED_RGB8_ETC2 = 0x9274
	COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276
	COMPRESSED_RGBA8_ETC2_EAC = 0x9278
	COMPRESSED_SIGNED_R11_EAC = 0x9271
	COMPRESSED_SIGNED_RG11_EAC = 0x9273
	COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279
	COMPRESSED_SRGB8_ETC2 = 0x9275
	COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277
	MAX_ELEMENT_INDEX = 0x8D6B
	PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69
)
// ARB_arrays_of_arrays
const (
)
// ARB_base_instance
const (
)
// ARB_blend_func_extended
const (
	MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC
	ONE_MINUS_SRC1_ALPHA = 0x88FB
	ONE_MINUS_SRC1_COLOR = 0x88FA
	SRC1_ALPHA = 0x8589
	SRC1_COLOR = 0x88F9
)
// ARB_cl_event
const (
	SYNC_CL_EVENT_ARB = 0x8240
	SYNC_CL_EVENT_COMPLETE_ARB = 0x8241
)
// ARB_clear_buffer_object
const (
)
// ARB_color_buffer_float
const (
	CLAMP_FRAGMENT_COLOR_ARB = 0x891B
	CLAMP_READ_COLOR_ARB = 0x891C
	CLAMP_VERTEX_COLOR_ARB = 0x891A
	FIXED_ONLY_ARB = 0x891D
	RGBA_FLOAT_MODE_ARB = 0x8820
)
// ARB_compatibility
const (
)
// ARB_compressed_texture_pixel_storage
const (
	PACK_COMPRESSED_BLOCK_DEPTH = 0x912D
	PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C
	PACK_COMPRESSED_BLOCK_SIZE = 0x912E
	PACK_COMPRESSED_BLOCK_WIDTH = 0x912B
	UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129
	UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128
	UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A
	UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127
)
// ARB_compute_shader
const (
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED
	COMPUTE_LOCAL_WORK_SIZE = 0x8267
	COMPUTE_SHADER = 0x91B9
	COMPUTE_SHADER_BIT = 0x00000020
	DISPATCH_INDIRECT_BUFFER = 0x90EE
	DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF
	MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266
	MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265
	MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264
	MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD
	MAX_COMPUTE_LOCAL_INVOCATIONS = 0x90EB
	MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262
	MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC
	MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB
	MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263
	MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE
	MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF
	UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC
)
// ARB_conservative_depth
const (
)
// ARB_copy_buffer
const (
	COPY_READ_BUFFER = 0x8F36
	COPY_READ_BUFFER_BINDING = 0x8F36
	COPY_WRITE_BUFFER = 0x8F37
	COPY_WRITE_BUFFER_BINDING = 0x8F37
)
// ARB_copy_image
const (
)
// ARB_debug_output
const (
	DEBUG_CALLBACK_FUNCTION_ARB = 0x8244
	DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245
	DEBUG_LOGGED_MESSAGES_ARB = 0x9145
	DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243
	DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242
	DEBUG_SEVERITY_HIGH_ARB = 0x9146
	DEBUG_SEVERITY_LOW_ARB = 0x9148
	DEBUG_SEVERITY_MEDIUM_ARB = 0x9147
	DEBUG_SOURCE_API_ARB = 0x8246
	DEBUG_SOURCE_APPLICATION_ARB = 0x824A
	DEBUG_SOURCE_OTHER_ARB = 0x824B
	DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248
	DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249
	DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247
	DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D
	DEBUG_TYPE_ERROR_ARB = 0x824C
	DEBUG_TYPE_OTHER_ARB = 0x8251
	DEBUG_TYPE_PERFORMANCE_ARB = 0x8250
	DEBUG_TYPE_PORTABILITY_ARB = 0x824F
	DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E
	MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144
	MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143
)
// ARB_depth_buffer_float
const (
	DEPTH32F_STENCIL8 = 0x8CAD
	DEPTH_COMPONENT32F = 0x8CAC
	FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD
)
// ARB_depth_clamp
const (
	DEPTH_CLAMP = 0x864F
)
// ARB_depth_texture
const (
	DEPTH_COMPONENT16_ARB = 0x81A5
	DEPTH_COMPONENT24_ARB = 0x81A6
	DEPTH_COMPONENT32_ARB = 0x81A7
	DEPTH_TEXTURE_MODE_ARB = 0x884B
	TEXTURE_DEPTH_SIZE_ARB = 0x884A
)
// ARB_draw_buffers
const (
	DRAW_BUFFER0_ARB = 0x8825
	DRAW_BUFFER10_ARB = 0x882F
	DRAW_BUFFER11_ARB = 0x8830
	DRAW_BUFFER12_ARB = 0x8831
	DRAW_BUFFER13_ARB = 0x8832
	DRAW_BUFFER14_ARB = 0x8833
	DRAW_BUFFER15_ARB = 0x8834
	DRAW_BUFFER1_ARB = 0x8826
	DRAW_BUFFER2_ARB = 0x8827
	DRAW_BUFFER3_ARB = 0x8828
	DRAW_BUFFER4_ARB = 0x8829
	DRAW_BUFFER5_ARB = 0x882A
	DRAW_BUFFER6_ARB = 0x882B
	DRAW_BUFFER7_ARB = 0x882C
	DRAW_BUFFER8_ARB = 0x882D
	DRAW_BUFFER9_ARB = 0x882E
	MAX_DRAW_BUFFERS_ARB = 0x8824
)
// ARB_draw_buffers_blend
const (
)
// ARB_draw_elements_base_vertex
const (
)
// ARB_draw_indirect
const (
	DRAW_INDIRECT_BUFFER = 0x8F3F
	DRAW_INDIRECT_BUFFER_BINDING = 0x8F43
)
// ARB_draw_instanced
const (
)
// ARB_explicit_attrib_location
const (
)
// ARB_explicit_uniform_location
const (
	MAX_UNIFORM_LOCATIONS = 0x826E
)
// ARB_fragment_coord_conventions
const (
)
// ARB_fragment_layer_viewport
const (
)
// ARB_fragment_program
const (
	FRAGMENT_PROGRAM_ARB = 0x8804
	MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B
	MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E
	MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810
	MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F
	MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D
	MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C
	MAX_TEXTURE_COORDS_ARB = 0x8871
	MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872
	PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805
	PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808
	PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A
	PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809
	PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807
	PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806
)
// ARB_fragment_program_shadow
const (
)
// ARB_fragment_shader
const (
	FRAGMENT_SHADER_ARB = 0x8B30
	FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B
	MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49
)
// ARB_framebuffer_no_attachments
const (
	FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314
	FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311
	FRAMEBUFFER_DEFAULT_LAYERS = 0x9312
	FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313
	FRAMEBUFFER_DEFAULT_WIDTH = 0x9310
	MAX_FRAMEBUFFER_HEIGHT = 0x9316
	MAX_FRAMEBUFFER_LAYERS = 0x9317
	MAX_FRAMEBUFFER_SAMPLES = 0x9318
	MAX_FRAMEBUFFER_WIDTH = 0x9315
)
// ARB_framebuffer_object
const (
	COLOR_ATTACHMENT0 = 0x8CE0
	COLOR_ATTACHMENT1 = 0x8CE1
	COLOR_ATTACHMENT10 = 0x8CEA
	COLOR_ATTACHMENT11 = 0x8CEB
	COLOR_ATTACHMENT12 = 0x8CEC
	COLOR_ATTACHMENT13 = 0x8CED
	COLOR_ATTACHMENT14 = 0x8CEE
	COLOR_ATTACHMENT15 = 0x8CEF
	COLOR_ATTACHMENT2 = 0x8CE2
	COLOR_ATTACHMENT3 = 0x8CE3
	COLOR_ATTACHMENT4 = 0x8CE4
	COLOR_ATTACHMENT5 = 0x8CE5
	COLOR_ATTACHMENT6 = 0x8CE6
	COLOR_ATTACHMENT7 = 0x8CE7
	COLOR_ATTACHMENT8 = 0x8CE8
	COLOR_ATTACHMENT9 = 0x8CE9
	DEPTH24_STENCIL8 = 0x88F0
	DEPTH_ATTACHMENT = 0x8D00
	DEPTH_STENCIL = 0x84F9
	DEPTH_STENCIL_ATTACHMENT = 0x821A
	DRAW_FRAMEBUFFER = 0x8CA9
	DRAW_FRAMEBUFFER_BINDING = 0x8CA6
	FRAMEBUFFER = 0x8D40
	FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215
	FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214
	FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210
	FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211
	FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216
	FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213
	FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1
	FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0
	FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212
	FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217
	FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3
	FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2
	FRAMEBUFFER_BINDING = 0x8CA6
	FRAMEBUFFER_COMPLETE = 0x8CD5
	FRAMEBUFFER_DEFAULT = 0x8218
	FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6
	FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB
	FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7
	FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56
	FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC
	FRAMEBUFFER_UNDEFINED = 0x8219
	FRAMEBUFFER_UNSUPPORTED = 0x8CDD
	INDEX = 0x8222
	INVALID_FRAMEBUFFER_OPERATION = 0x0506
	MAX_COLOR_ATTACHMENTS = 0x8CDF
	MAX_RENDERBUFFER_SIZE = 0x84E8
	MAX_SAMPLES = 0x8D57
	READ_FRAMEBUFFER = 0x8CA8
	READ_FRAMEBUFFER_BINDING = 0x8CAA
	RENDERBUFFER_ALPHA_SIZE = 0x8D53
	RENDERBUFFER_BINDING = 0x8CA7
	RENDERBUFFER_BLUE_SIZE = 0x8D52
	RENDERBUFFER_DEPTH_SIZE = 0x8D54
	RENDERBUFFER_GREEN_SIZE = 0x8D51
	RENDERBUFFER_HEIGHT = 0x8D43
	RENDERBUFFER_INTERNAL_FORMAT = 0x8D44
	RENDERBUFFER_RED_SIZE = 0x8D50
	RENDERBUFFER_SAMPLES = 0x8CAB
	RENDERBUFFER_STENCIL_SIZE = 0x8D55
	RENDERBUFFER_WIDTH = 0x8D42
	STENCIL_ATTACHMENT = 0x8D20
	STENCIL_INDEX1 = 0x8D46
	STENCIL_INDEX16 = 0x8D49
	STENCIL_INDEX4 = 0x8D47
	STENCIL_INDEX8 = 0x8D48
	TEXTURE_ALPHA_TYPE = 0x8C13
	TEXTURE_BLUE_TYPE = 0x8C12
	TEXTURE_DEPTH_TYPE = 0x8C16
	TEXTURE_GREEN_TYPE = 0x8C11
	TEXTURE_INTENSITY_TYPE = 0x8C15
	TEXTURE_LUMINANCE_TYPE = 0x8C14
	TEXTURE_RED_TYPE = 0x8C10
	TEXTURE_STENCIL_SIZE = 0x88F1
	UNSIGNED_INT_24_8 = 0x84FA
	UNSIGNED_NORMALIZED = 0x8C17
)
// ARB_framebuffer_sRGB
const (
	FRAMEBUFFER_SRGB = 0x8DB9
)
// ARB_geometry_shader4
const (
	FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7
	FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9
	FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8
	GEOMETRY_INPUT_TYPE_ARB = 0x8DDB
	GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC
	GEOMETRY_SHADER_ARB = 0x8DD9
	GEOMETRY_VERTICES_OUT_ARB = 0x8DDA
	LINES_ADJACENCY_ARB = 0x000A
	LINE_STRIP_ADJACENCY_ARB = 0x000B
	MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0
	MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29
	MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1
	MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF
	MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD
	MAX_VARYING_COMPONENTS = 0x8B4B
	MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE
	PROGRAM_POINT_SIZE_ARB = 0x8642
	TRIANGLES_ADJACENCY_ARB = 0x000C
	TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D
)
// ARB_get_program_binary
const (
	NUM_PROGRAM_BINARY_FORMATS = 0x87FE
	PROGRAM_BINARY_FORMATS = 0x87FF
	PROGRAM_BINARY_LENGTH = 0x8741
	PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257
)
// ARB_gpu_shader5
const (
	FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D
	GEOMETRY_SHADER_INVOCATIONS = 0x887F
	MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C
	MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A
	MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B
)
// ARB_gpu_shader_fp64
const (
	DOUBLE = 0x140A
)
// ARB_half_float_pixel
const (
	HALF_FLOAT_ARB = 0x140B
)
// ARB_half_float_vertex
const (
	HALF_FLOAT = 0x140B
)
// ARB_imaging
const (
	BLEND_COLOR = 0x8005
	BLEND_EQUATION = 0x8009
	COLOR_MATRIX = 0x80B1
	COLOR_MATRIX_STACK_DEPTH = 0x80B2
	COLOR_TABLE = 0x80D0
	COLOR_TABLE_ALPHA_SIZE = 0x80DD
	COLOR_TABLE_BIAS = 0x80D7
	COLOR_TABLE_BLUE_SIZE = 0x80DC
	COLOR_TABLE_FORMAT = 0x80D8
	COLOR_TABLE_GREEN_SIZE = 0x80DB
	COLOR_TABLE_INTENSITY_SIZE = 0x80DF
	COLOR_TABLE_LUMINANCE_SIZE = 0x80DE
	COLOR_TABLE_RED_SIZE = 0x80DA
	COLOR_TABLE_SCALE = 0x80D6
	COLOR_TABLE_WIDTH = 0x80D9
	CONSTANT_ALPHA = 0x8003
	CONSTANT_BORDER = 0x8151
	CONSTANT_COLOR = 0x8001
	CONVOLUTION_1D = 0x8010
	CONVOLUTION_2D = 0x8011
	CONVOLUTION_BORDER_COLOR = 0x8154
	CONVOLUTION_BORDER_MODE = 0x8013
	CONVOLUTION_FILTER_BIAS = 0x8015
	CONVOLUTION_FILTER_SCALE = 0x8014
	CONVOLUTION_FORMAT = 0x8017
	CONVOLUTION_HEIGHT = 0x8019
	CONVOLUTION_WIDTH = 0x8018
	FUNC_ADD = 0x8006
	FUNC_REVERSE_SUBTRACT = 0x800B
	FUNC_SUBTRACT = 0x800A
	HISTOGRAM = 0x8024
	HISTOGRAM_ALPHA_SIZE = 0x802B
	HISTOGRAM_BLUE_SIZE = 0x802A
	HISTOGRAM_FORMAT = 0x8027
	HISTOGRAM_GREEN_SIZE = 0x8029
	HISTOGRAM_LUMINANCE_SIZE = 0x802C
	HISTOGRAM_RED_SIZE = 0x8028
	HISTOGRAM_SINK = 0x802D
	HISTOGRAM_WIDTH = 0x8026
	MAX = 0x8008
	MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3
	MAX_CONVOLUTION_HEIGHT = 0x801B
	MAX_CONVOLUTION_WIDTH = 0x801A
	MIN = 0x8007
	MINMAX = 0x802E
	MINMAX_FORMAT = 0x802F
	MINMAX_SINK = 0x8030
	ONE_MINUS_CONSTANT_ALPHA = 0x8004
	ONE_MINUS_CONSTANT_COLOR = 0x8002
	POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB
	POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7
	POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA
	POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6
	POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2
	POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9
	POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5
	POST_COLOR_MATRIX_RED_BIAS = 0x80B8
	POST_COLOR_MATRIX_RED_SCALE = 0x80B4
	POST_CONVOLUTION_ALPHA_BIAS = 0x8023
	POST_CONVOLUTION_ALPHA_SCALE = 0x801F
	POST_CONVOLUTION_BLUE_BIAS = 0x8022
	POST_CONVOLUTION_BLUE_SCALE = 0x801E
	POST_CONVOLUTION_COLOR_TABLE = 0x80D1
	POST_CONVOLUTION_GREEN_BIAS = 0x8021
	POST_CONVOLUTION_GREEN_SCALE = 0x801D
	POST_CONVOLUTION_RED_BIAS = 0x8020
	POST_CONVOLUTION_RED_SCALE = 0x801C
	PROXY_COLOR_TABLE = 0x80D3
	PROXY_HISTOGRAM = 0x8025
	PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5
	PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4
	REDUCE = 0x8016
	REPLICATE_BORDER = 0x8153
	SEPARABLE_2D = 0x8012
	TABLE_TOO_LARGE = 0x8031
)
// ARB_instanced_arrays
const (
	VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE
)
// ARB_internalformat_query
const (
)
// ARB_internalformat_query2
const (
	AUTO_GENERATE_MIPMAP = 0x8295
	CAVEAT_SUPPORT = 0x82B8
	CLEAR_BUFFER = 0x82B4
	COLOR_COMPONENTS = 0x8283
	COLOR_ENCODING = 0x8296
	COLOR_RENDERABLE = 0x8286
	COMPUTE_TEXTURE = 0x82A0
	DEPTH_COMPONENTS = 0x8284
	DEPTH_RENDERABLE = 0x8287
	FILTER = 0x829A
	FRAGMENT_TEXTURE = 0x829F
	FRAMEBUFFER_BLEND = 0x828B
	FRAMEBUFFER_RENDERABLE = 0x8289
	FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A
	FULL_SUPPORT = 0x82B7
	GEOMETRY_TEXTURE = 0x829E
	GET_TEXTURE_IMAGE_FORMAT = 0x8291
	GET_TEXTURE_IMAGE_TYPE = 0x8292
	IMAGE_CLASS_10_10_10_2 = 0x82C3
	IMAGE_CLASS_11_11_10 = 0x82C2
	IMAGE_CLASS_1_X_16 = 0x82BE
	IMAGE_CLASS_1_X_32 = 0x82BB
	IMAGE_CLASS_1_X_8 = 0x82C1
	IMAGE_CLASS_2_X_16 = 0x82BD
	IMAGE_CLASS_2_X_32 = 0x82BA
	IMAGE_CLASS_2_X_8 = 0x82C0
	IMAGE_CLASS_4_X_16 = 0x82BC
	IMAGE_CLASS_4_X_32 = 0x82B9
	IMAGE_CLASS_4_X_8 = 0x82BF
	IMAGE_COMPATIBILITY_CLASS = 0x82A8
	IMAGE_PIXEL_FORMAT = 0x82A9
	IMAGE_PIXEL_TYPE = 0x82AA
	IMAGE_TEXEL_SIZE = 0x82A7
	INTERNALFORMAT_ALPHA_SIZE = 0x8274
	INTERNALFORMAT_ALPHA_TYPE = 0x827B
	INTERNALFORMAT_BLUE_SIZE = 0x8273
	INTERNALFORMAT_BLUE_TYPE = 0x827A
	INTERNALFORMAT_DEPTH_SIZE = 0x8275
	INTERNALFORMAT_DEPTH_TYPE = 0x827C
	INTERNALFORMAT_GREEN_SIZE = 0x8272
	INTERNALFORMAT_GREEN_TYPE = 0x8279
	INTERNALFORMAT_PREFERRED = 0x8270
	INTERNALFORMAT_RED_SIZE = 0x8271
	INTERNALFORMAT_RED_TYPE = 0x8278
	INTERNALFORMAT_SHARED_SIZE = 0x8277
	INTERNALFORMAT_STENCIL_SIZE = 0x8276
	INTERNALFORMAT_STENCIL_TYPE = 0x827D
	INTERNALFORMAT_SUPPORTED = 0x826F
	MANUAL_GENERATE_MIPMAP = 0x8294
	MAX_COMBINED_DIMENSIONS = 0x8282
	MAX_DEPTH = 0x8280
	MAX_HEIGHT = 0x827F
	MAX_LAYERS = 0x8281
	MAX_WIDTH = 0x827E
	MIPMAP = 0x8293
	READ_PIXELS = 0x828C
	READ_PIXELS_FORMAT = 0x828D
	READ_PIXELS_TYPE = 0x828E
	SAMPLES = 0x80A9
	SHADER_IMAGE_ATOMIC = 0x82A6
	SHADER_IMAGE_LOAD = 0x82A4
	SHADER_IMAGE_STORE = 0x82A5
	SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC
	SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE
	SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD
	SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF
	SRGB_DECODE_ARB = 0x8299
	SRGB_READ = 0x8297
	SRGB_WRITE = 0x8298
	STENCIL_COMPONENTS = 0x8285
	STENCIL_RENDERABLE = 0x8288
	TESS_CONTROL_TEXTURE = 0x829C
	TESS_EVALUATION_TEXTURE = 0x829D
	TEXTURE_1D_ARRAY = 0x8C18
	TEXTURE_2D_ARRAY = 0x8C1A
	TEXTURE_3D = 0x806F
	TEXTURE_BUFFER = 0x8C2A
	TEXTURE_COMPRESSED = 0x86A1
	TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2
	TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3
	TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1
	TEXTURE_CUBE_MAP = 0x8513
	TEXTURE_GATHER = 0x82A2
	TEXTURE_GATHER_SHADOW = 0x82A3
	TEXTURE_IMAGE_FORMAT = 0x828F
	TEXTURE_IMAGE_TYPE = 0x8290
	TEXTURE_RECTANGLE = 0x84F5
	TEXTURE_SHADOW = 0x82A1
	TEXTURE_VIEW = 0x82B5
	VERTEX_TEXTURE = 0x829B
	VIEW_CLASS_128_BITS = 0x82C4
	VIEW_CLASS_16_BITS = 0x82CA
	VIEW_CLASS_24_BITS = 0x82C9
	VIEW_CLASS_32_BITS = 0x82C8
	VIEW_CLASS_48_BITS = 0x82C7
	VIEW_CLASS_64_BITS = 0x82C6
	VIEW_CLASS_8_BITS = 0x82CB
	VIEW_CLASS_96_BITS = 0x82C5
	VIEW_CLASS_BPTC_FLOAT = 0x82D3
	VIEW_CLASS_BPTC_UNORM = 0x82D2
	VIEW_CLASS_RGTC1_RED = 0x82D0
	VIEW_CLASS_RGTC2_RG = 0x82D1
	VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC
	VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD
	VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE
	VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF
	VIEW_COMPATIBILITY_CLASS = 0x82B6
)
// ARB_invalidate_subdata
const (
)
// ARB_map_buffer_alignment
const (
	MIN_MAP_BUFFER_ALIGNMENT = 0x90BC
)
// ARB_map_buffer_range
const (
	MAP_FLUSH_EXPLICIT_BIT = 0x0010
	MAP_INVALIDATE_BUFFER_BIT = 0x0008
	MAP_INVALIDATE_RANGE_BIT = 0x0004
	MAP_READ_BIT = 0x0001
	MAP_UNSYNCHRONIZED_BIT = 0x0020
	MAP_WRITE_BIT = 0x0002
)
// ARB_matrix_palette
const (
	CURRENT_MATRIX_INDEX_ARB = 0x8845
	CURRENT_PALETTE_MATRIX_ARB = 0x8843
	MATRIX_INDEX_ARRAY_ARB = 0x8844
	MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849
	MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846
	MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848
	MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847
	MATRIX_PALETTE_ARB = 0x8840
	MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841
	MAX_PALETTE_MATRICES_ARB = 0x8842
)
// ARB_multi_draw_indirect
const (
)
// ARB_multisample
const (
	MULTISAMPLE_ARB = 0x809D
	MULTISAMPLE_BIT_ARB = 0x20000000
	SAMPLES_ARB = 0x80A9
	SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E
	SAMPLE_ALPHA_TO_ONE_ARB = 0x809F
	SAMPLE_BUFFERS_ARB = 0x80A8
	SAMPLE_COVERAGE_ARB = 0x80A0
	SAMPLE_COVERAGE_INVERT_ARB = 0x80AB
	SAMPLE_COVERAGE_VALUE_ARB = 0x80AA
)
// ARB_multitexture
const (
	ACTIVE_TEXTURE_ARB = 0x84E0
	CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1
	MAX_TEXTURE_UNITS_ARB = 0x84E2
	TEXTURE0_ARB = 0x84C0
	TEXTURE10_ARB = 0x84CA
	TEXTURE11_ARB = 0x84CB
	TEXTURE12_ARB = 0x84CC
	TEXTURE13_ARB = 0x84CD
	TEXTURE14_ARB = 0x84CE
	TEXTURE15_ARB = 0x84CF
	TEXTURE16_ARB = 0x84D0
	TEXTURE17_ARB = 0x84D1
	TEXTURE18_ARB = 0x84D2
	TEXTURE19_ARB = 0x84D3
	TEXTURE1_ARB = 0x84C1
	TEXTURE20_ARB = 0x84D4
	TEXTURE21_ARB = 0x84D5
	TEXTURE22_ARB = 0x84D6
	TEXTURE23_ARB = 0x84D7
	TEXTURE24_ARB = 0x84D8
	TEXTURE25_ARB = 0x84D9
	TEXTURE26_ARB = 0x84DA
	TEXTURE27_ARB = 0x84DB
	TEXTURE28_ARB = 0x84DC
	TEXTURE29_ARB = 0x84DD
	TEXTURE2_ARB = 0x84C2
	TEXTURE30_ARB = 0x84DE
	TEXTURE31_ARB = 0x84DF
	TEXTURE3_ARB = 0x84C3
	TEXTURE4_ARB = 0x84C4
	TEXTURE5_ARB = 0x84C5
	TEXTURE6_ARB = 0x84C6
	TEXTURE7_ARB = 0x84C7
	TEXTURE8_ARB = 0x84C8
	TEXTURE9_ARB = 0x84C9
)
// ARB_occlusion_query
const (
	CURRENT_QUERY_ARB = 0x8865
	QUERY_COUNTER_BITS_ARB = 0x8864
	QUERY_RESULT_ARB = 0x8866
	QUERY_RESULT_AVAILABLE_ARB = 0x8867
	SAMPLES_PASSED_ARB = 0x8914
)
// ARB_occlusion_query2
const (
	ANY_SAMPLES_PASSED = 0x8C2F
)
// ARB_pixel_buffer_object
const (
	PIXEL_PACK_BUFFER_ARB = 0x88EB
	PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED
	PIXEL_UNPACK_BUFFER_ARB = 0x88EC
	PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF
)
// ARB_point_parameters
const (
	POINT_DISTANCE_ATTENUATION_ARB = 0x8129
	POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128
	POINT_SIZE_MAX_ARB = 0x8127
	POINT_SIZE_MIN_ARB = 0x8126
)
// ARB_point_sprite
const (
	COORD_REPLACE_ARB = 0x8862
	POINT_SPRITE_ARB = 0x8861
)
// ARB_program_interface_query
const (
	ACTIVE_RESOURCES = 0x92F5
	ACTIVE_VARIABLES = 0x9305
	ARRAY_SIZE = 0x92FB
	ARRAY_STRIDE = 0x92FE
	ATOMIC_COUNTER_BUFFER_INDEX = 0x9301
	BLOCK_INDEX = 0x92FD
	BUFFER_BINDING = 0x9302
	BUFFER_DATA_SIZE = 0x9303
	BUFFER_VARIABLE = 0x92E5
	COMPUTE_SUBROUTINE = 0x92ED
	COMPUTE_SUBROUTINE_UNIFORM = 0x92F3
	FRAGMENT_SUBROUTINE = 0x92EC
	FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2
	GEOMETRY_SUBROUTINE = 0x92EB
	GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1
	IS_PER_PATCH = 0x92E7
	IS_ROW_MAJOR = 0x9300
	LOCATION = 0x930E
	LOCATION_INDEX = 0x930F
	MATRIX_STRIDE = 0x92FF
	MAX_NAME_LENGTH = 0x92F6
	MAX_NUM_ACTIVE_VARIABLES = 0x92F7
	MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8
	NAME_LENGTH = 0x92F9
	NUM_ACTIVE_VARIABLES = 0x9304
	OFFSET = 0x92FC
	PROGRAM_INPUT = 0x92E3
	PROGRAM_OUTPUT = 0x92E4
	REFERENCED_BY_COMPUTE_SHADER = 0x930B
	REFERENCED_BY_FRAGMENT_SHADER = 0x930A
	REFERENCED_BY_GEOMETRY_SHADER = 0x9309
	REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307
	REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308
	REFERENCED_BY_VERTEX_SHADER = 0x9306
	SHADER_STORAGE_BLOCK = 0x92E6
	TESS_CONTROL_SUBROUTINE = 0x92E9
	TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF
	TESS_EVALUATION_SUBROUTINE = 0x92EA
	TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0
	TOP_LEVEL_ARRAY_SIZE = 0x930C
	TOP_LEVEL_ARRAY_STRIDE = 0x930D
	TRANSFORM_FEEDBACK_VARYING = 0x92F4
	TYPE = 0x92FA
	UNIFORM = 0x92E1
	UNIFORM_BLOCK = 0x92E2
	VERTEX_SUBROUTINE = 0x92E8
	VERTEX_SUBROUTINE_UNIFORM = 0x92EE
)
// ARB_provoking_vertex
const (
	QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C
)
// ARB_robust_buffer_access_behavior
const (
)
// ARB_robustness
const (
	CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004
	GUILTY_CONTEXT_RESET_ARB = 0x8253
	INNOCENT_CONTEXT_RESET_ARB = 0x8254
	LOSE_CONTEXT_ON_RESET_ARB = 0x8252
	NO_ERROR = 0
	NO_RESET_NOTIFICATION_ARB = 0x8261
	RESET_NOTIFICATION_STRATEGY_ARB = 0x8256
	UNKNOWN_CONTEXT_RESET_ARB = 0x8255
)
// ARB_robustness_isolation
const (
)
// ARB_sample_shading
const (
	MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37
	SAMPLE_SHADING_ARB = 0x8C36
)
// ARB_sampler_objects
const (
	SAMPLER_BINDING = 0x8919
)
// ARB_seamless_cube_map
const (
	TEXTURE_CUBE_MAP_SEAMLESS = 0x884F
)
// ARB_separate_shader_objects
const (
	ACTIVE_PROGRAM = 0x8259
	ALL_SHADER_BITS = 0xFFFFFFFF
	FRAGMENT_SHADER_BIT = 0x00000002
	GEOMETRY_SHADER_BIT = 0x00000004
	PROGRAM_PIPELINE_BINDING = 0x825A
	PROGRAM_SEPARABLE = 0x8258
	TESS_CONTROL_SHADER_BIT = 0x00000008
	TESS_EVALUATION_SHADER_BIT = 0x00000010
	VERTEX_SHADER_BIT = 0x00000001
)
// ARB_shader_atomic_counters
const (
	ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9
	ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5
	ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6
	ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1
	ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9
	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7
	ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3
	ATOMIC_COUNTER_BUFFER_START = 0x92C2
	MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC
	MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8
	MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7
	MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1
	MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6
	MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0
	MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5
	MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF
	MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3
	MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD
	MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4
	MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE
	MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2
	MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC
	UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA
	UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB
)
// ARB_shader_bit_encoding
const (
)
// ARB_shader_image_load_store
const (
	ALL_BARRIER_BITS = 0xFFFFFFFF
	ATOMIC_COUNTER_BARRIER_BIT = 0x00001000
	BUFFER_UPDATE_BARRIER_BIT = 0x00000200
	COMMAND_BARRIER_BIT = 0x00000040
	ELEMENT_ARRAY_BARRIER_BIT = 0x00000002
	FRAMEBUFFER_BARRIER_BIT = 0x00000400
	IMAGE_1D = 0x904C
	IMAGE_1D_ARRAY = 0x9052
	IMAGE_2D = 0x904D
	IMAGE_2D_ARRAY = 0x9053
	IMAGE_2D_MULTISAMPLE = 0x9055
	IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056
	IMAGE_2D_RECT = 0x904F
	IMAGE_3D = 0x904E
	IMAGE_BINDING_ACCESS = 0x8F3E
	IMAGE_BINDING_FORMAT = 0x906E
	IMAGE_BINDING_LAYER = 0x8F3D
	IMAGE_BINDING_LAYERED = 0x8F3C
	IMAGE_BINDING_LEVEL = 0x8F3B
	IMAGE_BINDING_NAME = 0x8F3A
	IMAGE_BUFFER = 0x9051
	IMAGE_CUBE = 0x9050
	IMAGE_CUBE_MAP_ARRAY = 0x9054
	IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9
	IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8
	INT_IMAGE_1D = 0x9057
	INT_IMAGE_1D_ARRAY = 0x905D
	INT_IMAGE_2D = 0x9058
	INT_IMAGE_2D_ARRAY = 0x905E
	INT_IMAGE_2D_MULTISAMPLE = 0x9060
	INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061
	INT_IMAGE_2D_RECT = 0x905A
	INT_IMAGE_3D = 0x9059
	INT_IMAGE_BUFFER = 0x905C
	INT_IMAGE_CUBE = 0x905B
	INT_IMAGE_CUBE_MAP_ARRAY = 0x905F
	MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF
	MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE
	MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD
	MAX_IMAGE_SAMPLES = 0x906D
	MAX_IMAGE_UNITS = 0x8F38
	MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB
	MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC
	MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA
	PIXEL_BUFFER_BARRIER_BIT = 0x00000080
	SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020
	TEXTURE_FETCH_BARRIER_BIT = 0x00000008
	TEXTURE_UPDATE_BARRIER_BIT = 0x00000100
	TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800
	UNIFORM_BARRIER_BIT = 0x00000004
	UNSIGNED_INT_IMAGE_1D = 0x9062
	UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068
	UNSIGNED_INT_IMAGE_2D = 0x9063
	UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069
	UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B
	UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C
	UNSIGNED_INT_IMAGE_2D_RECT = 0x9065
	UNSIGNED_INT_IMAGE_3D = 0x9064
	UNSIGNED_INT_IMAGE_BUFFER = 0x9067
	UNSIGNED_INT_IMAGE_CUBE = 0x9066
	UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A
	VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001
)
// ARB_shader_image_size
const (
)
// ARB_shader_objects
const (
	BOOL_ARB = 0x8B56
	BOOL_VEC2_ARB = 0x8B57
	BOOL_VEC3_ARB = 0x8B58
	BOOL_VEC4_ARB = 0x8B59
	FLOAT_MAT2_ARB = 0x8B5A
	FLOAT_MAT3_ARB = 0x8B5B
	FLOAT_MAT4_ARB = 0x8B5C
	FLOAT_VEC2_ARB = 0x8B50
	FLOAT_VEC3_ARB = 0x8B51
	FLOAT_VEC4_ARB = 0x8B52
	INT_VEC2_ARB = 0x8B53
	INT_VEC3_ARB = 0x8B54
	INT_VEC4_ARB = 0x8B55
	OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86
	OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87
	OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85
	OBJECT_COMPILE_STATUS_ARB = 0x8B81
	OBJECT_DELETE_STATUS_ARB = 0x8B80
	OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84
	OBJECT_LINK_STATUS_ARB = 0x8B82
	OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88
	OBJECT_SUBTYPE_ARB = 0x8B4F
	OBJECT_TYPE_ARB = 0x8B4E
	OBJECT_VALIDATE_STATUS_ARB = 0x8B83
	PROGRAM_OBJECT_ARB = 0x8B40
	SAMPLER_1D_ARB = 0x8B5D
	SAMPLER_1D_SHADOW_ARB = 0x8B61
	SAMPLER_2D_ARB = 0x8B5E
	SAMPLER_2D_RECT_ARB = 0x8B63
	SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64
	SAMPLER_2D_SHADOW_ARB = 0x8B62
	SAMPLER_3D_ARB = 0x8B5F
	SAMPLER_CUBE_ARB = 0x8B60
	SHADER_OBJECT_ARB = 0x8B48
)
// ARB_shader_precision
const (
)
// ARB_shader_stencil_export
const (
)
// ARB_shader_storage_buffer_object
const (
	MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39
	MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC
	MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB
	MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA
	MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7
	MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE
	MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD
	MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8
	MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9
	MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6
	SHADER_STORAGE_BARRIER_BIT = 0x2000
	SHADER_STORAGE_BUFFER = 0x90D2
	SHADER_STORAGE_BUFFER_BINDING = 0x90D3
	SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF
	SHADER_STORAGE_BUFFER_SIZE = 0x90D5
	SHADER_STORAGE_BUFFER_START = 0x90D4
)
// ARB_shader_subroutine
const (
	ACTIVE_SUBROUTINES = 0x8DE5
	ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48
	ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6
	ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47
	ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49
	MAX_SUBROUTINES = 0x8DE7
	MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8
)
// ARB_shader_texture_lod
const (
)
// ARB_shading_language_100
const (
	SHADING_LANGUAGE_VERSION_ARB = 0x8B8C
)
// ARB_shading_language_420pack
const (
)
// ARB_shading_language_include
const (
	NAMED_STRING_LENGTH_ARB = 0x8DE9
	NAMED_STRING_TYPE_ARB = 0x8DEA
	SHADER_INCLUDE_ARB = 0x8DAE
)
// ARB_shading_language_packing
const (
)
// ARB_shadow
const (
	COMPARE_R_TO_TEXTURE_ARB = 0x884E
	TEXTURE_COMPARE_FUNC_ARB = 0x884D
	TEXTURE_COMPARE_MODE_ARB = 0x884C
)
// ARB_shadow_ambient
const (
	TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF
)
// ARB_stencil_texturing
const (
	DEPTH_STENCIL_TEXTURE_MODE = 0x90EA
)
// ARB_sync
const (
	ALREADY_SIGNALED = 0x911A
	CONDITION_SATISFIED = 0x911C
	MAX_SERVER_WAIT_TIMEOUT = 0x9111
	OBJECT_TYPE = 0x9112
	SIGNALED = 0x9119
	SYNC_CONDITION = 0x9113
	SYNC_FENCE = 0x9116
	SYNC_FLAGS = 0x9115
	SYNC_FLUSH_COMMANDS_BIT = 0x00000001
	SYNC_GPU_COMMANDS_COMPLETE = 0x9117
	SYNC_STATUS = 0x9114
	TIMEOUT_EXPIRED = 0x911B
	TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF
	UNSIGNALED = 0x9118
	WAIT_FAILED = 0x911D
)
// ARB_tessellation_shader
const (
	CCW = 0x0901
	CW = 0x0900
	EQUAL = 0x0202
	FRACTIONAL_EVEN = 0x8E7C
	FRACTIONAL_ODD = 0x8E7B
	ISOLINES = 0x8E7A
	MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E
	MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F
	MAX_PATCH_VERTICES = 0x8E7D
	MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C
	MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83
	MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81
	MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85
	MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89
	MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F
	MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D
	MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86
	MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82
	MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A
	MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80
	MAX_TESS_GEN_LEVEL = 0x8E7E
	MAX_TESS_PATCH_COMPONENTS = 0x8E84
	PATCHES = 0x000E
	PATCH_DEFAULT_INNER_LEVEL = 0x8E73
	PATCH_DEFAULT_OUTER_LEVEL = 0x8E74
	PATCH_VERTICES = 0x8E72
	QUADS = 0x0007
	TESS_CONTROL_OUTPUT_VERTICES = 0x8E75
	TESS_CONTROL_SHADER = 0x8E88
	TESS_EVALUATION_SHADER = 0x8E87
	TESS_GEN_MODE = 0x8E76
	TESS_GEN_POINT_MODE = 0x8E79
	TESS_GEN_SPACING = 0x8E77
	TESS_GEN_VERTEX_ORDER = 0x8E78
	TRIANGLES = 0x0004
	UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0
	UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1
)
// ARB_texture_border_clamp
const (
	CLAMP_TO_BORDER_ARB = 0x812D
)
// ARB_texture_buffer_object
const (
	MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B
	TEXTURE_BINDING_BUFFER_ARB = 0x8C2C
	TEXTURE_BUFFER_ARB = 0x8C2A
	TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D
	TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E
)
// ARB_texture_buffer_object_rgb32
const (
	RGB32F = 0x8815
	RGB32UI = 0x8D71
)
// ARB_texture_buffer_range
const (
	TEXTURE_BUFFER_OFFSET = 0x919D
	TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F
	TEXTURE_BUFFER_SIZE = 0x919E
)
// ARB_texture_compression
const (
	COMPRESSED_ALPHA_ARB = 0x84E9
	COMPRESSED_INTENSITY_ARB = 0x84EC
	COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB
	COMPRESSED_LUMINANCE_ARB = 0x84EA
	COMPRESSED_RGBA_ARB = 0x84EE
	COMPRESSED_RGB_ARB = 0x84ED
	COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3
	NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2
	TEXTURE_COMPRESSED_ARB = 0x86A1
	TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0
	TEXTURE_COMPRESSION_HINT_ARB = 0x84EF
)
// ARB_texture_compression_bptc
const (
	COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C
	COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E
	COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F
	COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D
)
// ARB_texture_compression_rgtc
const (
	COMPRESSED_RED_RGTC1 = 0x8DBB
	COMPRESSED_RG_RGTC2 = 0x8DBD
	COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC
	COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE
)
// ARB_texture_cube_map
const (
	MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C
	NORMAL_MAP_ARB = 0x8511
	PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B
	REFLECTION_MAP_ARB = 0x8512
	TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514
	TEXTURE_CUBE_MAP_ARB = 0x8513
	TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516
	TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518
	TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A
	TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515
	TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517
	TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519
)
// ARB_texture_cube_map_array
const (
	INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E
	PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B
	SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C
	SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D
	TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A
	TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009
	UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F
)
// ARB_texture_env_add
const (
)
// ARB_texture_env_combine
const (
	ADD_SIGNED_ARB = 0x8574
	COMBINE_ALPHA_ARB = 0x8572
	COMBINE_ARB = 0x8570
	COMBINE_RGB_ARB = 0x8571
	CONSTANT_ARB = 0x8576
	INTERPOLATE_ARB = 0x8575
	OPERAND0_ALPHA_ARB = 0x8598
	OPERAND0_RGB_ARB = 0x8590
	OPERAND1_ALPHA_ARB = 0x8599
	OPERAND1_RGB_ARB = 0x8591
	OPERAND2_ALPHA_ARB = 0x859A
	OPERAND2_RGB_ARB = 0x8592
	PREVIOUS_ARB = 0x8578
	PRIMARY_COLOR_ARB = 0x8577
	RGB_SCALE_ARB = 0x8573
	SOURCE0_ALPHA_ARB = 0x8588
	SOURCE0_RGB_ARB = 0x8580
	SOURCE1_ALPHA_ARB = 0x8589
	SOURCE1_RGB_ARB = 0x8581
	SOURCE2_ALPHA_ARB = 0x858A
	SOURCE2_RGB_ARB = 0x8582
	SUBTRACT_ARB = 0x84E7
)
// ARB_texture_env_crossbar
const (
)
// ARB_texture_env_dot3
const (
	DOT3_RGBA_ARB = 0x86AF
	DOT3_RGB_ARB = 0x86AE
)
// ARB_texture_float
const (
	ALPHA16F_ARB = 0x881C
	ALPHA32F_ARB = 0x8816
	INTENSITY16F_ARB = 0x881D
	INTENSITY32F_ARB = 0x8817
	LUMINANCE16F_ARB = 0x881E
	LUMINANCE32F_ARB = 0x8818
	LUMINANCE_ALPHA16F_ARB = 0x881F
	LUMINANCE_ALPHA32F_ARB = 0x8819
	RGB16F_ARB = 0x881B
	RGB32F_ARB = 0x8815
	RGBA16F_ARB = 0x881A
	RGBA32F_ARB = 0x8814
	TEXTURE_ALPHA_TYPE_ARB = 0x8C13
	TEXTURE_BLUE_TYPE_ARB = 0x8C12
	TEXTURE_DEPTH_TYPE_ARB = 0x8C16
	TEXTURE_GREEN_TYPE_ARB = 0x8C11
	TEXTURE_INTENSITY_TYPE_ARB = 0x8C15
	TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14
	TEXTURE_RED_TYPE_ARB = 0x8C10
	UNSIGNED_NORMALIZED_ARB = 0x8C17
)
// ARB_texture_gather
const (
	MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F
	MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F
	MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E
)
// ARB_texture_mirrored_repeat
const (
	MIRRORED_REPEAT_ARB = 0x8370
)
// ARB_texture_multisample
const (
	INT_SAMPLER_2D_MULTISAMPLE = 0x9109
	INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C
	MAX_COLOR_TEXTURE_SAMPLES = 0x910E
	MAX_DEPTH_TEXTURE_SAMPLES = 0x910F
	MAX_INTEGER_SAMPLES = 0x9110
	MAX_SAMPLE_MASK_WORDS = 0x8E59
	PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101
	PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103
	SAMPLER_2D_MULTISAMPLE = 0x9108
	SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B
	SAMPLE_MASK = 0x8E51
	SAMPLE_MASK_VALUE = 0x8E52
	SAMPLE_POSITION = 0x8E50
	TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104
	TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105
	TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107
	TEXTURE_SAMPLES = 0x9106
	UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A
	UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D
)
// ARB_texture_non_power_of_two
const (
)
// ARB_texture_query_levels
const (
)
// ARB_texture_query_lod
const (
)
// ARB_texture_rectangle
const (
	MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8
	PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7
	TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6
	TEXTURE_RECTANGLE_ARB = 0x84F5
)
// ARB_texture_rg
const (
	R16 = 0x822A
	R16F = 0x822D
	R16I = 0x8233
	R16UI = 0x8234
	R32F = 0x822E
	R32I = 0x8235
	R32UI = 0x8236
	R8 = 0x8229
	R8I = 0x8231
	R8UI = 0x8232
	RG = 0x8227
	RG16 = 0x822C
	RG16F = 0x822F
	RG16I = 0x8239
	RG16UI = 0x823A
	RG32F = 0x8230
	RG32I = 0x823B
	RG32UI = 0x823C
	RG8 = 0x822B
	RG8I = 0x8237
	RG8UI = 0x8238
	RG_INTEGER = 0x8228
)
// ARB_texture_rgb10_a2ui
const (
	RGB10_A2UI = 0x906F
)
// ARB_texture_storage
const (
	TEXTURE_IMMUTABLE_FORMAT = 0x912F
)
// ARB_texture_storage_multisample
const (
)
// ARB_texture_swizzle
const (
	TEXTURE_SWIZZLE_A = 0x8E45
	TEXTURE_SWIZZLE_B = 0x8E44
	TEXTURE_SWIZZLE_G = 0x8E43
	TEXTURE_SWIZZLE_R = 0x8E42
	TEXTURE_SWIZZLE_RGBA = 0x8E46
)
// ARB_texture_view
const (
	TEXTURE_IMMUTABLE_LEVELS = 0x82DF
	TEXTURE_VIEW_MIN_LAYER = 0x82DD
	TEXTURE_VIEW_MIN_LEVEL = 0x82DB
	TEXTURE_VIEW_NUM_LAYERS = 0x82DE
	TEXTURE_VIEW_NUM_LEVELS = 0x82DC
)
// ARB_timer_query
const (
	TIMESTAMP = 0x8E28
	TIME_ELAPSED = 0x88BF
)
// ARB_transform_feedback2
const (
	TRANSFORM_FEEDBACK = 0x8E22
	TRANSFORM_FEEDBACK_ACTIVE = 0x8E24
	TRANSFORM_FEEDBACK_BINDING = 0x8E25
	TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24
	TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23
	TRANSFORM_FEEDBACK_PAUSED = 0x8E23
)
// ARB_transform_feedback3
const (
	MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70
	MAX_VERTEX_STREAMS = 0x8E71
)
// ARB_transform_feedback_instanced
const (
)
// ARB_transpose_matrix
const (
	TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6
	TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3
	TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4
	TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5
)
// ARB_uniform_buffer_object
const (
	ACTIVE_UNIFORM_BLOCKS = 0x8A36
	ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35
	INVALID_INDEX = 0xFFFFFFFF
	MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33
	MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32
	MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E
	MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31
	MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D
	MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C
	MAX_UNIFORM_BLOCK_SIZE = 0x8A30
	MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F
	MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B
	UNIFORM_ARRAY_STRIDE = 0x8A3C
	UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42
	UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43
	UNIFORM_BLOCK_BINDING = 0x8A3F
	UNIFORM_BLOCK_DATA_SIZE = 0x8A40
	UNIFORM_BLOCK_INDEX = 0x8A3A
	UNIFORM_BLOCK_NAME_LENGTH = 0x8A41
	UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46
	UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45
	UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44
	UNIFORM_BUFFER = 0x8A11
	UNIFORM_BUFFER_BINDING = 0x8A28
	UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34
	UNIFORM_BUFFER_SIZE = 0x8A2A
	UNIFORM_BUFFER_START = 0x8A29
	UNIFORM_IS_ROW_MAJOR = 0x8A3E
	UNIFORM_MATRIX_STRIDE = 0x8A3D
	UNIFORM_OFFSET = 0x8A3B
	UNIFORM_TYPE = 0x8A37
)
// ARB_vertex_array_bgra
const (
	BGRA = 0x80E1
)
// ARB_vertex_array_object
const (
	VERTEX_ARRAY_BINDING = 0x85B5
)
// ARB_vertex_attrib_64bit
const (
)
// ARB_vertex_attrib_binding
const (
	MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA
	MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9
	VERTEX_ATTRIB_BINDING = 0x82D4
	VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5
	VERTEX_BINDING_DIVISOR = 0x82D6
	VERTEX_BINDING_OFFSET = 0x82D7
	VERTEX_BINDING_STRIDE = 0x82D8
)
// ARB_vertex_blend
const (
	ACTIVE_VERTEX_UNITS_ARB = 0x86A5
	CURRENT_WEIGHT_ARB = 0x86A8
	MAX_VERTEX_UNITS_ARB = 0x86A4
	MODELVIEW0_ARB = 0x1700
	MODELVIEW10_ARB = 0x872A
	MODELVIEW11_ARB = 0x872B
	MODELVIEW12_ARB = 0x872C
	MODELVIEW13_ARB = 0x872D
	MODELVIEW14_ARB = 0x872E
	MODELVIEW15_ARB = 0x872F
	MODELVIEW16_ARB = 0x8730
	MODELVIEW17_ARB = 0x8731
	MODELVIEW18_ARB = 0x8732
	MODELVIEW19_ARB = 0x8733
	MODELVIEW1_ARB = 0x850A
	MODELVIEW20_ARB = 0x8734
	MODELVIEW21_ARB = 0x8735
	MODELVIEW22_ARB = 0x8736
	MODELVIEW23_ARB = 0x8737
	MODELVIEW24_ARB = 0x8738
	MODELVIEW25_ARB = 0x8739
	MODELVIEW26_ARB = 0x873A
	MODELVIEW27_ARB = 0x873B
	MODELVIEW28_ARB = 0x873C
	MODELVIEW29_ARB = 0x873D
	MODELVIEW2_ARB = 0x8722
	MODELVIEW30_ARB = 0x873E
	MODELVIEW31_ARB = 0x873F
	MODELVIEW3_ARB = 0x8723
	MODELVIEW4_ARB = 0x8724
	MODELVIEW5_ARB = 0x8725
	MODELVIEW6_ARB = 0x8726
	MODELVIEW7_ARB = 0x8727
	MODELVIEW8_ARB = 0x8728
	MODELVIEW9_ARB = 0x8729
	VERTEX_BLEND_ARB = 0x86A7
	WEIGHT_ARRAY_ARB = 0x86AD
	WEIGHT_ARRAY_POINTER_ARB = 0x86AC
	WEIGHT_ARRAY_SIZE_ARB = 0x86AB
	WEIGHT_ARRAY_STRIDE_ARB = 0x86AA
	WEIGHT_ARRAY_TYPE_ARB = 0x86A9
	WEIGHT_SUM_UNITY_ARB = 0x86A6
)
// ARB_vertex_buffer_object
const (
	ARRAY_BUFFER_ARB = 0x8892
	ARRAY_BUFFER_BINDING_ARB = 0x8894
	BUFFER_ACCESS_ARB = 0x88BB
	BUFFER_MAPPED_ARB = 0x88BC
	BUFFER_MAP_POINTER_ARB = 0x88BD
	BUFFER_SIZE_ARB = 0x8764
	BUFFER_USAGE_ARB = 0x8765
	COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898
	DYNAMIC_COPY_ARB = 0x88EA
	DYNAMIC_DRAW_ARB = 0x88E8
	DYNAMIC_READ_ARB = 0x88E9
	EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B
	ELEMENT_ARRAY_BUFFER_ARB = 0x8893
	ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895
	FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D
	INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899
	NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897
	READ_ONLY_ARB = 0x88B8
	READ_WRITE_ARB = 0x88BA
	SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C
	STATIC_COPY_ARB = 0x88E6
	STATIC_DRAW_ARB = 0x88E4
	STATIC_READ_ARB = 0x88E5
	STREAM_COPY_ARB = 0x88E2
	STREAM_DRAW_ARB = 0x88E0
	STREAM_READ_ARB = 0x88E1
	TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A
	VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896
	VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F
	WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E
	WRITE_ONLY_ARB = 0x88B9
)
// ARB_vertex_program
const (
	COLOR_SUM_ARB = 0x8458
	CURRENT_MATRIX_ARB = 0x8641
	CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640
	CURRENT_VERTEX_ATTRIB_ARB = 0x8626
	MATRIX0_ARB = 0x88C0
	MATRIX10_ARB = 0x88CA
	MATRIX11_ARB = 0x88CB
	MATRIX12_ARB = 0x88CC
	MATRIX13_ARB = 0x88CD
	MATRIX14_ARB = 0x88CE
	MATRIX15_ARB = 0x88CF
	MATRIX16_ARB = 0x88D0
	MATRIX17_ARB = 0x88D1
	MATRIX18_ARB = 0x88D2
	MATRIX19_ARB = 0x88D3
	MATRIX1_ARB = 0x88C1
	MATRIX20_ARB = 0x88D4
	MATRIX21_ARB = 0x88D5
	MATRIX22_ARB = 0x88D6
	MATRIX23_ARB = 0x88D7
	MATRIX24_ARB = 0x88D8
	MATRIX25_ARB = 0x88D9
	MATRIX26_ARB = 0x88DA
	MATRIX27_ARB = 0x88DB
	MATRIX28_ARB = 0x88DC
	MATRIX29_ARB = 0x88DD
	MATRIX2_ARB = 0x88C2
	MATRIX30_ARB = 0x88DE
	MATRIX31_ARB = 0x88DF
	MATRIX3_ARB = 0x88C3
	MATRIX4_ARB = 0x88C4
	MATRIX5_ARB = 0x88C5
	MATRIX6_ARB = 0x88C6
	MATRIX7_ARB = 0x88C7
	MATRIX8_ARB = 0x88C8
	MATRIX9_ARB = 0x88C9
	MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1
	MAX_PROGRAM_ATTRIBS_ARB = 0x88AD
	MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5
	MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1
	MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4
	MAX_PROGRAM_MATRICES_ARB = 0x862F
	MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E
	MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3
	MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF
	MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3
	MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB
	MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7
	MAX_PROGRAM_PARAMETERS_ARB = 0x88A9
	MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5
	MAX_VERTEX_ATTRIBS_ARB = 0x8869
	PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0
	PROGRAM_ATTRIBS_ARB = 0x88AC
	PROGRAM_BINDING_ARB = 0x8677
	PROGRAM_ERROR_POSITION_ARB = 0x864B
	PROGRAM_ERROR_STRING_ARB = 0x8874
	PROGRAM_FORMAT_ARB = 0x8876
	PROGRAM_FORMAT_ASCII_ARB = 0x8875
	PROGRAM_INSTRUCTIONS_ARB = 0x88A0
	PROGRAM_LENGTH_ARB = 0x8627
	PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2
	PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE
	PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2
	PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA
	PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6
	PROGRAM_PARAMETERS_ARB = 0x88A8
	PROGRAM_STRING_ARB = 0x8628
	PROGRAM_TEMPORARIES_ARB = 0x88A4
	PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6
	TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7
	VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622
	VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A
	VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645
	VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623
	VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624
	VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625
	VERTEX_PROGRAM_ARB = 0x8620
	VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642
	VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643
)
// ARB_vertex_shader
const (
	MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D
	MAX_VARYING_FLOATS_ARB = 0x8B4B
	MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C
	MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A
	OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89
	OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A
	VERTEX_SHADER_ARB = 0x8B31
)
// ARB_vertex_type_2_10_10_10_rev
const (
	INT_2_10_10_10_REV = 0x8D9F
	UNSIGNED_INT_2_10_10_10_REV = 0x8368
)
// ARB_viewport_array
const (
	DEPTH_RANGE = 0x0B70
	LAYER_PROVOKING_VERTEX = 0x825E
	MAX_VIEWPORTS = 0x825B
	SCISSOR_BOX = 0x0C10
	SCISSOR_TEST = 0x0C11
	UNDEFINED_VERTEX = 0x8260
	VIEWPORT = 0x0BA2
	VIEWPORT_BOUNDS_RANGE = 0x825D
	VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F
	VIEWPORT_SUBPIXEL_BITS = 0x825C
)
// ARB_window_pos
const (
)
// ARB_ES2_compatibility

func ReleaseShaderCompiler()  {
	C.goglReleaseShaderCompiler()
}
func ShaderBinary(count Sizei, shaders *Uint, binaryformat Enum, binary Pointer, length Sizei)  {
	C.goglShaderBinary((C.GLsizei)(count), (*C.GLuint)(shaders), (C.GLenum)(binaryformat), (unsafe.Pointer)(binary), (C.GLsizei)(length))
}
func GetShaderPrecisionFormat(shadertype Enum, precisiontype Enum, range_ *Int, precision *Int)  {
	C.goglGetShaderPrecisionFormat((C.GLenum)(shadertype), (C.GLenum)(precisiontype), (*C.GLint)(range_), (*C.GLint)(precision))
}
func DepthRangef(n Float, f Float)  {
	C.goglDepthRangef((C.GLfloat)(n), (C.GLfloat)(f))
}
func ClearDepthf(d Float)  {
	C.goglClearDepthf((C.GLfloat)(d))
}
// ARB_base_instance

func DrawArraysInstancedBaseInstance(mode Enum, first Int, count Sizei, instancecount Sizei, baseinstance Uint)  {
	C.goglDrawArraysInstancedBaseInstance((C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(instancecount), (C.GLuint)(baseinstance))
}
func DrawElementsInstancedBaseInstance(mode Enum, count Sizei, type_ Enum, indices Pointer, instancecount Sizei, baseinstance Uint)  {
	C.goglDrawElementsInstancedBaseInstance((C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLsizei)(instancecount), (C.GLuint)(baseinstance))
}
func DrawElementsInstancedBaseVertexBaseInstance(mode Enum, count Sizei, type_ Enum, indices Pointer, instancecount Sizei, basevertex Int, baseinstance Uint)  {
	C.goglDrawElementsInstancedBaseVertexBaseInstance((C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLsizei)(instancecount), (C.GLint)(basevertex), (C.GLuint)(baseinstance))
}
// ARB_blend_func_extended

func BindFragDataLocationIndexed(program Uint, colorNumber Uint, index Uint, name *Char)  {
	C.goglBindFragDataLocationIndexed((C.GLuint)(program), (C.GLuint)(colorNumber), (C.GLuint)(index), (*C.GLchar)(name))
}
func GetFragDataIndex(program Uint, name *Char) Int {
	return (Int)(C.goglGetFragDataIndex((C.GLuint)(program), (*C.GLchar)(name)))
}
// ARB_cl_event

func CreateSyncFromCLeventARB(context Pointer, event Pointer, flags Bitfield) Sync {
	return (Sync)(C.goglCreateSyncFromCLeventARB((*[0]byte)(context), (*[0]byte)(event), (C.GLbitfield)(flags)))
}
// ARB_clear_buffer_object

func ClearBufferData(target Enum, internalformat Enum, format Enum, type_ Enum, data Pointer)  {
	C.goglClearBufferData((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(format), (C.GLenum)(type_), (unsafe.Pointer)(data))
}
func ClearBufferSubData(target Enum, internalformat Enum, offset Intptr, size Sizeiptr, format Enum, type_ Enum, data Pointer)  {
	C.goglClearBufferSubData((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLenum)(format), (C.GLenum)(type_), (unsafe.Pointer)(data))
}
func ClearNamedBufferDataEXT(buffer Uint, internalformat Enum, format Enum, type_ Enum, data Pointer)  {
	C.goglClearNamedBufferDataEXT((C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLenum)(format), (C.GLenum)(type_), (unsafe.Pointer)(data))
}
func ClearNamedBufferSubDataEXT(buffer Uint, internalformat Enum, offset Sizeiptr, size Sizeiptr, format Enum, type_ Enum, data Pointer)  {
	C.goglClearNamedBufferSubDataEXT((C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLsizeiptr)(offset), (C.GLsizeiptr)(size), (C.GLenum)(format), (C.GLenum)(type_), (unsafe.Pointer)(data))
}
// ARB_color_buffer_float

func ClampColorARB(target Enum, clamp Enum)  {
	C.goglClampColorARB((C.GLenum)(target), (C.GLenum)(clamp))
}
// ARB_compute_shader

func DispatchCompute(num_groups_x Uint, num_groups_y Uint, num_groups_z Uint)  {
	C.goglDispatchCompute((C.GLuint)(num_groups_x), (C.GLuint)(num_groups_y), (C.GLuint)(num_groups_z))
}
func DispatchComputeIndirect(indirect Intptr)  {
	C.goglDispatchComputeIndirect((C.GLintptr)(indirect))
}
// ARB_copy_buffer

func CopyBufferSubData(readTarget Enum, writeTarget Enum, readOffset Intptr, writeOffset Intptr, size Sizeiptr)  {
	C.goglCopyBufferSubData((C.GLenum)(readTarget), (C.GLenum)(writeTarget), (C.GLintptr)(readOffset), (C.GLintptr)(writeOffset), (C.GLsizeiptr)(size))
}
// ARB_copy_image

func CopyImageSubData(srcName Uint, srcTarget Enum, srcLevel Int, srcX Int, srcY Int, srcZ Int, dstName Uint, dstTarget Enum, dstLevel Int, dstX Int, dstY Int, dstZ Int, srcWidth Sizei, srcHeight Sizei, srcDepth Sizei)  {
	C.goglCopyImageSubData((C.GLuint)(srcName), (C.GLenum)(srcTarget), (C.GLint)(srcLevel), (C.GLint)(srcX), (C.GLint)(srcY), (C.GLint)(srcZ), (C.GLuint)(dstName), (C.GLenum)(dstTarget), (C.GLint)(dstLevel), (C.GLint)(dstX), (C.GLint)(dstY), (C.GLint)(dstZ), (C.GLsizei)(srcWidth), (C.GLsizei)(srcHeight), (C.GLsizei)(srcDepth))
}
// ARB_debug_output

func DebugMessageControlARB(source Enum, type_ Enum, severity Enum, count Sizei, ids *Uint, enabled Boolean)  {
	C.goglDebugMessageControlARB((C.GLenum)(source), (C.GLenum)(type_), (C.GLenum)(severity), (C.GLsizei)(count), (*C.GLuint)(ids), (C.GLboolean)(enabled))
}
func DebugMessageInsertARB(source Enum, type_ Enum, id Uint, severity Enum, length Sizei, buf *Char)  {
	C.goglDebugMessageInsertARB((C.GLenum)(source), (C.GLenum)(type_), (C.GLuint)(id), (C.GLenum)(severity), (C.GLsizei)(length), (*C.GLchar)(buf))
}
func DebugMessageCallbackARB(callback Pointer, userParam Pointer)  {
	C.goglDebugMessageCallbackARB((*[0]byte)(callback), (unsafe.Pointer)(userParam))
}
func GetDebugMessageLogARB(count Uint, bufsize Sizei, sources *Enum, types *Enum, ids *Uint, severities *Enum, lengths *Sizei, messageLog *Char) Uint {
	return (Uint)(C.goglGetDebugMessageLogARB((C.GLuint)(count), (C.GLsizei)(bufsize), (*C.GLenum)(sources), (*C.GLenum)(types), (*C.GLuint)(ids), (*C.GLenum)(severities), (*C.GLsizei)(lengths), (*C.GLchar)(messageLog)))
}
// ARB_draw_buffers

func DrawBuffersARB(n Sizei, bufs *Enum)  {
	C.goglDrawBuffersARB((C.GLsizei)(n), (*C.GLenum)(bufs))
}
// ARB_draw_buffers_blend

func BlendEquationiARB(buf Uint, mode Enum)  {
	C.goglBlendEquationiARB((C.GLuint)(buf), (C.GLenum)(mode))
}
func BlendEquationSeparateiARB(buf Uint, modeRGB Enum, modeAlpha Enum)  {
	C.goglBlendEquationSeparateiARB((C.GLuint)(buf), (C.GLenum)(modeRGB), (C.GLenum)(modeAlpha))
}
func BlendFunciARB(buf Uint, src Enum, dst Enum)  {
	C.goglBlendFunciARB((C.GLuint)(buf), (C.GLenum)(src), (C.GLenum)(dst))
}
func BlendFuncSeparateiARB(buf Uint, srcRGB Enum, dstRGB Enum, srcAlpha Enum, dstAlpha Enum)  {
	C.goglBlendFuncSeparateiARB((C.GLuint)(buf), (C.GLenum)(srcRGB), (C.GLenum)(dstRGB), (C.GLenum)(srcAlpha), (C.GLenum)(dstAlpha))
}
// ARB_draw_elements_base_vertex

func DrawElementsBaseVertex(mode Enum, count Sizei, type_ Enum, indices Pointer, basevertex Int)  {
	C.goglDrawElementsBaseVertex((C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLint)(basevertex))
}
func DrawRangeElementsBaseVertex(mode Enum, start Uint, end Uint, count Sizei, type_ Enum, indices Pointer, basevertex Int)  {
	C.goglDrawRangeElementsBaseVertex((C.GLenum)(mode), (C.GLuint)(start), (C.GLuint)(end), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLint)(basevertex))
}
func DrawElementsInstancedBaseVertex(mode Enum, count Sizei, type_ Enum, indices Pointer, instancecount Sizei, basevertex Int)  {
	C.goglDrawElementsInstancedBaseVertex((C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLsizei)(instancecount), (C.GLint)(basevertex))
}
func MultiDrawElementsBaseVertex(mode Enum, count *Sizei, type_ Enum, indices *Pointer, drawcount Sizei, basevertex *Int)  {
	C.goglMultiDrawElementsBaseVertex((C.GLenum)(mode), (*C.GLsizei)(count), (C.GLenum)(type_), (*unsafe.Pointer)(indices), (C.GLsizei)(drawcount), (*C.GLint)(basevertex))
}
// ARB_draw_indirect

func DrawArraysIndirect(mode Enum, indirect Pointer)  {
	C.goglDrawArraysIndirect((C.GLenum)(mode), (unsafe.Pointer)(indirect))
}
func DrawElementsIndirect(mode Enum, type_ Enum, indirect Pointer)  {
	C.goglDrawElementsIndirect((C.GLenum)(mode), (C.GLenum)(type_), (unsafe.Pointer)(indirect))
}
// ARB_draw_instanced

func DrawArraysInstancedARB(mode Enum, first Int, count Sizei, primcount Sizei)  {
	C.goglDrawArraysInstancedARB((C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(primcount))
}
func DrawElementsInstancedARB(mode Enum, count Sizei, type_ Enum, indices Pointer, primcount Sizei)  {
	C.goglDrawElementsInstancedARB((C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(type_), (unsafe.Pointer)(indices), (C.GLsizei)(primcount))
}
// ARB_framebuffer_no_attachments

func FramebufferParameteri(target Enum, pname Enum, param Int)  {
	C.goglFramebufferParameteri((C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param))
}
func GetFramebufferParameteriv(target Enum, pname Enum, params *Int)  {
	C.goglGetFramebufferParameteriv((C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(params))
}
func NamedFramebufferParameteriEXT(framebuffer Uint, pname Enum, param Int)  {
	C.goglNamedFramebufferParameteriEXT((C.GLuint)(framebuffer), (C.GLenum)(pname), (C.GLint)(param))
}
func GetNamedFramebufferParameterivEXT(framebuffer Uint, pname Enum, params *Int)  {
	C.goglGetNamedFramebufferParameterivEXT((C.GLuint)(framebuffer), (C.GLenum)(pname), (*C.GLint)(params))
}
// ARB_framebuffer_object

func IsRenderbuffer(renderbuffer Uint) Boolean {
	return (Boolean)(C.goglIsRenderbuffer((C.GLuint)(renderbuffer)))
}
func BindRenderbuffer(target Enum, renderbuffer Uint)  {
	C.goglBindRenderbuffer((C.GLenum)(target), (C.GLuint)(renderbuffer))
}
func DeleteRenderbuffers(n Sizei, renderbuffers *Uint)  {
	C.goglDeleteRenderbuffers((C.GLsizei)(n), (*C.GLuint)(renderbuffers))
}
func GenRenderbuffers(n Sizei, renderbuffers *Uint)  {
	C.goglGenRenderbuffers((C.GLsizei)(n), (*C.GLuint)(renderbuffers))
}
func RenderbufferStorage(target Enum, internalformat Enum, width Sizei, height Sizei)  {
	C.goglRenderbufferStorage((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height))
}
func GetRenderbufferParameteriv(target Enum, pname Enum, params *Int)  {
	C.goglGetRenderbufferParameteriv((C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(params))
}
func IsFramebuffer(framebuffer Uint) Boolean {
	return (Boolean)(C.goglIsFramebuffer((C.GLuint)(framebuffer)))
}
func BindFramebuffer(target Enum, framebuffer Uint)  {
	C.goglBindFramebuffer((C.GLenum)(target), (C.GLuint)(framebuffer))
}
func DeleteFramebuffers(n Sizei, framebuffers *Uint)  {
	C.goglDeleteFramebuffers((C.GLsizei)(n), (*C.GLuint)(framebuffers))
}
func GenFramebuffers(n Sizei, framebuffers *Uint)  {
	C.goglGenFramebuffers((C.GLsizei)(n), (*C.GLuint)(framebuffers))
}
func CheckFramebufferStatus(target Enum) Enum {
	return (Enum)(C.goglCheckFramebufferStatus((C.GLenum)(target)))
}
func FramebufferTexture1D(target Enum, attachment Enum, textarget Enum, texture Uint, level Int)  {
	C.goglFramebufferTexture1D((C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level))
}
func FramebufferTexture2D(target Enum, attachment Enum, textarget Enum, texture Uint, level Int)  {
	C.goglFramebufferTexture2D((C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level))
}
func FramebufferTexture3D(target Enum, attachment Enum, textarget Enum, texture Uint, level Int, zoffset Int)  {
	C.goglFramebufferTexture3D((C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(zoffset))
}
func FramebufferRenderbuffer(target Enum, attachment Enum, renderbuffertarget Enum, renderbuffer Uint)  {
	C.goglFramebufferRenderbuffer((C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(renderbuffertarget), (C.GLuint)(renderbuffer))
}
func GetFramebufferAttachmentParameteriv(target Enum, attachment Enum, pname Enum, params *Int)  {
	C.goglGetFramebufferAttachmentParameteriv((C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(pname), (*C.GLint)(params))
}
func GenerateMipmap(target Enum)  {
	C.goglGenerateMipmap((C.GLenum)(target))
}
func BlitFramebuffer(srcX0 Int, srcY0 Int, srcX1 Int, srcY1 Int, dstX0 Int, dstY0 Int, dstX1 Int, dstY1 Int, mask Bitfield, filter Enum)  {
	C.goglBlitFramebuffer((C.GLint)(srcX0), (C.GLint)(srcY0), (C.GLint)(srcX1), (C.GLint)(srcY1), (C.GLint)(dstX0), (C.GLint)(dstY0), (C.GLint)(dstX1), (C.GLint)(dstY1), (C.GLbitfield)(mask), (C.GLenum)(filter))
}
func RenderbufferStorageMultisample(target Enum, samples Sizei, internalformat Enum, width Sizei, height Sizei)  {
	C.goglRenderbufferStorageMultisample((C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height))
}
func FramebufferTextureLayer(target Enum, attachment Enum, texture Uint, level Int, layer Int)  {
	C.goglFramebufferTextureLayer((C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer))
}
// ARB_geometry_shader4

func ProgramParameteriARB(program Uint, pname Enum, value Int)  {
	C.goglProgramParameteriARB((C.GLuint)(program), (C.GLenum)(pname), (C.GLint)(value))
}
func FramebufferTextureARB(target Enum, attachment Enum, texture Uint, level Int)  {
	C.goglFramebufferTextureARB((C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level))
}
func FramebufferTextureLayerARB(target Enum, attachment Enum, texture Uint, level Int, layer Int)  {
	C.goglFramebufferTextureLayerARB((C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer))
}
func FramebufferTextureFaceARB(target Enum, attachment Enum, texture Uint, level Int, face Enum)  {
	C.goglFramebufferTextureFaceARB((C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(face))
}
// ARB_get_program_binary

func GetProgramBinary(program Uint, bufSize Sizei, length *Sizei, binaryFormat *Enum, binary Pointer)  {
	C.goglGetProgramBinary((C.GLuint)(program), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLenum)(binaryFormat), (unsafe.Pointer)(binary))
}
func ProgramBinary(program Uint, binaryFormat Enum, binary Pointer, length Sizei)  {
	C.goglProgramBinary((C.GLuint)(program), (C.GLenum)(binaryFormat), (unsafe.Pointer)(binary), (C.GLsizei)(length))
}
func ProgramParameteri(program Uint, pname Enum, value Int)  {
	C.goglProgramParameteri((C.GLuint)(program), (C.GLenum)(pname), (C.GLint)(value))
}
// ARB_gpu_shader_fp64

func Uniform1d(location Int, x Double)  {
	C.goglUniform1d((C.GLint)(location), (C.GLdouble)(x))
}
func Uniform2d(location Int, x Double, y Double)  {
	C.goglUniform2d((C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y))
}
func Uniform3d(location Int, x Double, y Double, z Double)  {
	C.goglUniform3d((C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z))
}
func Uniform4d(location Int, x Double, y Double, z Double, w Double)  {
	C.goglUniform4d((C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w))
}
func Uniform1dv(location Int, count Sizei, value *Double)  {
	C.goglUniform1dv((C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func Uniform2dv(location Int, count Sizei, value *Double)  {
	C.goglUniform2dv((C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func Uniform3dv(location Int, count Sizei, value *Double)  {
	C.goglUniform3dv((C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func Uniform4dv(location Int, count Sizei, value *Double)  {
	C.goglUniform4dv((C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func UniformMatrix2dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix2dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix3dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix3dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix4dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix4dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix2x3dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix2x3dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix2x4dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix2x4dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix3x2dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix3x2dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix3x4dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix3x4dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix4x2dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix4x2dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func UniformMatrix4x3dv(location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglUniformMatrix4x3dv((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func GetUniformdv(program Uint, location Int, params *Double)  {
	C.goglGetUniformdv((C.GLuint)(program), (C.GLint)(location), (*C.GLdouble)(params))
}
// ARB_instanced_arrays

func VertexAttribDivisorARB(index Uint, divisor Uint)  {
	C.goglVertexAttribDivisorARB((C.GLuint)(index), (C.GLuint)(divisor))
}
// ARB_internalformat_query

func GetInternalformativ(target Enum, internalformat Enum, pname Enum, bufSize Sizei, params *Int)  {
	C.goglGetInternalformativ((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(pname), (C.GLsizei)(bufSize), (*C.GLint)(params))
}
// ARB_internalformat_query2

func GetInternalformati64v(target Enum, internalformat Enum, pname Enum, bufSize Sizei, params *Int64)  {
	C.goglGetInternalformati64v((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(pname), (C.GLsizei)(bufSize), (*C.GLint64)(params))
}
// ARB_invalidate_subdata

func InvalidateTexSubImage(texture Uint, level Int, xoffset Int, yoffset Int, zoffset Int, width Sizei, height Sizei, depth Sizei)  {
	C.goglInvalidateTexSubImage((C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth))
}
func InvalidateTexImage(texture Uint, level Int)  {
	C.goglInvalidateTexImage((C.GLuint)(texture), (C.GLint)(level))
}
func InvalidateBufferSubData(buffer Uint, offset Intptr, length Sizeiptr)  {
	C.goglInvalidateBufferSubData((C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length))
}
func InvalidateBufferData(buffer Uint)  {
	C.goglInvalidateBufferData((C.GLuint)(buffer))
}
func InvalidateFramebuffer(target Enum, numAttachments Sizei, attachments *Enum)  {
	C.goglInvalidateFramebuffer((C.GLenum)(target), (C.GLsizei)(numAttachments), (*C.GLenum)(attachments))
}
func InvalidateSubFramebuffer(target Enum, numAttachments Sizei, attachments *Enum, x Int, y Int, width Sizei, height Sizei)  {
	C.goglInvalidateSubFramebuffer((C.GLenum)(target), (C.GLsizei)(numAttachments), (*C.GLenum)(attachments), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height))
}
// ARB_map_buffer_range

func MapBufferRange(target Enum, offset Intptr, length Sizeiptr, access Bitfield) Pointer {
	return (Pointer)(C.goglMapBufferRange((C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(length), (C.GLbitfield)(access)))
}
func FlushMappedBufferRange(target Enum, offset Intptr, length Sizeiptr)  {
	C.goglFlushMappedBufferRange((C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(length))
}
// ARB_matrix_palette

func CurrentPaletteMatrixARB(index Int)  {
	C.goglCurrentPaletteMatrixARB((C.GLint)(index))
}
func MatrixIndexubvARB(size Int, indices *Ubyte)  {
	C.goglMatrixIndexubvARB((C.GLint)(size), (*C.GLubyte)(indices))
}
func MatrixIndexusvARB(size Int, indices *Ushort)  {
	C.goglMatrixIndexusvARB((C.GLint)(size), (*C.GLushort)(indices))
}
func MatrixIndexuivARB(size Int, indices *Uint)  {
	C.goglMatrixIndexuivARB((C.GLint)(size), (*C.GLuint)(indices))
}
func MatrixIndexPointerARB(size Int, type_ Enum, stride Sizei, pointer Pointer)  {
	C.goglMatrixIndexPointerARB((C.GLint)(size), (C.GLenum)(type_), (C.GLsizei)(stride), (unsafe.Pointer)(pointer))
}
// ARB_multi_draw_indirect

func MultiDrawArraysIndirect(mode Enum, indirect Pointer, drawcount Sizei, stride Sizei)  {
	C.goglMultiDrawArraysIndirect((C.GLenum)(mode), (unsafe.Pointer)(indirect), (C.GLsizei)(drawcount), (C.GLsizei)(stride))
}
func MultiDrawElementsIndirect(mode Enum, type_ Enum, indirect Pointer, drawcount Sizei, stride Sizei)  {
	C.goglMultiDrawElementsIndirect((C.GLenum)(mode), (C.GLenum)(type_), (unsafe.Pointer)(indirect), (C.GLsizei)(drawcount), (C.GLsizei)(stride))
}
// ARB_multisample

func SampleCoverageARB(value Float, invert Boolean)  {
	C.goglSampleCoverageARB((C.GLfloat)(value), (C.GLboolean)(invert))
}
// ARB_multitexture

func ActiveTextureARB(texture Enum)  {
	C.goglActiveTextureARB((C.GLenum)(texture))
}
func ClientActiveTextureARB(texture Enum)  {
	C.goglClientActiveTextureARB((C.GLenum)(texture))
}
func MultiTexCoord1dARB(target Enum, s Double)  {
	C.goglMultiTexCoord1dARB((C.GLenum)(target), (C.GLdouble)(s))
}
func MultiTexCoord1dvARB(target Enum, v *Double)  {
	C.goglMultiTexCoord1dvARB((C.GLenum)(target), (*C.GLdouble)(v))
}
func MultiTexCoord1fARB(target Enum, s Float)  {
	C.goglMultiTexCoord1fARB((C.GLenum)(target), (C.GLfloat)(s))
}
func MultiTexCoord1fvARB(target Enum, v *Float)  {
	C.goglMultiTexCoord1fvARB((C.GLenum)(target), (*C.GLfloat)(v))
}
func MultiTexCoord1iARB(target Enum, s Int)  {
	C.goglMultiTexCoord1iARB((C.GLenum)(target), (C.GLint)(s))
}
func MultiTexCoord1ivARB(target Enum, v *Int)  {
	C.goglMultiTexCoord1ivARB((C.GLenum)(target), (*C.GLint)(v))
}
func MultiTexCoord1sARB(target Enum, s Short)  {
	C.goglMultiTexCoord1sARB((C.GLenum)(target), (C.GLshort)(s))
}
func MultiTexCoord1svARB(target Enum, v *Short)  {
	C.goglMultiTexCoord1svARB((C.GLenum)(target), (*C.GLshort)(v))
}
func MultiTexCoord2dARB(target Enum, s Double, t Double)  {
	C.goglMultiTexCoord2dARB((C.GLenum)(target), (C.GLdouble)(s), (C.GLdouble)(t))
}
func MultiTexCoord2dvARB(target Enum, v *Double)  {
	C.goglMultiTexCoord2dvARB((C.GLenum)(target), (*C.GLdouble)(v))
}
func MultiTexCoord2fARB(target Enum, s Float, t Float)  {
	C.goglMultiTexCoord2fARB((C.GLenum)(target), (C.GLfloat)(s), (C.GLfloat)(t))
}
func MultiTexCoord2fvARB(target Enum, v *Float)  {
	C.goglMultiTexCoord2fvARB((C.GLenum)(target), (*C.GLfloat)(v))
}
func MultiTexCoord2iARB(target Enum, s Int, t Int)  {
	C.goglMultiTexCoord2iARB((C.GLenum)(target), (C.GLint)(s), (C.GLint)(t))
}
func MultiTexCoord2ivARB(target Enum, v *Int)  {
	C.goglMultiTexCoord2ivARB((C.GLenum)(target), (*C.GLint)(v))
}
func MultiTexCoord2sARB(target Enum, s Short, t Short)  {
	C.goglMultiTexCoord2sARB((C.GLenum)(target), (C.GLshort)(s), (C.GLshort)(t))
}
func MultiTexCoord2svARB(target Enum, v *Short)  {
	C.goglMultiTexCoord2svARB((C.GLenum)(target), (*C.GLshort)(v))
}
func MultiTexCoord3dARB(target Enum, s Double, t Double, r Double)  {
	C.goglMultiTexCoord3dARB((C.GLenum)(target), (C.GLdouble)(s), (C.GLdouble)(t), (C.GLdouble)(r))
}
func MultiTexCoord3dvARB(target Enum, v *Double)  {
	C.goglMultiTexCoord3dvARB((C.GLenum)(target), (*C.GLdouble)(v))
}
func MultiTexCoord3fARB(target Enum, s Float, t Float, r Float)  {
	C.goglMultiTexCoord3fARB((C.GLenum)(target), (C.GLfloat)(s), (C.GLfloat)(t), (C.GLfloat)(r))
}
func MultiTexCoord3fvARB(target Enum, v *Float)  {
	C.goglMultiTexCoord3fvARB((C.GLenum)(target), (*C.GLfloat)(v))
}
func MultiTexCoord3iARB(target Enum, s Int, t Int, r Int)  {
	C.goglMultiTexCoord3iARB((C.GLenum)(target), (C.GLint)(s), (C.GLint)(t), (C.GLint)(r))
}
func MultiTexCoord3ivARB(target Enum, v *Int)  {
	C.goglMultiTexCoord3ivARB((C.GLenum)(target), (*C.GLint)(v))
}
func MultiTexCoord3sARB(target Enum, s Short, t Short, r Short)  {
	C.goglMultiTexCoord3sARB((C.GLenum)(target), (C.GLshort)(s), (C.GLshort)(t), (C.GLshort)(r))
}
func MultiTexCoord3svARB(target Enum, v *Short)  {
	C.goglMultiTexCoord3svARB((C.GLenum)(target), (*C.GLshort)(v))
}
func MultiTexCoord4dARB(target Enum, s Double, t Double, r Double, q Double)  {
	C.goglMultiTexCoord4dARB((C.GLenum)(target), (C.GLdouble)(s), (C.GLdouble)(t), (C.GLdouble)(r), (C.GLdouble)(q))
}
func MultiTexCoord4dvARB(target Enum, v *Double)  {
	C.goglMultiTexCoord4dvARB((C.GLenum)(target), (*C.GLdouble)(v))
}
func MultiTexCoord4fARB(target Enum, s Float, t Float, r Float, q Float)  {
	C.goglMultiTexCoord4fARB((C.GLenum)(target), (C.GLfloat)(s), (C.GLfloat)(t), (C.GLfloat)(r), (C.GLfloat)(q))
}
func MultiTexCoord4fvARB(target Enum, v *Float)  {
	C.goglMultiTexCoord4fvARB((C.GLenum)(target), (*C.GLfloat)(v))
}
func MultiTexCoord4iARB(target Enum, s Int, t Int, r Int, q Int)  {
	C.goglMultiTexCoord4iARB((C.GLenum)(target), (C.GLint)(s), (C.GLint)(t), (C.GLint)(r), (C.GLint)(q))
}
func MultiTexCoord4ivARB(target Enum, v *Int)  {
	C.goglMultiTexCoord4ivARB((C.GLenum)(target), (*C.GLint)(v))
}
func MultiTexCoord4sARB(target Enum, s Short, t Short, r Short, q Short)  {
	C.goglMultiTexCoord4sARB((C.GLenum)(target), (C.GLshort)(s), (C.GLshort)(t), (C.GLshort)(r), (C.GLshort)(q))
}
func MultiTexCoord4svARB(target Enum, v *Short)  {
	C.goglMultiTexCoord4svARB((C.GLenum)(target), (*C.GLshort)(v))
}
// ARB_occlusion_query

func GenQueriesARB(n Sizei, ids *Uint)  {
	C.goglGenQueriesARB((C.GLsizei)(n), (*C.GLuint)(ids))
}
func DeleteQueriesARB(n Sizei, ids *Uint)  {
	C.goglDeleteQueriesARB((C.GLsizei)(n), (*C.GLuint)(ids))
}
func IsQueryARB(id Uint) Boolean {
	return (Boolean)(C.goglIsQueryARB((C.GLuint)(id)))
}
func BeginQueryARB(target Enum, id Uint)  {
	C.goglBeginQueryARB((C.GLenum)(target), (C.GLuint)(id))
}
func EndQueryARB(target Enum)  {
	C.goglEndQueryARB((C.GLenum)(target))
}
func GetQueryivARB(target Enum, pname Enum, params *Int)  {
	C.goglGetQueryivARB((C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetQueryObjectivARB(id Uint, pname Enum, params *Int)  {
	C.goglGetQueryObjectivARB((C.GLuint)(id), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetQueryObjectuivARB(id Uint, pname Enum, params *Uint)  {
	C.goglGetQueryObjectuivARB((C.GLuint)(id), (C.GLenum)(pname), (*C.GLuint)(params))
}
// ARB_point_parameters

func PointParameterfARB(pname Enum, param Float)  {
	C.goglPointParameterfARB((C.GLenum)(pname), (C.GLfloat)(param))
}
func PointParameterfvARB(pname Enum, params *Float)  {
	C.goglPointParameterfvARB((C.GLenum)(pname), (*C.GLfloat)(params))
}
// ARB_program_interface_query

func GetProgramInterfaceiv(program Uint, programInterface Enum, pname Enum, params *Int)  {
	C.goglGetProgramInterfaceiv((C.GLuint)(program), (C.GLenum)(programInterface), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetProgramResourceIndex(program Uint, programInterface Enum, name *Char) Uint {
	return (Uint)(C.goglGetProgramResourceIndex((C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(name)))
}
func GetProgramResourceName(program Uint, programInterface Enum, index Uint, bufSize Sizei, length *Sizei, name *Char)  {
	C.goglGetProgramResourceName((C.GLuint)(program), (C.GLenum)(programInterface), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLchar)(name))
}
func GetProgramResourceiv(program Uint, programInterface Enum, index Uint, propCount Sizei, props *Enum, bufSize Sizei, length *Sizei, params *Int)  {
	C.goglGetProgramResourceiv((C.GLuint)(program), (C.GLenum)(programInterface), (C.GLuint)(index), (C.GLsizei)(propCount), (*C.GLenum)(props), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLint)(params))
}
func GetProgramResourceLocation(program Uint, programInterface Enum, name *Char) Int {
	return (Int)(C.goglGetProgramResourceLocation((C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(name)))
}
func GetProgramResourceLocationIndex(program Uint, programInterface Enum, name *Char) Int {
	return (Int)(C.goglGetProgramResourceLocationIndex((C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(name)))
}
// ARB_provoking_vertex

func ProvokingVertex(mode Enum)  {
	C.goglProvokingVertex((C.GLenum)(mode))
}
// ARB_robustness

func GetGraphicsResetStatusARB() Enum {
	return (Enum)(C.goglGetGraphicsResetStatusARB())
}
func GetnMapdvARB(target Enum, query Enum, bufSize Sizei, v *Double)  {
	C.goglGetnMapdvARB((C.GLenum)(target), (C.GLenum)(query), (C.GLsizei)(bufSize), (*C.GLdouble)(v))
}
func GetnMapfvARB(target Enum, query Enum, bufSize Sizei, v *Float)  {
	C.goglGetnMapfvARB((C.GLenum)(target), (C.GLenum)(query), (C.GLsizei)(bufSize), (*C.GLfloat)(v))
}
func GetnMapivARB(target Enum, query Enum, bufSize Sizei, v *Int)  {
	C.goglGetnMapivARB((C.GLenum)(target), (C.GLenum)(query), (C.GLsizei)(bufSize), (*C.GLint)(v))
}
func GetnPixelMapfvARB(map_ Enum, bufSize Sizei, values *Float)  {
	C.goglGetnPixelMapfvARB((C.GLenum)(map_), (C.GLsizei)(bufSize), (*C.GLfloat)(values))
}
func GetnPixelMapuivARB(map_ Enum, bufSize Sizei, values *Uint)  {
	C.goglGetnPixelMapuivARB((C.GLenum)(map_), (C.GLsizei)(bufSize), (*C.GLuint)(values))
}
func GetnPixelMapusvARB(map_ Enum, bufSize Sizei, values *Ushort)  {
	C.goglGetnPixelMapusvARB((C.GLenum)(map_), (C.GLsizei)(bufSize), (*C.GLushort)(values))
}
func GetnPolygonStippleARB(bufSize Sizei, pattern *Ubyte)  {
	C.goglGetnPolygonStippleARB((C.GLsizei)(bufSize), (*C.GLubyte)(pattern))
}
func GetnColorTableARB(target Enum, format Enum, type_ Enum, bufSize Sizei, table Pointer)  {
	C.goglGetnColorTableARB((C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(table))
}
func GetnConvolutionFilterARB(target Enum, format Enum, type_ Enum, bufSize Sizei, image Pointer)  {
	C.goglGetnConvolutionFilterARB((C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(image))
}
func GetnSeparableFilterARB(target Enum, format Enum, type_ Enum, rowBufSize Sizei, row Pointer, columnBufSize Sizei, column Pointer, span Pointer)  {
	C.goglGetnSeparableFilterARB((C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(rowBufSize), (unsafe.Pointer)(row), (C.GLsizei)(columnBufSize), (unsafe.Pointer)(column), (unsafe.Pointer)(span))
}
func GetnHistogramARB(target Enum, reset Boolean, format Enum, type_ Enum, bufSize Sizei, values Pointer)  {
	C.goglGetnHistogramARB((C.GLenum)(target), (C.GLboolean)(reset), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(values))
}
func GetnMinmaxARB(target Enum, reset Boolean, format Enum, type_ Enum, bufSize Sizei, values Pointer)  {
	C.goglGetnMinmaxARB((C.GLenum)(target), (C.GLboolean)(reset), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(values))
}
func GetnTexImageARB(target Enum, level Int, format Enum, type_ Enum, bufSize Sizei, img Pointer)  {
	C.goglGetnTexImageARB((C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(img))
}
func ReadnPixelsARB(x Int, y Int, width Sizei, height Sizei, format Enum, type_ Enum, bufSize Sizei, data Pointer)  {
	C.goglReadnPixelsARB((C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(type_), (C.GLsizei)(bufSize), (unsafe.Pointer)(data))
}
func GetnCompressedTexImageARB(target Enum, lod Int, bufSize Sizei, img Pointer)  {
	C.goglGetnCompressedTexImageARB((C.GLenum)(target), (C.GLint)(lod), (C.GLsizei)(bufSize), (unsafe.Pointer)(img))
}
func GetnUniformfvARB(program Uint, location Int, bufSize Sizei, params *Float)  {
	C.goglGetnUniformfvARB((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLfloat)(params))
}
func GetnUniformivARB(program Uint, location Int, bufSize Sizei, params *Int)  {
	C.goglGetnUniformivARB((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLint)(params))
}
func GetnUniformuivARB(program Uint, location Int, bufSize Sizei, params *Uint)  {
	C.goglGetnUniformuivARB((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLuint)(params))
}
func GetnUniformdvARB(program Uint, location Int, bufSize Sizei, params *Double)  {
	C.goglGetnUniformdvARB((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLdouble)(params))
}
// ARB_sample_shading

func MinSampleShadingARB(value Float)  {
	C.goglMinSampleShadingARB((C.GLfloat)(value))
}
// ARB_sampler_objects

func GenSamplers(count Sizei, samplers *Uint)  {
	C.goglGenSamplers((C.GLsizei)(count), (*C.GLuint)(samplers))
}
func DeleteSamplers(count Sizei, samplers *Uint)  {
	C.goglDeleteSamplers((C.GLsizei)(count), (*C.GLuint)(samplers))
}
func IsSampler(sampler Uint) Boolean {
	return (Boolean)(C.goglIsSampler((C.GLuint)(sampler)))
}
func BindSampler(unit Uint, sampler Uint)  {
	C.goglBindSampler((C.GLuint)(unit), (C.GLuint)(sampler))
}
func SamplerParameteri(sampler Uint, pname Enum, param Int)  {
	C.goglSamplerParameteri((C.GLuint)(sampler), (C.GLenum)(pname), (C.GLint)(param))
}
func SamplerParameteriv(sampler Uint, pname Enum, param *Int)  {
	C.goglSamplerParameteriv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(param))
}
func SamplerParameterf(sampler Uint, pname Enum, param Float)  {
	C.goglSamplerParameterf((C.GLuint)(sampler), (C.GLenum)(pname), (C.GLfloat)(param))
}
func SamplerParameterfv(sampler Uint, pname Enum, param *Float)  {
	C.goglSamplerParameterfv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLfloat)(param))
}
func SamplerParameterIiv(sampler Uint, pname Enum, param *Int)  {
	C.goglSamplerParameterIiv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(param))
}
func SamplerParameterIuiv(sampler Uint, pname Enum, param *Uint)  {
	C.goglSamplerParameterIuiv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLuint)(param))
}
func GetSamplerParameteriv(sampler Uint, pname Enum, params *Int)  {
	C.goglGetSamplerParameteriv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetSamplerParameterIiv(sampler Uint, pname Enum, params *Int)  {
	C.goglGetSamplerParameterIiv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetSamplerParameterfv(sampler Uint, pname Enum, params *Float)  {
	C.goglGetSamplerParameterfv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLfloat)(params))
}
func GetSamplerParameterIuiv(sampler Uint, pname Enum, params *Uint)  {
	C.goglGetSamplerParameterIuiv((C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLuint)(params))
}
// ARB_separate_shader_objects

func UseProgramStages(pipeline Uint, stages Bitfield, program Uint)  {
	C.goglUseProgramStages((C.GLuint)(pipeline), (C.GLbitfield)(stages), (C.GLuint)(program))
}
func ActiveShaderProgram(pipeline Uint, program Uint)  {
	C.goglActiveShaderProgram((C.GLuint)(pipeline), (C.GLuint)(program))
}
func CreateShaderProgramv(type_ Enum, count Sizei, strings **Char) Uint {
	return (Uint)(C.goglCreateShaderProgramv((C.GLenum)(type_), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(strings))))
}
func BindProgramPipeline(pipeline Uint)  {
	C.goglBindProgramPipeline((C.GLuint)(pipeline))
}
func DeleteProgramPipelines(n Sizei, pipelines *Uint)  {
	C.goglDeleteProgramPipelines((C.GLsizei)(n), (*C.GLuint)(pipelines))
}
func GenProgramPipelines(n Sizei, pipelines *Uint)  {
	C.goglGenProgramPipelines((C.GLsizei)(n), (*C.GLuint)(pipelines))
}
func IsProgramPipeline(pipeline Uint) Boolean {
	return (Boolean)(C.goglIsProgramPipeline((C.GLuint)(pipeline)))
}
func GetProgramPipelineiv(pipeline Uint, pname Enum, params *Int)  {
	C.goglGetProgramPipelineiv((C.GLuint)(pipeline), (C.GLenum)(pname), (*C.GLint)(params))
}
func ProgramUniform1i(program Uint, location Int, v0 Int)  {
	C.goglProgramUniform1i((C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0))
}
func ProgramUniform1iv(program Uint, location Int, count Sizei, value *Int)  {
	C.goglProgramUniform1iv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func ProgramUniform1f(program Uint, location Int, v0 Float)  {
	C.goglProgramUniform1f((C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0))
}
func ProgramUniform1fv(program Uint, location Int, count Sizei, value *Float)  {
	C.goglProgramUniform1fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func ProgramUniform1d(program Uint, location Int, v0 Double)  {
	C.goglProgramUniform1d((C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0))
}
func ProgramUniform1dv(program Uint, location Int, count Sizei, value *Double)  {
	C.goglProgramUniform1dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func ProgramUniform1ui(program Uint, location Int, v0 Uint)  {
	C.goglProgramUniform1ui((C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0))
}
func ProgramUniform1uiv(program Uint, location Int, count Sizei, value *Uint)  {
	C.goglProgramUniform1uiv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(value))
}
func ProgramUniform2i(program Uint, location Int, v0 Int, v1 Int)  {
	C.goglProgramUniform2i((C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1))
}
func ProgramUniform2iv(program Uint, location Int, count Sizei, value *Int)  {
	C.goglProgramUniform2iv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func ProgramUniform2f(program Uint, location Int, v0 Float, v1 Float)  {
	C.goglProgramUniform2f((C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1))
}
func ProgramUniform2fv(program Uint, location Int, count Sizei, value *Float)  {
	C.goglProgramUniform2fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func ProgramUniform2d(program Uint, location Int, v0 Double, v1 Double)  {
	C.goglProgramUniform2d((C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1))
}
func ProgramUniform2dv(program Uint, location Int, count Sizei, value *Double)  {
	C.goglProgramUniform2dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func ProgramUniform2ui(program Uint, location Int, v0 Uint, v1 Uint)  {
	C.goglProgramUniform2ui((C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1))
}
func ProgramUniform2uiv(program Uint, location Int, count Sizei, value *Uint)  {
	C.goglProgramUniform2uiv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(value))
}
func ProgramUniform3i(program Uint, location Int, v0 Int, v1 Int, v2 Int)  {
	C.goglProgramUniform3i((C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2))
}
func ProgramUniform3iv(program Uint, location Int, count Sizei, value *Int)  {
	C.goglProgramUniform3iv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func ProgramUniform3f(program Uint, location Int, v0 Float, v1 Float, v2 Float)  {
	C.goglProgramUniform3f((C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2))
}
func ProgramUniform3fv(program Uint, location Int, count Sizei, value *Float)  {
	C.goglProgramUniform3fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func ProgramUniform3d(program Uint, location Int, v0 Double, v1 Double, v2 Double)  {
	C.goglProgramUniform3d((C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1), (C.GLdouble)(v2))
}
func ProgramUniform3dv(program Uint, location Int, count Sizei, value *Double)  {
	C.goglProgramUniform3dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func ProgramUniform3ui(program Uint, location Int, v0 Uint, v1 Uint, v2 Uint)  {
	C.goglProgramUniform3ui((C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2))
}
func ProgramUniform3uiv(program Uint, location Int, count Sizei, value *Uint)  {
	C.goglProgramUniform3uiv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(value))
}
func ProgramUniform4i(program Uint, location Int, v0 Int, v1 Int, v2 Int, v3 Int)  {
	C.goglProgramUniform4i((C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2), (C.GLint)(v3))
}
func ProgramUniform4iv(program Uint, location Int, count Sizei, value *Int)  {
	C.goglProgramUniform4iv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func ProgramUniform4f(program Uint, location Int, v0 Float, v1 Float, v2 Float, v3 Float)  {
	C.goglProgramUniform4f((C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2), (C.GLfloat)(v3))
}
func ProgramUniform4fv(program Uint, location Int, count Sizei, value *Float)  {
	C.goglProgramUniform4fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func ProgramUniform4d(program Uint, location Int, v0 Double, v1 Double, v2 Double, v3 Double)  {
	C.goglProgramUniform4d((C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1), (C.GLdouble)(v2), (C.GLdouble)(v3))
}
func ProgramUniform4dv(program Uint, location Int, count Sizei, value *Double)  {
	C.goglProgramUniform4dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(value))
}
func ProgramUniform4ui(program Uint, location Int, v0 Uint, v1 Uint, v2 Uint, v3 Uint)  {
	C.goglProgramUniform4ui((C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2), (C.GLuint)(v3))
}
func ProgramUniform4uiv(program Uint, location Int, count Sizei, value *Uint)  {
	C.goglProgramUniform4uiv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(value))
}
func ProgramUniformMatrix2fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix2fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix3fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix3fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix4fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix4fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix2dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix2dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix3dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix3dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix4dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix4dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix2x3fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix2x3fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix3x2fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix3x2fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix2x4fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix2x4fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix4x2fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix4x2fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix3x4fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix3x4fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix4x3fv(program Uint, location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglProgramUniformMatrix4x3fv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func ProgramUniformMatrix2x3dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix2x3dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix3x2dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix3x2dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix2x4dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix2x4dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix4x2dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix4x2dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix3x4dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix3x4dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ProgramUniformMatrix4x3dv(program Uint, location Int, count Sizei, transpose Boolean, value *Double)  {
	C.goglProgramUniformMatrix4x3dv((C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLdouble)(value))
}
func ValidateProgramPipeline(pipeline Uint)  {
	C.goglValidateProgramPipeline((C.GLuint)(pipeline))
}
func GetProgramPipelineInfoLog(pipeline Uint, bufSize Sizei, length *Sizei, infoLog *Char)  {
	C.goglGetProgramPipelineInfoLog((C.GLuint)(pipeline), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLchar)(infoLog))
}
// ARB_shader_atomic_counters

func GetActiveAtomicCounterBufferiv(program Uint, bufferIndex Uint, pname Enum, params *Int)  {
	C.goglGetActiveAtomicCounterBufferiv((C.GLuint)(program), (C.GLuint)(bufferIndex), (C.GLenum)(pname), (*C.GLint)(params))
}
// ARB_shader_image_load_store

func BindImageTexture(unit Uint, texture Uint, level Int, layered Boolean, layer Int, access Enum, format Enum)  {
	C.goglBindImageTexture((C.GLuint)(unit), (C.GLuint)(texture), (C.GLint)(level), (C.GLboolean)(layered), (C.GLint)(layer), (C.GLenum)(access), (C.GLenum)(format))
}
func MemoryBarrier(barriers Bitfield)  {
	C.goglMemoryBarrier((C.GLbitfield)(barriers))
}
// ARB_shader_objects

func DeleteObjectARB(obj Uint)  {
	C.goglDeleteObjectARB((C.GLhandleARB)(obj))
}
func GetHandleARB(pname Enum) Uint {
	return (Uint)(C.goglGetHandleARB((C.GLenum)(pname)))
}
func DetachObjectARB(containerObj Uint, attachedObj Uint)  {
	C.goglDetachObjectARB((C.GLhandleARB)(containerObj), (C.GLhandleARB)(attachedObj))
}
func CreateShaderObjectARB(shaderType Enum) Uint {
	return (Uint)(C.goglCreateShaderObjectARB((C.GLenum)(shaderType)))
}
func ShaderSourceARB(shaderObj Uint, count Sizei, string_ **Char, length *Int)  {
	C.goglShaderSourceARB((C.GLhandleARB)(shaderObj), (C.GLsizei)(count), (**C.GLcharARB)(unsafe.Pointer(string_)), (*C.GLint)(length))
}
func CompileShaderARB(shaderObj Uint)  {
	C.goglCompileShaderARB((C.GLhandleARB)(shaderObj))
}
func CreateProgramObjectARB() Uint {
	return (Uint)(C.goglCreateProgramObjectARB())
}
func AttachObjectARB(containerObj Uint, obj Uint)  {
	C.goglAttachObjectARB((C.GLhandleARB)(containerObj), (C.GLhandleARB)(obj))
}
func LinkProgramARB(programObj Uint)  {
	C.goglLinkProgramARB((C.GLhandleARB)(programObj))
}
func UseProgramObjectARB(programObj Uint)  {
	C.goglUseProgramObjectARB((C.GLhandleARB)(programObj))
}
func ValidateProgramARB(programObj Uint)  {
	C.goglValidateProgramARB((C.GLhandleARB)(programObj))
}
func Uniform1fARB(location Int, v0 Float)  {
	C.goglUniform1fARB((C.GLint)(location), (C.GLfloat)(v0))
}
func Uniform2fARB(location Int, v0 Float, v1 Float)  {
	C.goglUniform2fARB((C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1))
}
func Uniform3fARB(location Int, v0 Float, v1 Float, v2 Float)  {
	C.goglUniform3fARB((C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2))
}
func Uniform4fARB(location Int, v0 Float, v1 Float, v2 Float, v3 Float)  {
	C.goglUniform4fARB((C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2), (C.GLfloat)(v3))
}
func Uniform1iARB(location Int, v0 Int)  {
	C.goglUniform1iARB((C.GLint)(location), (C.GLint)(v0))
}
func Uniform2iARB(location Int, v0 Int, v1 Int)  {
	C.goglUniform2iARB((C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1))
}
func Uniform3iARB(location Int, v0 Int, v1 Int, v2 Int)  {
	C.goglUniform3iARB((C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2))
}
func Uniform4iARB(location Int, v0 Int, v1 Int, v2 Int, v3 Int)  {
	C.goglUniform4iARB((C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2), (C.GLint)(v3))
}
func Uniform1fvARB(location Int, count Sizei, value *Float)  {
	C.goglUniform1fvARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func Uniform2fvARB(location Int, count Sizei, value *Float)  {
	C.goglUniform2fvARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func Uniform3fvARB(location Int, count Sizei, value *Float)  {
	C.goglUniform3fvARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func Uniform4fvARB(location Int, count Sizei, value *Float)  {
	C.goglUniform4fvARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(value))
}
func Uniform1ivARB(location Int, count Sizei, value *Int)  {
	C.goglUniform1ivARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func Uniform2ivARB(location Int, count Sizei, value *Int)  {
	C.goglUniform2ivARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func Uniform3ivARB(location Int, count Sizei, value *Int)  {
	C.goglUniform3ivARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func Uniform4ivARB(location Int, count Sizei, value *Int)  {
	C.goglUniform4ivARB((C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(value))
}
func UniformMatrix2fvARB(location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglUniformMatrix2fvARB((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func UniformMatrix3fvARB(location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglUniformMatrix3fvARB((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func UniformMatrix4fvARB(location Int, count Sizei, transpose Boolean, value *Float)  {
	C.goglUniformMatrix4fvARB((C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(transpose), (*C.GLfloat)(value))
}
func GetObjectParameterfvARB(obj Uint, pname Enum, params *Float)  {
	C.goglGetObjectParameterfvARB((C.GLhandleARB)(obj), (C.GLenum)(pname), (*C.GLfloat)(params))
}
func GetObjectParameterivARB(obj Uint, pname Enum, params *Int)  {
	C.goglGetObjectParameterivARB((C.GLhandleARB)(obj), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetInfoLogARB(obj Uint, maxLength Sizei, length *Sizei, infoLog *Char)  {
	C.goglGetInfoLogARB((C.GLhandleARB)(obj), (C.GLsizei)(maxLength), (*C.GLsizei)(length), (*C.GLcharARB)(infoLog))
}
func GetAttachedObjectsARB(containerObj Uint, maxCount Sizei, count *Sizei, obj *Uint)  {
	C.goglGetAttachedObjectsARB((C.GLhandleARB)(containerObj), (C.GLsizei)(maxCount), (*C.GLsizei)(count), (*C.GLhandleARB)(obj))
}
func GetUniformLocationARB(programObj Uint, name *Char) Int {
	return (Int)(C.goglGetUniformLocationARB((C.GLhandleARB)(programObj), (*C.GLcharARB)(name)))
}
func GetActiveUniformARB(programObj Uint, index Uint, maxLength Sizei, length *Sizei, size *Int, type_ *Enum, name *Char)  {
	C.goglGetActiveUniformARB((C.GLhandleARB)(programObj), (C.GLuint)(index), (C.GLsizei)(maxLength), (*C.GLsizei)(length), (*C.GLint)(size), (*C.GLenum)(type_), (*C.GLcharARB)(name))
}
func GetUniformfvARB(programObj Uint, location Int, params *Float)  {
	C.goglGetUniformfvARB((C.GLhandleARB)(programObj), (C.GLint)(location), (*C.GLfloat)(params))
}
func GetUniformivARB(programObj Uint, location Int, params *Int)  {
	C.goglGetUniformivARB((C.GLhandleARB)(programObj), (C.GLint)(location), (*C.GLint)(params))
}
func GetShaderSourceARB(obj Uint, maxLength Sizei, length *Sizei, source *Char)  {
	C.goglGetShaderSourceARB((C.GLhandleARB)(obj), (C.GLsizei)(maxLength), (*C.GLsizei)(length), (*C.GLcharARB)(source))
}
// ARB_shader_storage_buffer_object

func ShaderStorageBlockBinding(program Uint, storageBlockIndex Uint, storageBlockBinding Uint)  {
	C.goglShaderStorageBlockBinding((C.GLuint)(program), (C.GLuint)(storageBlockIndex), (C.GLuint)(storageBlockBinding))
}
// ARB_shader_subroutine

func GetSubroutineUniformLocation(program Uint, shadertype Enum, name *Char) Int {
	return (Int)(C.goglGetSubroutineUniformLocation((C.GLuint)(program), (C.GLenum)(shadertype), (*C.GLchar)(name)))
}
func GetSubroutineIndex(program Uint, shadertype Enum, name *Char) Uint {
	return (Uint)(C.goglGetSubroutineIndex((C.GLuint)(program), (C.GLenum)(shadertype), (*C.GLchar)(name)))
}
func GetActiveSubroutineUniformiv(program Uint, shadertype Enum, index Uint, pname Enum, values *Int)  {
	C.goglGetActiveSubroutineUniformiv((C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(values))
}
func GetActiveSubroutineUniformName(program Uint, shadertype Enum, index Uint, bufsize Sizei, length *Sizei, name *Char)  {
	C.goglGetActiveSubroutineUniformName((C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLsizei)(bufsize), (*C.GLsizei)(length), (*C.GLchar)(name))
}
func GetActiveSubroutineName(program Uint, shadertype Enum, index Uint, bufsize Sizei, length *Sizei, name *Char)  {
	C.goglGetActiveSubroutineName((C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLsizei)(bufsize), (*C.GLsizei)(length), (*C.GLchar)(name))
}
func UniformSubroutinesuiv(shadertype Enum, count Sizei, indices *Uint)  {
	C.goglUniformSubroutinesuiv((C.GLenum)(shadertype), (C.GLsizei)(count), (*C.GLuint)(indices))
}
func GetUniformSubroutineuiv(shadertype Enum, location Int, params *Uint)  {
	C.goglGetUniformSubroutineuiv((C.GLenum)(shadertype), (C.GLint)(location), (*C.GLuint)(params))
}
func GetProgramStageiv(program Uint, shadertype Enum, pname Enum, values *Int)  {
	C.goglGetProgramStageiv((C.GLuint)(program), (C.GLenum)(shadertype), (C.GLenum)(pname), (*C.GLint)(values))
}
// ARB_shading_language_include

func NamedStringARB(type_ Enum, namelen Int, name *Char, stringlen Int, string_ *Char)  {
	C.goglNamedStringARB((C.GLenum)(type_), (C.GLint)(namelen), (*C.GLchar)(name), (C.GLint)(stringlen), (*C.GLchar)(string_))
}
func DeleteNamedStringARB(namelen Int, name *Char)  {
	C.goglDeleteNamedStringARB((C.GLint)(namelen), (*C.GLchar)(name))
}
func CompileShaderIncludeARB(shader Uint, count Sizei, path **Char, length *Int)  {
	C.goglCompileShaderIncludeARB((C.GLuint)(shader), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(path)), (*C.GLint)(length))
}
func IsNamedStringARB(namelen Int, name *Char) Boolean {
	return (Boolean)(C.goglIsNamedStringARB((C.GLint)(namelen), (*C.GLchar)(name)))
}
func GetNamedStringARB(namelen Int, name *Char, bufSize Sizei, stringlen *Int, string_ *Char)  {
	C.goglGetNamedStringARB((C.GLint)(namelen), (*C.GLchar)(name), (C.GLsizei)(bufSize), (*C.GLint)(stringlen), (*C.GLchar)(string_))
}
func GetNamedStringivARB(namelen Int, name *Char, pname Enum, params *Int)  {
	C.goglGetNamedStringivARB((C.GLint)(namelen), (*C.GLchar)(name), (C.GLenum)(pname), (*C.GLint)(params))
}
// ARB_sync

func FenceSync(condition Enum, flags Bitfield) Sync {
	return (Sync)(C.goglFenceSync((C.GLenum)(condition), (C.GLbitfield)(flags)))
}
func IsSync(sync Sync) Boolean {
	return (Boolean)(C.goglIsSync((C.GLsync)(sync)))
}
func DeleteSync(sync Sync)  {
	C.goglDeleteSync((C.GLsync)(sync))
}
func ClientWaitSync(sync Sync, flags Bitfield, timeout Uint64) Enum {
	return (Enum)(C.goglClientWaitSync((C.GLsync)(sync), (C.GLbitfield)(flags), (C.GLuint64)(timeout)))
}
func WaitSync(sync Sync, flags Bitfield, timeout Uint64)  {
	C.goglWaitSync((C.GLsync)(sync), (C.GLbitfield)(flags), (C.GLuint64)(timeout))
}
func GetInteger64v(pname Enum, params *Int64)  {
	C.goglGetInteger64v((C.GLenum)(pname), (*C.GLint64)(params))
}
func GetSynciv(sync Sync, pname Enum, bufSize Sizei, length *Sizei, values *Int)  {
	C.goglGetSynciv((C.GLsync)(sync), (C.GLenum)(pname), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLint)(values))
}
// ARB_tessellation_shader

func PatchParameteri(pname Enum, value Int)  {
	C.goglPatchParameteri((C.GLenum)(pname), (C.GLint)(value))
}
func PatchParameterfv(pname Enum, values *Float)  {
	C.goglPatchParameterfv((C.GLenum)(pname), (*C.GLfloat)(values))
}
// ARB_texture_buffer_object

func TexBufferARB(target Enum, internalformat Enum, buffer Uint)  {
	C.goglTexBufferARB((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer))
}
// ARB_texture_buffer_range

func TexBufferRange(target Enum, internalformat Enum, buffer Uint, offset Intptr, size Sizeiptr)  {
	C.goglTexBufferRange((C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size))
}
func TextureBufferRangeEXT(texture Uint, target Enum, internalformat Enum, buffer Uint, offset Intptr, size Sizeiptr)  {
	C.goglTextureBufferRangeEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size))
}
// ARB_texture_compression

func CompressedTexImage3DARB(target Enum, level Int, internalformat Enum, width Sizei, height Sizei, depth Sizei, border Int, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexImage3DARB((C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func CompressedTexImage2DARB(target Enum, level Int, internalformat Enum, width Sizei, height Sizei, border Int, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexImage2DARB((C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func CompressedTexImage1DARB(target Enum, level Int, internalformat Enum, width Sizei, border Int, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexImage1DARB((C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func CompressedTexSubImage3DARB(target Enum, level Int, xoffset Int, yoffset Int, zoffset Int, width Sizei, height Sizei, depth Sizei, format Enum, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexSubImage3DARB((C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func CompressedTexSubImage2DARB(target Enum, level Int, xoffset Int, yoffset Int, width Sizei, height Sizei, format Enum, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexSubImage2DARB((C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func CompressedTexSubImage1DARB(target Enum, level Int, xoffset Int, width Sizei, format Enum, imageSize Sizei, data Pointer)  {
	C.goglCompressedTexSubImage1DARB((C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLsizei)(imageSize), (unsafe.Pointer)(data))
}
func GetCompressedTexImageARB(target Enum, level Int, img Pointer)  {
	C.goglGetCompressedTexImageARB((C.GLenum)(target), (C.GLint)(level), (unsafe.Pointer)(img))
}
// ARB_texture_multisample

func TexImage2DMultisample(target Enum, samples Sizei, internalformat Int, width Sizei, height Sizei, fixedsamplelocations Boolean)  {
	C.goglTexImage2DMultisample((C.GLenum)(target), (C.GLsizei)(samples), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(fixedsamplelocations))
}
func TexImage3DMultisample(target Enum, samples Sizei, internalformat Int, width Sizei, height Sizei, depth Sizei, fixedsamplelocations Boolean)  {
	C.goglTexImage3DMultisample((C.GLenum)(target), (C.GLsizei)(samples), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(fixedsamplelocations))
}
func GetMultisamplefv(pname Enum, index Uint, val *Float)  {
	C.goglGetMultisamplefv((C.GLenum)(pname), (C.GLuint)(index), (*C.GLfloat)(val))
}
func SampleMaski(index Uint, mask Bitfield)  {
	C.goglSampleMaski((C.GLuint)(index), (C.GLbitfield)(mask))
}
// ARB_texture_storage

func TexStorage1D(target Enum, levels Sizei, internalformat Enum, width Sizei)  {
	C.goglTexStorage1D((C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width))
}
func TexStorage2D(target Enum, levels Sizei, internalformat Enum, width Sizei, height Sizei)  {
	C.goglTexStorage2D((C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height))
}
func TexStorage3D(target Enum, levels Sizei, internalformat Enum, width Sizei, height Sizei, depth Sizei)  {
	C.goglTexStorage3D((C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth))
}
func TextureStorage1DEXT(texture Uint, target Enum, levels Sizei, internalformat Enum, width Sizei)  {
	C.goglTextureStorage1DEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width))
}
func TextureStorage2DEXT(texture Uint, target Enum, levels Sizei, internalformat Enum, width Sizei, height Sizei)  {
	C.goglTextureStorage2DEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height))
}
func TextureStorage3DEXT(texture Uint, target Enum, levels Sizei, internalformat Enum, width Sizei, height Sizei, depth Sizei)  {
	C.goglTextureStorage3DEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth))
}
// ARB_texture_storage_multisample

func TexStorage2DMultisample(target Enum, samples Sizei, internalformat Enum, width Sizei, height Sizei, fixedsamplelocations Boolean)  {
	C.goglTexStorage2DMultisample((C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(fixedsamplelocations))
}
func TexStorage3DMultisample(target Enum, samples Sizei, internalformat Enum, width Sizei, height Sizei, depth Sizei, fixedsamplelocations Boolean)  {
	C.goglTexStorage3DMultisample((C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(fixedsamplelocations))
}
func TextureStorage2DMultisampleEXT(texture Uint, target Enum, samples Sizei, internalformat Enum, width Sizei, height Sizei, fixedsamplelocations Boolean)  {
	C.goglTextureStorage2DMultisampleEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(fixedsamplelocations))
}
func TextureStorage3DMultisampleEXT(texture Uint, target Enum, samples Sizei, internalformat Enum, width Sizei, height Sizei, depth Sizei, fixedsamplelocations Boolean)  {
	C.goglTextureStorage3DMultisampleEXT((C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(fixedsamplelocations))
}
// ARB_texture_view

func TextureView(texture Uint, target Enum, origtexture Uint, internalformat Enum, minlevel Uint, numlevels Uint, minlayer Uint, numlayers Uint)  {
	C.goglTextureView((C.GLuint)(texture), (C.GLenum)(target), (C.GLuint)(origtexture), (C.GLenum)(internalformat), (C.GLuint)(minlevel), (C.GLuint)(numlevels), (C.GLuint)(minlayer), (C.GLuint)(numlayers))
}
// ARB_timer_query

func QueryCounter(id Uint, target Enum)  {
	C.goglQueryCounter((C.GLuint)(id), (C.GLenum)(target))
}
func GetQueryObjecti64v(id Uint, pname Enum, params *Int64)  {
	C.goglGetQueryObjecti64v((C.GLuint)(id), (C.GLenum)(pname), (*C.GLint64)(params))
}
func GetQueryObjectui64v(id Uint, pname Enum, params *Uint64)  {
	C.goglGetQueryObjectui64v((C.GLuint)(id), (C.GLenum)(pname), (*C.GLuint64)(params))
}
// ARB_transform_feedback2

func BindTransformFeedback(target Enum, id Uint)  {
	C.goglBindTransformFeedback((C.GLenum)(target), (C.GLuint)(id))
}
func DeleteTransformFeedbacks(n Sizei, ids *Uint)  {
	C.goglDeleteTransformFeedbacks((C.GLsizei)(n), (*C.GLuint)(ids))
}
func GenTransformFeedbacks(n Sizei, ids *Uint)  {
	C.goglGenTransformFeedbacks((C.GLsizei)(n), (*C.GLuint)(ids))
}
func IsTransformFeedback(id Uint) Boolean {
	return (Boolean)(C.goglIsTransformFeedback((C.GLuint)(id)))
}
func PauseTransformFeedback()  {
	C.goglPauseTransformFeedback()
}
func ResumeTransformFeedback()  {
	C.goglResumeTransformFeedback()
}
func DrawTransformFeedback(mode Enum, id Uint)  {
	C.goglDrawTransformFeedback((C.GLenum)(mode), (C.GLuint)(id))
}
// ARB_transform_feedback3

func DrawTransformFeedbackStream(mode Enum, id Uint, stream Uint)  {
	C.goglDrawTransformFeedbackStream((C.GLenum)(mode), (C.GLuint)(id), (C.GLuint)(stream))
}
func BeginQueryIndexed(target Enum, index Uint, id Uint)  {
	C.goglBeginQueryIndexed((C.GLenum)(target), (C.GLuint)(index), (C.GLuint)(id))
}
func EndQueryIndexed(target Enum, index Uint)  {
	C.goglEndQueryIndexed((C.GLenum)(target), (C.GLuint)(index))
}
func GetQueryIndexediv(target Enum, index Uint, pname Enum, params *Int)  {
	C.goglGetQueryIndexediv((C.GLenum)(target), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(params))
}
// ARB_transform_feedback_instanced

func DrawTransformFeedbackInstanced(mode Enum, id Uint, instancecount Sizei)  {
	C.goglDrawTransformFeedbackInstanced((C.GLenum)(mode), (C.GLuint)(id), (C.GLsizei)(instancecount))
}
func DrawTransformFeedbackStreamInstanced(mode Enum, id Uint, stream Uint, instancecount Sizei)  {
	C.goglDrawTransformFeedbackStreamInstanced((C.GLenum)(mode), (C.GLuint)(id), (C.GLuint)(stream), (C.GLsizei)(instancecount))
}
// ARB_transpose_matrix

func LoadTransposeMatrixfARB(m *Float)  {
	C.goglLoadTransposeMatrixfARB((*C.GLfloat)(m))
}
func LoadTransposeMatrixdARB(m *Double)  {
	C.goglLoadTransposeMatrixdARB((*C.GLdouble)(m))
}
func MultTransposeMatrixfARB(m *Float)  {
	C.goglMultTransposeMatrixfARB((*C.GLfloat)(m))
}
func MultTransposeMatrixdARB(m *Double)  {
	C.goglMultTransposeMatrixdARB((*C.GLdouble)(m))
}
// ARB_uniform_buffer_object

func GetUniformIndices(program Uint, uniformCount Sizei, uniformNames **Char, uniformIndices *Uint)  {
	C.goglGetUniformIndices((C.GLuint)(program), (C.GLsizei)(uniformCount), (**C.GLchar)(unsafe.Pointer(uniformNames)), (*C.GLuint)(uniformIndices))
}
func GetActiveUniformsiv(program Uint, uniformCount Sizei, uniformIndices *Uint, pname Enum, params *Int)  {
	C.goglGetActiveUniformsiv((C.GLuint)(program), (C.GLsizei)(uniformCount), (*C.GLuint)(uniformIndices), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetActiveUniformName(program Uint, uniformIndex Uint, bufSize Sizei, length *Sizei, uniformName *Char)  {
	C.goglGetActiveUniformName((C.GLuint)(program), (C.GLuint)(uniformIndex), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLchar)(uniformName))
}
func GetUniformBlockIndex(program Uint, uniformBlockName *Char) Uint {
	return (Uint)(C.goglGetUniformBlockIndex((C.GLuint)(program), (*C.GLchar)(uniformBlockName)))
}
func GetActiveUniformBlockiv(program Uint, uniformBlockIndex Uint, pname Enum, params *Int)  {
	C.goglGetActiveUniformBlockiv((C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetActiveUniformBlockName(program Uint, uniformBlockIndex Uint, bufSize Sizei, length *Sizei, uniformBlockName *Char)  {
	C.goglGetActiveUniformBlockName((C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLsizei)(bufSize), (*C.GLsizei)(length), (*C.GLchar)(uniformBlockName))
}
func UniformBlockBinding(program Uint, uniformBlockIndex Uint, uniformBlockBinding Uint)  {
	C.goglUniformBlockBinding((C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLuint)(uniformBlockBinding))
}
// ARB_vertex_array_object

func BindVertexArray(array Uint)  {
	C.goglBindVertexArray((C.GLuint)(array))
}
func DeleteVertexArrays(n Sizei, arrays *Uint)  {
	C.goglDeleteVertexArrays((C.GLsizei)(n), (*C.GLuint)(arrays))
}
func GenVertexArrays(n Sizei, arrays *Uint)  {
	C.goglGenVertexArrays((C.GLsizei)(n), (*C.GLuint)(arrays))
}
func IsVertexArray(array Uint) Boolean {
	return (Boolean)(C.goglIsVertexArray((C.GLuint)(array)))
}
// ARB_vertex_attrib_64bit

func VertexAttribL1d(index Uint, x Double)  {
	C.goglVertexAttribL1d((C.GLuint)(index), (C.GLdouble)(x))
}
func VertexAttribL2d(index Uint, x Double, y Double)  {
	C.goglVertexAttribL2d((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y))
}
func VertexAttribL3d(index Uint, x Double, y Double, z Double)  {
	C.goglVertexAttribL3d((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z))
}
func VertexAttribL4d(index Uint, x Double, y Double, z Double, w Double)  {
	C.goglVertexAttribL4d((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w))
}
func VertexAttribL1dv(index Uint, v *Double)  {
	C.goglVertexAttribL1dv((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttribL2dv(index Uint, v *Double)  {
	C.goglVertexAttribL2dv((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttribL3dv(index Uint, v *Double)  {
	C.goglVertexAttribL3dv((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttribL4dv(index Uint, v *Double)  {
	C.goglVertexAttribL4dv((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttribLPointer(index Uint, size Int, type_ Enum, stride Sizei, pointer Pointer)  {
	C.goglVertexAttribLPointer((C.GLuint)(index), (C.GLint)(size), (C.GLenum)(type_), (C.GLsizei)(stride), (unsafe.Pointer)(pointer))
}
func GetVertexAttribLdv(index Uint, pname Enum, params *Double)  {
	C.goglGetVertexAttribLdv((C.GLuint)(index), (C.GLenum)(pname), (*C.GLdouble)(params))
}
// ARB_vertex_attrib_binding

func BindVertexBuffer(bindingindex Uint, buffer Uint, offset Intptr, stride Sizei)  {
	C.goglBindVertexBuffer((C.GLuint)(bindingindex), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizei)(stride))
}
func VertexAttribFormat(attribindex Uint, size Int, type_ Enum, normalized Boolean, relativeoffset Uint)  {
	C.goglVertexAttribFormat((C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(relativeoffset))
}
func VertexAttribIFormat(attribindex Uint, size Int, type_ Enum, relativeoffset Uint)  {
	C.goglVertexAttribIFormat((C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLuint)(relativeoffset))
}
func VertexAttribLFormat(attribindex Uint, size Int, type_ Enum, relativeoffset Uint)  {
	C.goglVertexAttribLFormat((C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLuint)(relativeoffset))
}
func VertexAttribBinding(attribindex Uint, bindingindex Uint)  {
	C.goglVertexAttribBinding((C.GLuint)(attribindex), (C.GLuint)(bindingindex))
}
func VertexBindingDivisor(bindingindex Uint, divisor Uint)  {
	C.goglVertexBindingDivisor((C.GLuint)(bindingindex), (C.GLuint)(divisor))
}
func VertexArrayBindVertexBufferEXT(vaobj Uint, bindingindex Uint, buffer Uint, offset Intptr, stride Sizei)  {
	C.goglVertexArrayBindVertexBufferEXT((C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizei)(stride))
}
func VertexArrayVertexAttribFormatEXT(vaobj Uint, attribindex Uint, size Int, type_ Enum, normalized Boolean, relativeoffset Uint)  {
	C.goglVertexArrayVertexAttribFormatEXT((C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(relativeoffset))
}
func VertexArrayVertexAttribIFormatEXT(vaobj Uint, attribindex Uint, size Int, type_ Enum, relativeoffset Uint)  {
	C.goglVertexArrayVertexAttribIFormatEXT((C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLuint)(relativeoffset))
}
func VertexArrayVertexAttribLFormatEXT(vaobj Uint, attribindex Uint, size Int, type_ Enum, relativeoffset Uint)  {
	C.goglVertexArrayVertexAttribLFormatEXT((C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(type_), (C.GLuint)(relativeoffset))
}
func VertexArrayVertexAttribBindingEXT(vaobj Uint, attribindex Uint, bindingindex Uint)  {
	C.goglVertexArrayVertexAttribBindingEXT((C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLuint)(bindingindex))
}
func VertexArrayVertexBindingDivisorEXT(vaobj Uint, bindingindex Uint, divisor Uint)  {
	C.goglVertexArrayVertexBindingDivisorEXT((C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(divisor))
}
// ARB_vertex_blend

func WeightbvARB(size Int, weights *Byte)  {
	C.goglWeightbvARB((C.GLint)(size), (*C.GLbyte)(weights))
}
func WeightsvARB(size Int, weights *Short)  {
	C.goglWeightsvARB((C.GLint)(size), (*C.GLshort)(weights))
}
func WeightivARB(size Int, weights *Int)  {
	C.goglWeightivARB((C.GLint)(size), (*C.GLint)(weights))
}
func WeightfvARB(size Int, weights *Float)  {
	C.goglWeightfvARB((C.GLint)(size), (*C.GLfloat)(weights))
}
func WeightdvARB(size Int, weights *Double)  {
	C.goglWeightdvARB((C.GLint)(size), (*C.GLdouble)(weights))
}
func WeightubvARB(size Int, weights *Ubyte)  {
	C.goglWeightubvARB((C.GLint)(size), (*C.GLubyte)(weights))
}
func WeightusvARB(size Int, weights *Ushort)  {
	C.goglWeightusvARB((C.GLint)(size), (*C.GLushort)(weights))
}
func WeightuivARB(size Int, weights *Uint)  {
	C.goglWeightuivARB((C.GLint)(size), (*C.GLuint)(weights))
}
func WeightPointerARB(size Int, type_ Enum, stride Sizei, pointer Pointer)  {
	C.goglWeightPointerARB((C.GLint)(size), (C.GLenum)(type_), (C.GLsizei)(stride), (unsafe.Pointer)(pointer))
}
func VertexBlendARB(count Int)  {
	C.goglVertexBlendARB((C.GLint)(count))
}
// ARB_vertex_buffer_object

func BindBufferARB(target Enum, buffer Uint)  {
	C.goglBindBufferARB((C.GLenum)(target), (C.GLuint)(buffer))
}
func DeleteBuffersARB(n Sizei, buffers *Uint)  {
	C.goglDeleteBuffersARB((C.GLsizei)(n), (*C.GLuint)(buffers))
}
func GenBuffersARB(n Sizei, buffers *Uint)  {
	C.goglGenBuffersARB((C.GLsizei)(n), (*C.GLuint)(buffers))
}
func IsBufferARB(buffer Uint) Boolean {
	return (Boolean)(C.goglIsBufferARB((C.GLuint)(buffer)))
}
func BufferDataARB(target Enum, size Sizeiptr, data Pointer, usage Enum)  {
	C.goglBufferDataARB((C.GLenum)(target), (C.GLsizeiptrARB)(size), (unsafe.Pointer)(data), (C.GLenum)(usage))
}
func BufferSubDataARB(target Enum, offset Intptr, size Sizeiptr, data Pointer)  {
	C.goglBufferSubDataARB((C.GLenum)(target), (C.GLintptrARB)(offset), (C.GLsizeiptrARB)(size), (unsafe.Pointer)(data))
}
func GetBufferSubDataARB(target Enum, offset Intptr, size Sizeiptr, data Pointer)  {
	C.goglGetBufferSubDataARB((C.GLenum)(target), (C.GLintptrARB)(offset), (C.GLsizeiptrARB)(size), (unsafe.Pointer)(data))
}
func MapBufferARB(target Enum, access Enum) Pointer {
	return (Pointer)(C.goglMapBufferARB((C.GLenum)(target), (C.GLenum)(access)))
}
func UnmapBufferARB(target Enum) Boolean {
	return (Boolean)(C.goglUnmapBufferARB((C.GLenum)(target)))
}
func GetBufferParameterivARB(target Enum, pname Enum, params *Int)  {
	C.goglGetBufferParameterivARB((C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetBufferPointervARB(target Enum, pname Enum, params *Pointer)  {
	C.goglGetBufferPointervARB((C.GLenum)(target), (C.GLenum)(pname), (*unsafe.Pointer)(params))
}
// ARB_vertex_program

func VertexAttrib1dARB(index Uint, x Double)  {
	C.goglVertexAttrib1dARB((C.GLuint)(index), (C.GLdouble)(x))
}
func VertexAttrib1dvARB(index Uint, v *Double)  {
	C.goglVertexAttrib1dvARB((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttrib1fARB(index Uint, x Float)  {
	C.goglVertexAttrib1fARB((C.GLuint)(index), (C.GLfloat)(x))
}
func VertexAttrib1fvARB(index Uint, v *Float)  {
	C.goglVertexAttrib1fvARB((C.GLuint)(index), (*C.GLfloat)(v))
}
func VertexAttrib1sARB(index Uint, x Short)  {
	C.goglVertexAttrib1sARB((C.GLuint)(index), (C.GLshort)(x))
}
func VertexAttrib1svARB(index Uint, v *Short)  {
	C.goglVertexAttrib1svARB((C.GLuint)(index), (*C.GLshort)(v))
}
func VertexAttrib2dARB(index Uint, x Double, y Double)  {
	C.goglVertexAttrib2dARB((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y))
}
func VertexAttrib2dvARB(index Uint, v *Double)  {
	C.goglVertexAttrib2dvARB((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttrib2fARB(index Uint, x Float, y Float)  {
	C.goglVertexAttrib2fARB((C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y))
}
func VertexAttrib2fvARB(index Uint, v *Float)  {
	C.goglVertexAttrib2fvARB((C.GLuint)(index), (*C.GLfloat)(v))
}
func VertexAttrib2sARB(index Uint, x Short, y Short)  {
	C.goglVertexAttrib2sARB((C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y))
}
func VertexAttrib2svARB(index Uint, v *Short)  {
	C.goglVertexAttrib2svARB((C.GLuint)(index), (*C.GLshort)(v))
}
func VertexAttrib3dARB(index Uint, x Double, y Double, z Double)  {
	C.goglVertexAttrib3dARB((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z))
}
func VertexAttrib3dvARB(index Uint, v *Double)  {
	C.goglVertexAttrib3dvARB((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttrib3fARB(index Uint, x Float, y Float, z Float)  {
	C.goglVertexAttrib3fARB((C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z))
}
func VertexAttrib3fvARB(index Uint, v *Float)  {
	C.goglVertexAttrib3fvARB((C.GLuint)(index), (*C.GLfloat)(v))
}
func VertexAttrib3sARB(index Uint, x Short, y Short, z Short)  {
	C.goglVertexAttrib3sARB((C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y), (C.GLshort)(z))
}
func VertexAttrib3svARB(index Uint, v *Short)  {
	C.goglVertexAttrib3svARB((C.GLuint)(index), (*C.GLshort)(v))
}
func VertexAttrib4NbvARB(index Uint, v *Byte)  {
	C.goglVertexAttrib4NbvARB((C.GLuint)(index), (*C.GLbyte)(v))
}
func VertexAttrib4NivARB(index Uint, v *Int)  {
	C.goglVertexAttrib4NivARB((C.GLuint)(index), (*C.GLint)(v))
}
func VertexAttrib4NsvARB(index Uint, v *Short)  {
	C.goglVertexAttrib4NsvARB((C.GLuint)(index), (*C.GLshort)(v))
}
func VertexAttrib4NubARB(index Uint, x Ubyte, y Ubyte, z Ubyte, w Ubyte)  {
	C.goglVertexAttrib4NubARB((C.GLuint)(index), (C.GLubyte)(x), (C.GLubyte)(y), (C.GLubyte)(z), (C.GLubyte)(w))
}
func VertexAttrib4NubvARB(index Uint, v *Ubyte)  {
	C.goglVertexAttrib4NubvARB((C.GLuint)(index), (*C.GLubyte)(v))
}
func VertexAttrib4NuivARB(index Uint, v *Uint)  {
	C.goglVertexAttrib4NuivARB((C.GLuint)(index), (*C.GLuint)(v))
}
func VertexAttrib4NusvARB(index Uint, v *Ushort)  {
	C.goglVertexAttrib4NusvARB((C.GLuint)(index), (*C.GLushort)(v))
}
func VertexAttrib4bvARB(index Uint, v *Byte)  {
	C.goglVertexAttrib4bvARB((C.GLuint)(index), (*C.GLbyte)(v))
}
func VertexAttrib4dARB(index Uint, x Double, y Double, z Double, w Double)  {
	C.goglVertexAttrib4dARB((C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w))
}
func VertexAttrib4dvARB(index Uint, v *Double)  {
	C.goglVertexAttrib4dvARB((C.GLuint)(index), (*C.GLdouble)(v))
}
func VertexAttrib4fARB(index Uint, x Float, y Float, z Float, w Float)  {
	C.goglVertexAttrib4fARB((C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z), (C.GLfloat)(w))
}
func VertexAttrib4fvARB(index Uint, v *Float)  {
	C.goglVertexAttrib4fvARB((C.GLuint)(index), (*C.GLfloat)(v))
}
func VertexAttrib4ivARB(index Uint, v *Int)  {
	C.goglVertexAttrib4ivARB((C.GLuint)(index), (*C.GLint)(v))
}
func VertexAttrib4sARB(index Uint, x Short, y Short, z Short, w Short)  {
	C.goglVertexAttrib4sARB((C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y), (C.GLshort)(z), (C.GLshort)(w))
}
func VertexAttrib4svARB(index Uint, v *Short)  {
	C.goglVertexAttrib4svARB((C.GLuint)(index), (*C.GLshort)(v))
}
func VertexAttrib4ubvARB(index Uint, v *Ubyte)  {
	C.goglVertexAttrib4ubvARB((C.GLuint)(index), (*C.GLubyte)(v))
}
func VertexAttrib4uivARB(index Uint, v *Uint)  {
	C.goglVertexAttrib4uivARB((C.GLuint)(index), (*C.GLuint)(v))
}
func VertexAttrib4usvARB(index Uint, v *Ushort)  {
	C.goglVertexAttrib4usvARB((C.GLuint)(index), (*C.GLushort)(v))
}
func VertexAttribPointerARB(index Uint, size Int, type_ Enum, normalized Boolean, stride Sizei, pointer Pointer)  {
	C.goglVertexAttribPointerARB((C.GLuint)(index), (C.GLint)(size), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLsizei)(stride), (unsafe.Pointer)(pointer))
}
func EnableVertexAttribArrayARB(index Uint)  {
	C.goglEnableVertexAttribArrayARB((C.GLuint)(index))
}
func DisableVertexAttribArrayARB(index Uint)  {
	C.goglDisableVertexAttribArrayARB((C.GLuint)(index))
}
func ProgramStringARB(target Enum, format Enum, len Sizei, string_ Pointer)  {
	C.goglProgramStringARB((C.GLenum)(target), (C.GLenum)(format), (C.GLsizei)(len), (unsafe.Pointer)(string_))
}
func BindProgramARB(target Enum, program Uint)  {
	C.goglBindProgramARB((C.GLenum)(target), (C.GLuint)(program))
}
func DeleteProgramsARB(n Sizei, programs *Uint)  {
	C.goglDeleteProgramsARB((C.GLsizei)(n), (*C.GLuint)(programs))
}
func GenProgramsARB(n Sizei, programs *Uint)  {
	C.goglGenProgramsARB((C.GLsizei)(n), (*C.GLuint)(programs))
}
func ProgramEnvParameter4dARB(target Enum, index Uint, x Double, y Double, z Double, w Double)  {
	C.goglProgramEnvParameter4dARB((C.GLenum)(target), (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w))
}
func ProgramEnvParameter4dvARB(target Enum, index Uint, params *Double)  {
	C.goglProgramEnvParameter4dvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(params))
}
func ProgramEnvParameter4fARB(target Enum, index Uint, x Float, y Float, z Float, w Float)  {
	C.goglProgramEnvParameter4fARB((C.GLenum)(target), (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z), (C.GLfloat)(w))
}
func ProgramEnvParameter4fvARB(target Enum, index Uint, params *Float)  {
	C.goglProgramEnvParameter4fvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(params))
}
func ProgramLocalParameter4dARB(target Enum, index Uint, x Double, y Double, z Double, w Double)  {
	C.goglProgramLocalParameter4dARB((C.GLenum)(target), (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w))
}
func ProgramLocalParameter4dvARB(target Enum, index Uint, params *Double)  {
	C.goglProgramLocalParameter4dvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(params))
}
func ProgramLocalParameter4fARB(target Enum, index Uint, x Float, y Float, z Float, w Float)  {
	C.goglProgramLocalParameter4fARB((C.GLenum)(target), (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z), (C.GLfloat)(w))
}
func ProgramLocalParameter4fvARB(target Enum, index Uint, params *Float)  {
	C.goglProgramLocalParameter4fvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(params))
}
func GetProgramEnvParameterdvARB(target Enum, index Uint, params *Double)  {
	C.goglGetProgramEnvParameterdvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(params))
}
func GetProgramEnvParameterfvARB(target Enum, index Uint, params *Float)  {
	C.goglGetProgramEnvParameterfvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(params))
}
func GetProgramLocalParameterdvARB(target Enum, index Uint, params *Double)  {
	C.goglGetProgramLocalParameterdvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(params))
}
func GetProgramLocalParameterfvARB(target Enum, index Uint, params *Float)  {
	C.goglGetProgramLocalParameterfvARB((C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(params))
}
func GetProgramivARB(target Enum, pname Enum, params *Int)  {
	C.goglGetProgramivARB((C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetProgramStringARB(target Enum, pname Enum, string_ Pointer)  {
	C.goglGetProgramStringARB((C.GLenum)(target), (C.GLenum)(pname), (unsafe.Pointer)(string_))
}
func GetVertexAttribdvARB(index Uint, pname Enum, params *Double)  {
	C.goglGetVertexAttribdvARB((C.GLuint)(index), (C.GLenum)(pname), (*C.GLdouble)(params))
}
func GetVertexAttribfvARB(index Uint, pname Enum, params *Float)  {
	C.goglGetVertexAttribfvARB((C.GLuint)(index), (C.GLenum)(pname), (*C.GLfloat)(params))
}
func GetVertexAttribivARB(index Uint, pname Enum, params *Int)  {
	C.goglGetVertexAttribivARB((C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(params))
}
func GetVertexAttribPointervARB(index Uint, pname Enum, pointer *Pointer)  {
	C.goglGetVertexAttribPointervARB((C.GLuint)(index), (C.GLenum)(pname), (*unsafe.Pointer)(pointer))
}
func IsProgramARB(program Uint) Boolean {
	return (Boolean)(C.goglIsProgramARB((C.GLuint)(program)))
}
// ARB_vertex_shader

func BindAttribLocationARB(programObj Uint, index Uint, name *Char)  {
	C.goglBindAttribLocationARB((C.GLhandleARB)(programObj), (C.GLuint)(index), (*C.GLcharARB)(name))
}
func GetActiveAttribARB(programObj Uint, index Uint, maxLength Sizei, length *Sizei, size *Int, type_ *Enum, name *Char)  {
	C.goglGetActiveAttribARB((C.GLhandleARB)(programObj), (C.GLuint)(index), (C.GLsizei)(maxLength), (*C.GLsizei)(length), (*C.GLint)(size), (*C.GLenum)(type_), (*C.GLcharARB)(name))
}
func GetAttribLocationARB(programObj Uint, name *Char) Int {
	return (Int)(C.goglGetAttribLocationARB((C.GLhandleARB)(programObj), (*C.GLcharARB)(name)))
}
// ARB_vertex_type_2_10_10_10_rev

func VertexP2ui(type_ Enum, value Uint)  {
	C.goglVertexP2ui((C.GLenum)(type_), (C.GLuint)(value))
}
func VertexP2uiv(type_ Enum, value *Uint)  {
	C.goglVertexP2uiv((C.GLenum)(type_), (*C.GLuint)(value))
}
func VertexP3ui(type_ Enum, value Uint)  {
	C.goglVertexP3ui((C.GLenum)(type_), (C.GLuint)(value))
}
func VertexP3uiv(type_ Enum, value *Uint)  {
	C.goglVertexP3uiv((C.GLenum)(type_), (*C.GLuint)(value))
}
func VertexP4ui(type_ Enum, value Uint)  {
	C.goglVertexP4ui((C.GLenum)(type_), (C.GLuint)(value))
}
func VertexP4uiv(type_ Enum, value *Uint)  {
	C.goglVertexP4uiv((C.GLenum)(type_), (*C.GLuint)(value))
}
func TexCoordP1ui(type_ Enum, coords Uint)  {
	C.goglTexCoordP1ui((C.GLenum)(type_), (C.GLuint)(coords))
}
func TexCoordP1uiv(type_ Enum, coords *Uint)  {
	C.goglTexCoordP1uiv((C.GLenum)(type_), (*C.GLuint)(coords))
}
func TexCoordP2ui(type_ Enum, coords Uint)  {
	C.goglTexCoordP2ui((C.GLenum)(type_), (C.GLuint)(coords))
}
func TexCoordP2uiv(type_ Enum, coords *Uint)  {
	C.goglTexCoordP2uiv((C.GLenum)(type_), (*C.GLuint)(coords))
}
func TexCoordP3ui(type_ Enum, coords Uint)  {
	C.goglTexCoordP3ui((C.GLenum)(type_), (C.GLuint)(coords))
}
func TexCoordP3uiv(type_ Enum, coords *Uint)  {
	C.goglTexCoordP3uiv((C.GLenum)(type_), (*C.GLuint)(coords))
}
func TexCoordP4ui(type_ Enum, coords Uint)  {
	C.goglTexCoordP4ui((C.GLenum)(type_), (C.GLuint)(coords))
}
func TexCoordP4uiv(type_ Enum, coords *Uint)  {
	C.goglTexCoordP4uiv((C.GLenum)(type_), (*C.GLuint)(coords))
}
func MultiTexCoordP1ui(texture Enum, type_ Enum, coords Uint)  {
	C.goglMultiTexCoordP1ui((C.GLenum)(texture), (C.GLenum)(type_), (C.GLuint)(coords))
}
func MultiTexCoordP1uiv(texture Enum, type_ Enum, coords *Uint)  {
	C.goglMultiTexCoordP1uiv((C.GLenum)(texture), (C.GLenum)(type_), (*C.GLuint)(coords))
}
func MultiTexCoordP2ui(texture Enum, type_ Enum, coords Uint)  {
	C.goglMultiTexCoordP2ui((C.GLenum)(texture), (C.GLenum)(type_), (C.GLuint)(coords))
}
func MultiTexCoordP2uiv(texture Enum, type_ Enum, coords *Uint)  {
	C.goglMultiTexCoordP2uiv((C.GLenum)(texture), (C.GLenum)(type_), (*C.GLuint)(coords))
}
func MultiTexCoordP3ui(texture Enum, type_ Enum, coords Uint)  {
	C.goglMultiTexCoordP3ui((C.GLenum)(texture), (C.GLenum)(type_), (C.GLuint)(coords))
}
func MultiTexCoordP3uiv(texture Enum, type_ Enum, coords *Uint)  {
	C.goglMultiTexCoordP3uiv((C.GLenum)(texture), (C.GLenum)(type_), (*C.GLuint)(coords))
}
func MultiTexCoordP4ui(texture Enum, type_ Enum, coords Uint)  {
	C.goglMultiTexCoordP4ui((C.GLenum)(texture), (C.GLenum)(type_), (C.GLuint)(coords))
}
func MultiTexCoordP4uiv(texture Enum, type_ Enum, coords *Uint)  {
	C.goglMultiTexCoordP4uiv((C.GLenum)(texture), (C.GLenum)(type_), (*C.GLuint)(coords))
}
func NormalP3ui(type_ Enum, coords Uint)  {
	C.goglNormalP3ui((C.GLenum)(type_), (C.GLuint)(coords))
}
func NormalP3uiv(type_ Enum, coords *Uint)  {
	C.goglNormalP3uiv((C.GLenum)(type_), (*C.GLuint)(coords))
}
func ColorP3ui(type_ Enum, color Uint)  {
	C.goglColorP3ui((C.GLenum)(type_), (C.GLuint)(color))
}
func ColorP3uiv(type_ Enum, color *Uint)  {
	C.goglColorP3uiv((C.GLenum)(type_), (*C.GLuint)(color))
}
func ColorP4ui(type_ Enum, color Uint)  {
	C.goglColorP4ui((C.GLenum)(type_), (C.GLuint)(color))
}
func ColorP4uiv(type_ Enum, color *Uint)  {
	C.goglColorP4uiv((C.GLenum)(type_), (*C.GLuint)(color))
}
func SecondaryColorP3ui(type_ Enum, color Uint)  {
	C.goglSecondaryColorP3ui((C.GLenum)(type_), (C.GLuint)(color))
}
func SecondaryColorP3uiv(type_ Enum, color *Uint)  {
	C.goglSecondaryColorP3uiv((C.GLenum)(type_), (*C.GLuint)(color))
}
func VertexAttribP1ui(index Uint, type_ Enum, normalized Boolean, value Uint)  {
	C.goglVertexAttribP1ui((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(value))
}
func VertexAttribP1uiv(index Uint, type_ Enum, normalized Boolean, value *Uint)  {
	C.goglVertexAttribP1uiv((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (*C.GLuint)(value))
}
func VertexAttribP2ui(index Uint, type_ Enum, normalized Boolean, value Uint)  {
	C.goglVertexAttribP2ui((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(value))
}
func VertexAttribP2uiv(index Uint, type_ Enum, normalized Boolean, value *Uint)  {
	C.goglVertexAttribP2uiv((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (*C.GLuint)(value))
}
func VertexAttribP3ui(index Uint, type_ Enum, normalized Boolean, value Uint)  {
	C.goglVertexAttribP3ui((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(value))
}
func VertexAttribP3uiv(index Uint, type_ Enum, normalized Boolean, value *Uint)  {
	C.goglVertexAttribP3uiv((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (*C.GLuint)(value))
}
func VertexAttribP4ui(index Uint, type_ Enum, normalized Boolean, value Uint)  {
	C.goglVertexAttribP4ui((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (C.GLuint)(value))
}
func VertexAttribP4uiv(index Uint, type_ Enum, normalized Boolean, value *Uint)  {
	C.goglVertexAttribP4uiv((C.GLuint)(index), (C.GLenum)(type_), (C.GLboolean)(normalized), (*C.GLuint)(value))
}
// ARB_viewport_array

func ViewportArrayv(first Uint, count Sizei, v *Float)  {
	C.goglViewportArrayv((C.GLuint)(first), (C.GLsizei)(count), (*C.GLfloat)(v))
}
func ViewportIndexedf(index Uint, x Float, y Float, w Float, h Float)  {
	C.goglViewportIndexedf((C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(w), (C.GLfloat)(h))
}
func ViewportIndexedfv(index Uint, v *Float)  {
	C.goglViewportIndexedfv((C.GLuint)(index), (*C.GLfloat)(v))
}
func ScissorArrayv(first Uint, count Sizei, v *Int)  {
	C.goglScissorArrayv((C.GLuint)(first), (C.GLsizei)(count), (*C.GLint)(v))
}
func ScissorIndexed(index Uint, left Int, bottom Int, width Sizei, height Sizei)  {
	C.goglScissorIndexed((C.GLuint)(index), (C.GLint)(left), (C.GLint)(bottom), (C.GLsizei)(width), (C.GLsizei)(height))
}
func ScissorIndexedv(index Uint, v *Int)  {
	C.goglScissorIndexedv((C.GLuint)(index), (*C.GLint)(v))
}
func DepthRangeArrayv(first Uint, count Sizei, v *Double)  {
	C.goglDepthRangeArrayv((C.GLuint)(first), (C.GLsizei)(count), (*C.GLdouble)(v))
}
func DepthRangeIndexed(index Uint, n Double, f Double)  {
	C.goglDepthRangeIndexed((C.GLuint)(index), (C.GLdouble)(n), (C.GLdouble)(f))
}
func GetFloati_v(target Enum, index Uint, data *Float)  {
	C.goglGetFloati_v((C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(data))
}
func GetDoublei_v(target Enum, index Uint, data *Double)  {
	C.goglGetDoublei_v((C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(data))
}
// ARB_window_pos

func WindowPos2dARB(x Double, y Double)  {
	C.goglWindowPos2dARB((C.GLdouble)(x), (C.GLdouble)(y))
}
func WindowPos2dvARB(v *Double)  {
	C.goglWindowPos2dvARB((*C.GLdouble)(v))
}
func WindowPos2fARB(x Float, y Float)  {
	C.goglWindowPos2fARB((C.GLfloat)(x), (C.GLfloat)(y))
}
func WindowPos2fvARB(v *Float)  {
	C.goglWindowPos2fvARB((*C.GLfloat)(v))
}
func WindowPos2iARB(x Int, y Int)  {
	C.goglWindowPos2iARB((C.GLint)(x), (C.GLint)(y))
}
func WindowPos2ivARB(v *Int)  {
	C.goglWindowPos2ivARB((*C.GLint)(v))
}
func WindowPos2sARB(x Short, y Short)  {
	C.goglWindowPos2sARB((C.GLshort)(x), (C.GLshort)(y))
}
func WindowPos2svARB(v *Short)  {
	C.goglWindowPos2svARB((*C.GLshort)(v))
}
func WindowPos3dARB(x Double, y Double, z Double)  {
	C.goglWindowPos3dARB((C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z))
}
func WindowPos3dvARB(v *Double)  {
	C.goglWindowPos3dvARB((*C.GLdouble)(v))
}
func WindowPos3fARB(x Float, y Float, z Float)  {
	C.goglWindowPos3fARB((C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z))
}
func WindowPos3fvARB(v *Float)  {
	C.goglWindowPos3fvARB((*C.GLfloat)(v))
}
func WindowPos3iARB(x Int, y Int, z Int)  {
	C.goglWindowPos3iARB((C.GLint)(x), (C.GLint)(y), (C.GLint)(z))
}
func WindowPos3ivARB(v *Int)  {
	C.goglWindowPos3ivARB((*C.GLint)(v))
}
func WindowPos3sARB(x Short, y Short, z Short)  {
	C.goglWindowPos3sARB((C.GLshort)(x), (C.GLshort)(y), (C.GLshort)(z))
}
func WindowPos3svARB(v *Short)  {
	C.goglWindowPos3svARB((*C.GLshort)(v))
}
func InitArbEs2Compatibility() error {
	var ret C.int
	if ret = C.init_ARB_ES2_compatibility(); ret != 0 {
		return errors.New("unable to initialize ARB_ES2_compatibility")
	}
	return nil
}
func InitArbBaseInstance() error {
	var ret C.int
	if ret = C.init_ARB_base_instance(); ret != 0 {
		return errors.New("unable to initialize ARB_base_instance")
	}
	return nil
}
func InitArbBlendFuncExtended() error {
	var ret C.int
	if ret = C.init_ARB_blend_func_extended(); ret != 0 {
		return errors.New("unable to initialize ARB_blend_func_extended")
	}
	return nil
}
func InitArbClEvent() error {
	var ret C.int
	if ret = C.init_ARB_cl_event(); ret != 0 {
		return errors.New("unable to initialize ARB_cl_event")
	}
	return nil
}
func InitArbClearBufferObject() error {
	var ret C.int
	if ret = C.init_ARB_clear_buffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_clear_buffer_object")
	}
	return nil
}
func InitArbColorBufferFloat() error {
	var ret C.int
	if ret = C.init_ARB_color_buffer_float(); ret != 0 {
		return errors.New("unable to initialize ARB_color_buffer_float")
	}
	return nil
}
func InitArbComputeShader() error {
	var ret C.int
	if ret = C.init_ARB_compute_shader(); ret != 0 {
		return errors.New("unable to initialize ARB_compute_shader")
	}
	return nil
}
func InitArbCopyBuffer() error {
	var ret C.int
	if ret = C.init_ARB_copy_buffer(); ret != 0 {
		return errors.New("unable to initialize ARB_copy_buffer")
	}
	return nil
}
func InitArbCopyImage() error {
	var ret C.int
	if ret = C.init_ARB_copy_image(); ret != 0 {
		return errors.New("unable to initialize ARB_copy_image")
	}
	return nil
}
func InitArbDebugOutput() error {
	var ret C.int
	if ret = C.init_ARB_debug_output(); ret != 0 {
		return errors.New("unable to initialize ARB_debug_output")
	}
	return nil
}
func InitArbDrawBuffers() error {
	var ret C.int
	if ret = C.init_ARB_draw_buffers(); ret != 0 {
		return errors.New("unable to initialize ARB_draw_buffers")
	}
	return nil
}
func InitArbDrawBuffersBlend() error {
	var ret C.int
	if ret = C.init_ARB_draw_buffers_blend(); ret != 0 {
		return errors.New("unable to initialize ARB_draw_buffers_blend")
	}
	return nil
}
func InitArbDrawElementsBaseVertex() error {
	var ret C.int
	if ret = C.init_ARB_draw_elements_base_vertex(); ret != 0 {
		return errors.New("unable to initialize ARB_draw_elements_base_vertex")
	}
	return nil
}
func InitArbDrawIndirect() error {
	var ret C.int
	if ret = C.init_ARB_draw_indirect(); ret != 0 {
		return errors.New("unable to initialize ARB_draw_indirect")
	}
	return nil
}
func InitArbDrawInstanced() error {
	var ret C.int
	if ret = C.init_ARB_draw_instanced(); ret != 0 {
		return errors.New("unable to initialize ARB_draw_instanced")
	}
	return nil
}
func InitArbFramebufferNoAttachments() error {
	var ret C.int
	if ret = C.init_ARB_framebuffer_no_attachments(); ret != 0 {
		return errors.New("unable to initialize ARB_framebuffer_no_attachments")
	}
	return nil
}
func InitArbFramebufferObject() error {
	var ret C.int
	if ret = C.init_ARB_framebuffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_framebuffer_object")
	}
	return nil
}
func InitArbGeometryShader4() error {
	var ret C.int
	if ret = C.init_ARB_geometry_shader4(); ret != 0 {
		return errors.New("unable to initialize ARB_geometry_shader4")
	}
	return nil
}
func InitArbGetProgramBinary() error {
	var ret C.int
	if ret = C.init_ARB_get_program_binary(); ret != 0 {
		return errors.New("unable to initialize ARB_get_program_binary")
	}
	return nil
}
func InitArbGpuShaderFp64() error {
	var ret C.int
	if ret = C.init_ARB_gpu_shader_fp64(); ret != 0 {
		return errors.New("unable to initialize ARB_gpu_shader_fp64")
	}
	return nil
}
func InitArbInstancedArrays() error {
	var ret C.int
	if ret = C.init_ARB_instanced_arrays(); ret != 0 {
		return errors.New("unable to initialize ARB_instanced_arrays")
	}
	return nil
}
func InitArbInternalformatQuery() error {
	var ret C.int
	if ret = C.init_ARB_internalformat_query(); ret != 0 {
		return errors.New("unable to initialize ARB_internalformat_query")
	}
	return nil
}
func InitArbInternalformatQuery2() error {
	var ret C.int
	if ret = C.init_ARB_internalformat_query2(); ret != 0 {
		return errors.New("unable to initialize ARB_internalformat_query2")
	}
	return nil
}
func InitArbInvalidateSubdata() error {
	var ret C.int
	if ret = C.init_ARB_invalidate_subdata(); ret != 0 {
		return errors.New("unable to initialize ARB_invalidate_subdata")
	}
	return nil
}
func InitArbMapBufferRange() error {
	var ret C.int
	if ret = C.init_ARB_map_buffer_range(); ret != 0 {
		return errors.New("unable to initialize ARB_map_buffer_range")
	}
	return nil
}
func InitArbMatrixPalette() error {
	var ret C.int
	if ret = C.init_ARB_matrix_palette(); ret != 0 {
		return errors.New("unable to initialize ARB_matrix_palette")
	}
	return nil
}
func InitArbMultiDrawIndirect() error {
	var ret C.int
	if ret = C.init_ARB_multi_draw_indirect(); ret != 0 {
		return errors.New("unable to initialize ARB_multi_draw_indirect")
	}
	return nil
}
func InitArbMultisample() error {
	var ret C.int
	if ret = C.init_ARB_multisample(); ret != 0 {
		return errors.New("unable to initialize ARB_multisample")
	}
	return nil
}
func InitArbMultitexture() error {
	var ret C.int
	if ret = C.init_ARB_multitexture(); ret != 0 {
		return errors.New("unable to initialize ARB_multitexture")
	}
	return nil
}
func InitArbOcclusionQuery() error {
	var ret C.int
	if ret = C.init_ARB_occlusion_query(); ret != 0 {
		return errors.New("unable to initialize ARB_occlusion_query")
	}
	return nil
}
func InitArbPointParameters() error {
	var ret C.int
	if ret = C.init_ARB_point_parameters(); ret != 0 {
		return errors.New("unable to initialize ARB_point_parameters")
	}
	return nil
}
func InitArbProgramInterfaceQuery() error {
	var ret C.int
	if ret = C.init_ARB_program_interface_query(); ret != 0 {
		return errors.New("unable to initialize ARB_program_interface_query")
	}
	return nil
}
func InitArbProvokingVertex() error {
	var ret C.int
	if ret = C.init_ARB_provoking_vertex(); ret != 0 {
		return errors.New("unable to initialize ARB_provoking_vertex")
	}
	return nil
}
func InitArbRobustness() error {
	var ret C.int
	if ret = C.init_ARB_robustness(); ret != 0 {
		return errors.New("unable to initialize ARB_robustness")
	}
	return nil
}
func InitArbSampleShading() error {
	var ret C.int
	if ret = C.init_ARB_sample_shading(); ret != 0 {
		return errors.New("unable to initialize ARB_sample_shading")
	}
	return nil
}
func InitArbSamplerObjects() error {
	var ret C.int
	if ret = C.init_ARB_sampler_objects(); ret != 0 {
		return errors.New("unable to initialize ARB_sampler_objects")
	}
	return nil
}
func InitArbSeparateShaderObjects() error {
	var ret C.int
	if ret = C.init_ARB_separate_shader_objects(); ret != 0 {
		return errors.New("unable to initialize ARB_separate_shader_objects")
	}
	return nil
}
func InitArbShaderAtomicCounters() error {
	var ret C.int
	if ret = C.init_ARB_shader_atomic_counters(); ret != 0 {
		return errors.New("unable to initialize ARB_shader_atomic_counters")
	}
	return nil
}
func InitArbShaderImageLoadStore() error {
	var ret C.int
	if ret = C.init_ARB_shader_image_load_store(); ret != 0 {
		return errors.New("unable to initialize ARB_shader_image_load_store")
	}
	return nil
}
func InitArbShaderObjects() error {
	var ret C.int
	if ret = C.init_ARB_shader_objects(); ret != 0 {
		return errors.New("unable to initialize ARB_shader_objects")
	}
	return nil
}
func InitArbShaderStorageBufferObject() error {
	var ret C.int
	if ret = C.init_ARB_shader_storage_buffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_shader_storage_buffer_object")
	}
	return nil
}
func InitArbShaderSubroutine() error {
	var ret C.int
	if ret = C.init_ARB_shader_subroutine(); ret != 0 {
		return errors.New("unable to initialize ARB_shader_subroutine")
	}
	return nil
}
func InitArbShadingLanguageInclude() error {
	var ret C.int
	if ret = C.init_ARB_shading_language_include(); ret != 0 {
		return errors.New("unable to initialize ARB_shading_language_include")
	}
	return nil
}
func InitArbSync() error {
	var ret C.int
	if ret = C.init_ARB_sync(); ret != 0 {
		return errors.New("unable to initialize ARB_sync")
	}
	return nil
}
func InitArbTessellationShader() error {
	var ret C.int
	if ret = C.init_ARB_tessellation_shader(); ret != 0 {
		return errors.New("unable to initialize ARB_tessellation_shader")
	}
	return nil
}
func InitArbTextureBufferObject() error {
	var ret C.int
	if ret = C.init_ARB_texture_buffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_buffer_object")
	}
	return nil
}
func InitArbTextureBufferRange() error {
	var ret C.int
	if ret = C.init_ARB_texture_buffer_range(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_buffer_range")
	}
	return nil
}
func InitArbTextureCompression() error {
	var ret C.int
	if ret = C.init_ARB_texture_compression(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_compression")
	}
	return nil
}
func InitArbTextureMultisample() error {
	var ret C.int
	if ret = C.init_ARB_texture_multisample(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_multisample")
	}
	return nil
}
func InitArbTextureStorage() error {
	var ret C.int
	if ret = C.init_ARB_texture_storage(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_storage")
	}
	return nil
}
func InitArbTextureStorageMultisample() error {
	var ret C.int
	if ret = C.init_ARB_texture_storage_multisample(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_storage_multisample")
	}
	return nil
}
func InitArbTextureView() error {
	var ret C.int
	if ret = C.init_ARB_texture_view(); ret != 0 {
		return errors.New("unable to initialize ARB_texture_view")
	}
	return nil
}
func InitArbTimerQuery() error {
	var ret C.int
	if ret = C.init_ARB_timer_query(); ret != 0 {
		return errors.New("unable to initialize ARB_timer_query")
	}
	return nil
}
func InitArbTransformFeedback2() error {
	var ret C.int
	if ret = C.init_ARB_transform_feedback2(); ret != 0 {
		return errors.New("unable to initialize ARB_transform_feedback2")
	}
	return nil
}
func InitArbTransformFeedback3() error {
	var ret C.int
	if ret = C.init_ARB_transform_feedback3(); ret != 0 {
		return errors.New("unable to initialize ARB_transform_feedback3")
	}
	return nil
}
func InitArbTransformFeedbackInstanced() error {
	var ret C.int
	if ret = C.init_ARB_transform_feedback_instanced(); ret != 0 {
		return errors.New("unable to initialize ARB_transform_feedback_instanced")
	}
	return nil
}
func InitArbTransposeMatrix() error {
	var ret C.int
	if ret = C.init_ARB_transpose_matrix(); ret != 0 {
		return errors.New("unable to initialize ARB_transpose_matrix")
	}
	return nil
}
func InitArbUniformBufferObject() error {
	var ret C.int
	if ret = C.init_ARB_uniform_buffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_uniform_buffer_object")
	}
	return nil
}
func InitArbVertexArrayObject() error {
	var ret C.int
	if ret = C.init_ARB_vertex_array_object(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_array_object")
	}
	return nil
}
func InitArbVertexAttrib64bit() error {
	var ret C.int
	if ret = C.init_ARB_vertex_attrib_64bit(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_attrib_64bit")
	}
	return nil
}
func InitArbVertexAttribBinding() error {
	var ret C.int
	if ret = C.init_ARB_vertex_attrib_binding(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_attrib_binding")
	}
	return nil
}
func InitArbVertexBlend() error {
	var ret C.int
	if ret = C.init_ARB_vertex_blend(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_blend")
	}
	return nil
}
func InitArbVertexBufferObject() error {
	var ret C.int
	if ret = C.init_ARB_vertex_buffer_object(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_buffer_object")
	}
	return nil
}
func InitArbVertexProgram() error {
	var ret C.int
	if ret = C.init_ARB_vertex_program(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_program")
	}
	return nil
}
func InitArbVertexShader() error {
	var ret C.int
	if ret = C.init_ARB_vertex_shader(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_shader")
	}
	return nil
}
func InitArbVertexType2101010Rev() error {
	var ret C.int
	if ret = C.init_ARB_vertex_type_2_10_10_10_rev(); ret != 0 {
		return errors.New("unable to initialize ARB_vertex_type_2_10_10_10_rev")
	}
	return nil
}
func InitArbViewportArray() error {
	var ret C.int
	if ret = C.init_ARB_viewport_array(); ret != 0 {
		return errors.New("unable to initialize ARB_viewport_array")
	}
	return nil
}
func InitArbWindowPos() error {
	var ret C.int
	if ret = C.init_ARB_window_pos(); ret != 0 {
		return errors.New("unable to initialize ARB_window_pos")
	}
	return nil
}
// EOF