gl.c

#include <stdio.h>

#include "gl.h"

#define LEAK_COUNTER

#ifdef LEAK_COUNTER
int leak_samplers = 0;
int leak_textures = 0;
int leak_framebuffers = 0;
int leak_renderbuffers = 0;
int leak_transformfeedbacks = 0;
int leak_buffers = 0;
int leak_vertexarrays = 0;
int leak_queries = 0;
int leak_shaderprograms = 0;
int leak_programs = 0;
int leak_shaders = 0;
int leak_programpipelines = 0;
#endif

void DumpLeakCounter()
{
	const int* counter[]=
	{
		&leak_samplers, (const int*)"samplers",
		&leak_textures, (const int*)"textures",
		&leak_framebuffers, (const int*)"framebuffers",
		&leak_renderbuffers, (const int*)"renderbuffers",
		&leak_transformfeedbacks, (const int*)"transformfeedbacks",
		&leak_buffers, (const int*)"buffers",
		&leak_vertexarrays, (const int*)"vertexarrays",
		&leak_queries, (const int*)"queries",
		&leak_shaderprograms, (const int*)"shaderprograms",
		&leak_programs, (const int*)"programs",
		&leak_shaders, (const int*)"shaders",
		&leak_programpipelines, (const int*)"programpipelines",
		0,0
	};

	int i = 0;
	while (counter[i])
	{
		printf("%s: %d\n", (const char*)counter[i + 1], *(counter[i]));
		i += 2;
	}
}



/* This file was auto-generated by Galogen */
#include <assert.h>
#if defined(_WIN32)
void* GalogenGetProcAddress(const char *name) {
  static HMODULE opengl32module = NULL;
  static PROC(WINAPI *wgl_get_proc_address)(LPCSTR name) = NULL;
  if (!wgl_get_proc_address) {
    if (!opengl32module) {
      opengl32module = LoadLibraryA("opengl32.dll");
    }
    wgl_get_proc_address = (PROC(WINAPI*)(LPCSTR))GetProcAddress(opengl32module, "wglGetProcAddress");
    assert(wgl_get_proc_address);
  }
  void *ptr = (void *)wgl_get_proc_address(name);
  if(ptr == 0 || (ptr == (void*)1) || (ptr == (void*)2) || (ptr == (void*)3) ||
     (ptr == (void*)-1) ) {
    if (opengl32module == NULL) {
      opengl32module = LoadLibraryA("opengl32.dll");
      assert(opengl32module);
    }
    ptr = (void *)GetProcAddress(opengl32module, name);
  }
  return ptr;
}

#elif defined(__APPLE__)
#include <dlfcn.h>

static void* GalogenGetProcAddress (const char *name)
{
  static void* lib = NULL;
  if (NULL == lib)
    lib = dlopen(
      "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL",
      RTLD_LAZY);
  return lib ? dlsym(lib, name) : NULL;
}
#elif defined(__ANDROID__)
#include <dlfcn.h>
#if GALOGEN_API_VER_MAJ == 3
#define GALOGEN_GLES_LIB "libGLESv3.so"
#elif GALOGEN_API_VER_MAJ == 2
#define GALOGEN_GLES_LIB "libGLESv2.so"
#else
#define GALOGEN_GLES_LIB "libGLESv1_CM.so"
#endif
static void* GalogenGetProcAddress(const char *name)
{
  static void* lib = NULL;
  if (NULL == lib) {
    lib = dlopen(GALOGEN_GLES_LIB, RTLD_LAZY);
    assert(lib);
  }
  return lib ? dlsym(lib, name) : NULL;
}

#else

#include <GL/glx.h>
#define GalogenGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)

#endif


static void  GL_APIENTRY _impl_glTextureBarrier () {
  _glptr_glTextureBarrier = (PFN_glTextureBarrier)GalogenGetProcAddress("glTextureBarrier");
   _glptr_glTextureBarrier();
}
PFN_glTextureBarrier _glptr_glTextureBarrier = _impl_glTextureBarrier;

static void  GL_APIENTRY _impl_glReadnPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) {
  _glptr_glReadnPixels = (PFN_glReadnPixels)GalogenGetProcAddress("glReadnPixels");
   _glptr_glReadnPixels(x, y, width, height, format, type, bufSize, data);
}
PFN_glReadnPixels _glptr_glReadnPixels = _impl_glReadnPixels;

static void  GL_APIENTRY _impl_glGetnUniformuiv (GLuint program, GLint location, GLsizei bufSize, GLuint * params) {
  _glptr_glGetnUniformuiv = (PFN_glGetnUniformuiv)GalogenGetProcAddress("glGetnUniformuiv");
   _glptr_glGetnUniformuiv(program, location, bufSize, params);
}
PFN_glGetnUniformuiv _glptr_glGetnUniformuiv = _impl_glGetnUniformuiv;

static void  GL_APIENTRY _impl_glGetnUniformfv (GLuint program, GLint location, GLsizei bufSize, GLfloat * params) {
  _glptr_glGetnUniformfv = (PFN_glGetnUniformfv)GalogenGetProcAddress("glGetnUniformfv");
   _glptr_glGetnUniformfv(program, location, bufSize, params);
}
PFN_glGetnUniformfv _glptr_glGetnUniformfv = _impl_glGetnUniformfv;

static void  GL_APIENTRY _impl_glGetnCompressedTexImage (GLenum target, GLint lod, GLsizei bufSize, void * pixels) {
  _glptr_glGetnCompressedTexImage = (PFN_glGetnCompressedTexImage)GalogenGetProcAddress("glGetnCompressedTexImage");
   _glptr_glGetnCompressedTexImage(target, lod, bufSize, pixels);
}
PFN_glGetnCompressedTexImage _glptr_glGetnCompressedTexImage = _impl_glGetnCompressedTexImage;

static void  GL_APIENTRY _impl_glGetCompressedTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels) {
  _glptr_glGetCompressedTextureSubImage = (PFN_glGetCompressedTextureSubImage)GalogenGetProcAddress("glGetCompressedTextureSubImage");
   _glptr_glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
}
PFN_glGetCompressedTextureSubImage _glptr_glGetCompressedTextureSubImage = _impl_glGetCompressedTextureSubImage;

static void  GL_APIENTRY _impl_glMemoryBarrierByRegion (GLbitfield barriers) {
  _glptr_glMemoryBarrierByRegion = (PFN_glMemoryBarrierByRegion)GalogenGetProcAddress("glMemoryBarrierByRegion");
   _glptr_glMemoryBarrierByRegion(barriers);
}
PFN_glMemoryBarrierByRegion _glptr_glMemoryBarrierByRegion = _impl_glMemoryBarrierByRegion;

static void  GL_APIENTRY _impl_glGetQueryBufferObjectuiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
  _glptr_glGetQueryBufferObjectuiv = (PFN_glGetQueryBufferObjectuiv)GalogenGetProcAddress("glGetQueryBufferObjectuiv");
   _glptr_glGetQueryBufferObjectuiv(id, buffer, pname, offset);
}
PFN_glGetQueryBufferObjectuiv _glptr_glGetQueryBufferObjectuiv = _impl_glGetQueryBufferObjectuiv;

static void  GL_APIENTRY _impl_glGetQueryBufferObjectui64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
  _glptr_glGetQueryBufferObjectui64v = (PFN_glGetQueryBufferObjectui64v)GalogenGetProcAddress("glGetQueryBufferObjectui64v");
   _glptr_glGetQueryBufferObjectui64v(id, buffer, pname, offset);
}
PFN_glGetQueryBufferObjectui64v _glptr_glGetQueryBufferObjectui64v = _impl_glGetQueryBufferObjectui64v;

static void  GL_APIENTRY _impl_glCreateSamplers (GLsizei n, GLuint * samplers) {
#ifdef LEAK_COUNTER
	leak_samplers += n;
	PFN_glCreateSamplers
#endif
  _glptr_glCreateSamplers = (PFN_glCreateSamplers)GalogenGetProcAddress("glCreateSamplers");
   _glptr_glCreateSamplers(n, samplers);
}
PFN_glCreateSamplers _glptr_glCreateSamplers = _impl_glCreateSamplers;

static void  GL_APIENTRY _impl_glGetVertexArrayIndexed64iv (GLuint vaobj, GLuint index, GLenum pname, GLint64 * param) {
  _glptr_glGetVertexArrayIndexed64iv = (PFN_glGetVertexArrayIndexed64iv)GalogenGetProcAddress("glGetVertexArrayIndexed64iv");
   _glptr_glGetVertexArrayIndexed64iv(vaobj, index, pname, param);
}
PFN_glGetVertexArrayIndexed64iv _glptr_glGetVertexArrayIndexed64iv = _impl_glGetVertexArrayIndexed64iv;

static void  GL_APIENTRY _impl_glGetVertexArrayIndexediv (GLuint vaobj, GLuint index, GLenum pname, GLint * param) {
  _glptr_glGetVertexArrayIndexediv = (PFN_glGetVertexArrayIndexediv)GalogenGetProcAddress("glGetVertexArrayIndexediv");
   _glptr_glGetVertexArrayIndexediv(vaobj, index, pname, param);
}
PFN_glGetVertexArrayIndexediv _glptr_glGetVertexArrayIndexediv = _impl_glGetVertexArrayIndexediv;

static void  GL_APIENTRY _impl_glGetVertexArrayiv (GLuint vaobj, GLenum pname, GLint * param) {
  _glptr_glGetVertexArrayiv = (PFN_glGetVertexArrayiv)GalogenGetProcAddress("glGetVertexArrayiv");
   _glptr_glGetVertexArrayiv(vaobj, pname, param);
}
PFN_glGetVertexArrayiv _glptr_glGetVertexArrayiv = _impl_glGetVertexArrayiv;

static void  GL_APIENTRY _impl_glVertexArrayBindingDivisor (GLuint vaobj, GLuint bindingindex, GLuint divisor) {
  _glptr_glVertexArrayBindingDivisor = (PFN_glVertexArrayBindingDivisor)GalogenGetProcAddress("glVertexArrayBindingDivisor");
   _glptr_glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}
PFN_glVertexArrayBindingDivisor _glptr_glVertexArrayBindingDivisor = _impl_glVertexArrayBindingDivisor;

static void  GL_APIENTRY _impl_glVertexArrayAttribIFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
  _glptr_glVertexArrayAttribIFormat = (PFN_glVertexArrayAttribIFormat)GalogenGetProcAddress("glVertexArrayAttribIFormat");
   _glptr_glVertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
}
PFN_glVertexArrayAttribIFormat _glptr_glVertexArrayAttribIFormat = _impl_glVertexArrayAttribIFormat;

static void  GL_APIENTRY _impl_glVertexArrayElementBuffer (GLuint vaobj, GLuint buffer) {
  _glptr_glVertexArrayElementBuffer = (PFN_glVertexArrayElementBuffer)GalogenGetProcAddress("glVertexArrayElementBuffer");
   _glptr_glVertexArrayElementBuffer(vaobj, buffer);
}
PFN_glVertexArrayElementBuffer _glptr_glVertexArrayElementBuffer = _impl_glVertexArrayElementBuffer;

static void  GL_APIENTRY _impl_glEnableVertexArrayAttrib (GLuint vaobj, GLuint index) {
  _glptr_glEnableVertexArrayAttrib = (PFN_glEnableVertexArrayAttrib)GalogenGetProcAddress("glEnableVertexArrayAttrib");
   _glptr_glEnableVertexArrayAttrib(vaobj, index);
}
PFN_glEnableVertexArrayAttrib _glptr_glEnableVertexArrayAttrib = _impl_glEnableVertexArrayAttrib;

static void  GL_APIENTRY _impl_glDisableVertexArrayAttrib (GLuint vaobj, GLuint index) {
  _glptr_glDisableVertexArrayAttrib = (PFN_glDisableVertexArrayAttrib)GalogenGetProcAddress("glDisableVertexArrayAttrib");
   _glptr_glDisableVertexArrayAttrib(vaobj, index);
}
PFN_glDisableVertexArrayAttrib _glptr_glDisableVertexArrayAttrib = _impl_glDisableVertexArrayAttrib;

static void  GL_APIENTRY _impl_glGetTextureParameteriv (GLuint texture, GLenum pname, GLint * params) {
  _glptr_glGetTextureParameteriv = (PFN_glGetTextureParameteriv)GalogenGetProcAddress("glGetTextureParameteriv");
   _glptr_glGetTextureParameteriv(texture, pname, params);
}
PFN_glGetTextureParameteriv _glptr_glGetTextureParameteriv = _impl_glGetTextureParameteriv;

static void  GL_APIENTRY _impl_glGetnUniformdv (GLuint program, GLint location, GLsizei bufSize, GLdouble * params) {
  _glptr_glGetnUniformdv = (PFN_glGetnUniformdv)GalogenGetProcAddress("glGetnUniformdv");
   _glptr_glGetnUniformdv(program, location, bufSize, params);
}
PFN_glGetnUniformdv _glptr_glGetnUniformdv = _impl_glGetnUniformdv;

static void  GL_APIENTRY _impl_glGetTextureParameterIuiv (GLuint texture, GLenum pname, GLuint * params) {
  _glptr_glGetTextureParameterIuiv = (PFN_glGetTextureParameterIuiv)GalogenGetProcAddress("glGetTextureParameterIuiv");
   _glptr_glGetTextureParameterIuiv(texture, pname, params);
}
PFN_glGetTextureParameterIuiv _glptr_glGetTextureParameterIuiv = _impl_glGetTextureParameterIuiv;

static void  GL_APIENTRY _impl_glGetTextureLevelParameterfv (GLuint texture, GLint level, GLenum pname, GLfloat * params) {
  _glptr_glGetTextureLevelParameterfv = (PFN_glGetTextureLevelParameterfv)GalogenGetProcAddress("glGetTextureLevelParameterfv");
   _glptr_glGetTextureLevelParameterfv(texture, level, pname, params);
}
PFN_glGetTextureLevelParameterfv _glptr_glGetTextureLevelParameterfv = _impl_glGetTextureLevelParameterfv;

static void  GL_APIENTRY _impl_glGetTextureImage (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels) {
  _glptr_glGetTextureImage = (PFN_glGetTextureImage)GalogenGetProcAddress("glGetTextureImage");
   _glptr_glGetTextureImage(texture, level, format, type, bufSize, pixels);
}
PFN_glGetTextureImage _glptr_glGetTextureImage = _impl_glGetTextureImage;

static void  GL_APIENTRY _impl_glBindTextureUnit (GLuint unit, GLuint texture) {
  _glptr_glBindTextureUnit = (PFN_glBindTextureUnit)GalogenGetProcAddress("glBindTextureUnit");
   _glptr_glBindTextureUnit(unit, texture);
}
PFN_glBindTextureUnit _glptr_glBindTextureUnit = _impl_glBindTextureUnit;

static void  GL_APIENTRY _impl_glGenerateTextureMipmap (GLuint texture) {
  _glptr_glGenerateTextureMipmap = (PFN_glGenerateTextureMipmap)GalogenGetProcAddress("glGenerateTextureMipmap");
   _glptr_glGenerateTextureMipmap(texture);
}
PFN_glGenerateTextureMipmap _glptr_glGenerateTextureMipmap = _impl_glGenerateTextureMipmap;

static void  GL_APIENTRY _impl_glTextureParameterIuiv (GLuint texture, GLenum pname, const GLuint * params) {
  _glptr_glTextureParameterIuiv = (PFN_glTextureParameterIuiv)GalogenGetProcAddress("glTextureParameterIuiv");
   _glptr_glTextureParameterIuiv(texture, pname, params);
}
PFN_glTextureParameterIuiv _glptr_glTextureParameterIuiv = _impl_glTextureParameterIuiv;

static void  GL_APIENTRY _impl_glTextureParameterfv (GLuint texture, GLenum pname, const GLfloat * param) {
  _glptr_glTextureParameterfv = (PFN_glTextureParameterfv)GalogenGetProcAddress("glTextureParameterfv");
   _glptr_glTextureParameterfv(texture, pname, param);
}
PFN_glTextureParameterfv _glptr_glTextureParameterfv = _impl_glTextureParameterfv;

static void  GL_APIENTRY _impl_glCopyTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glCopyTextureSubImage3D = (PFN_glCopyTextureSubImage3D)GalogenGetProcAddress("glCopyTextureSubImage3D");
   _glptr_glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}
PFN_glCopyTextureSubImage3D _glptr_glCopyTextureSubImage3D = _impl_glCopyTextureSubImage3D;

static void  GL_APIENTRY _impl_glCopyTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
  _glptr_glCopyTextureSubImage1D = (PFN_glCopyTextureSubImage1D)GalogenGetProcAddress("glCopyTextureSubImage1D");
   _glptr_glCopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}
PFN_glCopyTextureSubImage1D _glptr_glCopyTextureSubImage1D = _impl_glCopyTextureSubImage1D;

static void  GL_APIENTRY _impl_glCompressedTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTextureSubImage3D = (PFN_glCompressedTextureSubImage3D)GalogenGetProcAddress("glCompressedTextureSubImage3D");
   _glptr_glCompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
PFN_glCompressedTextureSubImage3D _glptr_glCompressedTextureSubImage3D = _impl_glCompressedTextureSubImage3D;

static void  GL_APIENTRY _impl_glCompressedTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTextureSubImage2D = (PFN_glCompressedTextureSubImage2D)GalogenGetProcAddress("glCompressedTextureSubImage2D");
   _glptr_glCompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}
PFN_glCompressedTextureSubImage2D _glptr_glCompressedTextureSubImage2D = _impl_glCompressedTextureSubImage2D;

static void  GL_APIENTRY _impl_glTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTextureSubImage3D = (PFN_glTextureSubImage3D)GalogenGetProcAddress("glTextureSubImage3D");
   _glptr_glTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
PFN_glTextureSubImage3D _glptr_glTextureSubImage3D = _impl_glTextureSubImage3D;

static void  GL_APIENTRY _impl_glTextureParameterIiv (GLuint texture, GLenum pname, const GLint * params) {
  _glptr_glTextureParameterIiv = (PFN_glTextureParameterIiv)GalogenGetProcAddress("glTextureParameterIiv");
   _glptr_glTextureParameterIiv(texture, pname, params);
}
PFN_glTextureParameterIiv _glptr_glTextureParameterIiv = _impl_glTextureParameterIiv;

static void  GL_APIENTRY _impl_glTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTextureSubImage2D = (PFN_glTextureSubImage2D)GalogenGetProcAddress("glTextureSubImage2D");
   _glptr_glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
}
PFN_glTextureSubImage2D _glptr_glTextureSubImage2D = _impl_glTextureSubImage2D;

static void  GL_APIENTRY _impl_glTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTextureSubImage1D = (PFN_glTextureSubImage1D)GalogenGetProcAddress("glTextureSubImage1D");
   _glptr_glTextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
}
PFN_glTextureSubImage1D _glptr_glTextureSubImage1D = _impl_glTextureSubImage1D;

static void  GL_APIENTRY _impl_glTextureStorage2DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
  _glptr_glTextureStorage2DMultisample = (PFN_glTextureStorage2DMultisample)GalogenGetProcAddress("glTextureStorage2DMultisample");
   _glptr_glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
}
PFN_glTextureStorage2DMultisample _glptr_glTextureStorage2DMultisample = _impl_glTextureStorage2DMultisample;

static void  GL_APIENTRY _impl_glTextureStorage3D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
  _glptr_glTextureStorage3D = (PFN_glTextureStorage3D)GalogenGetProcAddress("glTextureStorage3D");
   _glptr_glTextureStorage3D(texture, levels, internalformat, width, height, depth);
}
PFN_glTextureStorage3D _glptr_glTextureStorage3D = _impl_glTextureStorage3D;

static void  GL_APIENTRY _impl_glTextureStorage2D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glTextureStorage2D = (PFN_glTextureStorage2D)GalogenGetProcAddress("glTextureStorage2D");
   _glptr_glTextureStorage2D(texture, levels, internalformat, width, height);
}
PFN_glTextureStorage2D _glptr_glTextureStorage2D = _impl_glTextureStorage2D;

static void  GL_APIENTRY _impl_glTextureStorage1D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) {
  _glptr_glTextureStorage1D = (PFN_glTextureStorage1D)GalogenGetProcAddress("glTextureStorage1D");
   _glptr_glTextureStorage1D(texture, levels, internalformat, width);
}
PFN_glTextureStorage1D _glptr_glTextureStorage1D = _impl_glTextureStorage1D;

static void  GL_APIENTRY _impl_glTextureBuffer (GLuint texture, GLenum internalformat, GLuint buffer) {
  _glptr_glTextureBuffer = (PFN_glTextureBuffer)GalogenGetProcAddress("glTextureBuffer");
   _glptr_glTextureBuffer(texture, internalformat, buffer);
}
PFN_glTextureBuffer _glptr_glTextureBuffer = _impl_glTextureBuffer;

static void  GL_APIENTRY _impl_glCreateTextures (GLenum target, GLsizei n, GLuint * textures) {
#ifdef LEAK_COUNTER
	leak_textures += n;
	PFN_glCreateTextures
#endif
  _glptr_glCreateTextures = (PFN_glCreateTextures)GalogenGetProcAddress("glCreateTextures");
   _glptr_glCreateTextures(target, n, textures);
}
PFN_glCreateTextures _glptr_glCreateTextures = _impl_glCreateTextures;

static void  GL_APIENTRY _impl_glCreateRenderbuffers (GLsizei n, GLuint * renderbuffers) {
#ifdef LEAK_COUNTER
	leak_renderbuffers += n;
	PFN_glCreateRenderbuffers
#endif
  _glptr_glCreateRenderbuffers = (PFN_glCreateRenderbuffers)GalogenGetProcAddress("glCreateRenderbuffers");
   _glptr_glCreateRenderbuffers(n, renderbuffers);
}
PFN_glCreateRenderbuffers _glptr_glCreateRenderbuffers = _impl_glCreateRenderbuffers;

static void  GL_APIENTRY _impl_glClearNamedFramebufferfi (GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
  _glptr_glClearNamedFramebufferfi = (PFN_glClearNamedFramebufferfi)GalogenGetProcAddress("glClearNamedFramebufferfi");
   _glptr_glClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
}
PFN_glClearNamedFramebufferfi _glptr_glClearNamedFramebufferfi = _impl_glClearNamedFramebufferfi;

static void  GL_APIENTRY _impl_glClearNamedFramebufferuiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value) {
  _glptr_glClearNamedFramebufferuiv = (PFN_glClearNamedFramebufferuiv)GalogenGetProcAddress("glClearNamedFramebufferuiv");
   _glptr_glClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
}
PFN_glClearNamedFramebufferuiv _glptr_glClearNamedFramebufferuiv = _impl_glClearNamedFramebufferuiv;

static void  GL_APIENTRY _impl_glInvalidateNamedFramebufferSubData (GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glInvalidateNamedFramebufferSubData = (PFN_glInvalidateNamedFramebufferSubData)GalogenGetProcAddress("glInvalidateNamedFramebufferSubData");
   _glptr_glInvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
}
PFN_glInvalidateNamedFramebufferSubData _glptr_glInvalidateNamedFramebufferSubData = _impl_glInvalidateNamedFramebufferSubData;

static void  GL_APIENTRY _impl_glInvalidateNamedFramebufferData (GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments) {
  _glptr_glInvalidateNamedFramebufferData = (PFN_glInvalidateNamedFramebufferData)GalogenGetProcAddress("glInvalidateNamedFramebufferData");
   _glptr_glInvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
}
PFN_glInvalidateNamedFramebufferData _glptr_glInvalidateNamedFramebufferData = _impl_glInvalidateNamedFramebufferData;

static void  GL_APIENTRY _impl_glNamedFramebufferReadBuffer (GLuint framebuffer, GLenum src) {
  _glptr_glNamedFramebufferReadBuffer = (PFN_glNamedFramebufferReadBuffer)GalogenGetProcAddress("glNamedFramebufferReadBuffer");
   _glptr_glNamedFramebufferReadBuffer(framebuffer, src);
}
PFN_glNamedFramebufferReadBuffer _glptr_glNamedFramebufferReadBuffer = _impl_glNamedFramebufferReadBuffer;

static void  GL_APIENTRY _impl_glNamedFramebufferTexture (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) {
  _glptr_glNamedFramebufferTexture = (PFN_glNamedFramebufferTexture)GalogenGetProcAddress("glNamedFramebufferTexture");
   _glptr_glNamedFramebufferTexture(framebuffer, attachment, texture, level);
}
PFN_glNamedFramebufferTexture _glptr_glNamedFramebufferTexture = _impl_glNamedFramebufferTexture;

static void  GL_APIENTRY _impl_glNamedFramebufferRenderbuffer (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
  _glptr_glNamedFramebufferRenderbuffer = (PFN_glNamedFramebufferRenderbuffer)GalogenGetProcAddress("glNamedFramebufferRenderbuffer");
   _glptr_glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
}
PFN_glNamedFramebufferRenderbuffer _glptr_glNamedFramebufferRenderbuffer = _impl_glNamedFramebufferRenderbuffer;

static void  GL_APIENTRY _impl_glCreateFramebuffers (GLsizei n, GLuint * framebuffers) {
#ifdef LEAK_COUNTER
	leak_framebuffers += n;
	PFN_glCreateFramebuffers
#endif
  _glptr_glCreateFramebuffers = (PFN_glCreateFramebuffers)GalogenGetProcAddress("glCreateFramebuffers");
   _glptr_glCreateFramebuffers(n, framebuffers);
}
PFN_glCreateFramebuffers _glptr_glCreateFramebuffers = _impl_glCreateFramebuffers;

static void  GL_APIENTRY _impl_glGetNamedBufferParameteri64v (GLuint buffer, GLenum pname, GLint64 * params) {
  _glptr_glGetNamedBufferParameteri64v = (PFN_glGetNamedBufferParameteri64v)GalogenGetProcAddress("glGetNamedBufferParameteri64v");
   _glptr_glGetNamedBufferParameteri64v(buffer, pname, params);
}
PFN_glGetNamedBufferParameteri64v _glptr_glGetNamedBufferParameteri64v = _impl_glGetNamedBufferParameteri64v;

static void * GL_APIENTRY _impl_glMapNamedBuffer (GLuint buffer, GLenum access) {
  _glptr_glMapNamedBuffer = (PFN_glMapNamedBuffer)GalogenGetProcAddress("glMapNamedBuffer");
  return _glptr_glMapNamedBuffer(buffer, access);
}
PFN_glMapNamedBuffer _glptr_glMapNamedBuffer = _impl_glMapNamedBuffer;

static void  GL_APIENTRY _impl_glClearNamedBufferSubData (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) {
  _glptr_glClearNamedBufferSubData = (PFN_glClearNamedBufferSubData)GalogenGetProcAddress("glClearNamedBufferSubData");
   _glptr_glClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
}
PFN_glClearNamedBufferSubData _glptr_glClearNamedBufferSubData = _impl_glClearNamedBufferSubData;

static void  GL_APIENTRY _impl_glClearNamedBufferData (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data) {
  _glptr_glClearNamedBufferData = (PFN_glClearNamedBufferData)GalogenGetProcAddress("glClearNamedBufferData");
   _glptr_glClearNamedBufferData(buffer, internalformat, format, type, data);
}
PFN_glClearNamedBufferData _glptr_glClearNamedBufferData = _impl_glClearNamedBufferData;

static void  GL_APIENTRY _impl_glCopyNamedBufferSubData (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
  _glptr_glCopyNamedBufferSubData = (PFN_glCopyNamedBufferSubData)GalogenGetProcAddress("glCopyNamedBufferSubData");
   _glptr_glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
}
PFN_glCopyNamedBufferSubData _glptr_glCopyNamedBufferSubData = _impl_glCopyNamedBufferSubData;

static void  GL_APIENTRY _impl_glNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data) {
  _glptr_glNamedBufferSubData = (PFN_glNamedBufferSubData)GalogenGetProcAddress("glNamedBufferSubData");
   _glptr_glNamedBufferSubData(buffer, offset, size, data);
}
PFN_glNamedBufferSubData _glptr_glNamedBufferSubData = _impl_glNamedBufferSubData;

static void  GL_APIENTRY _impl_glNamedBufferData (GLuint buffer, GLsizeiptr size, const void * data, GLenum usage) {
  _glptr_glNamedBufferData = (PFN_glNamedBufferData)GalogenGetProcAddress("glNamedBufferData");
   _glptr_glNamedBufferData(buffer, size, data, usage);
}
PFN_glNamedBufferData _glptr_glNamedBufferData = _impl_glNamedBufferData;

static void  GL_APIENTRY _impl_glNamedBufferStorage (GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags) {
  _glptr_glNamedBufferStorage = (PFN_glNamedBufferStorage)GalogenGetProcAddress("glNamedBufferStorage");
   _glptr_glNamedBufferStorage(buffer, size, data, flags);
}
PFN_glNamedBufferStorage _glptr_glNamedBufferStorage = _impl_glNamedBufferStorage;

static void  GL_APIENTRY _impl_glGetTransformFeedbacki_v (GLuint xfb, GLenum pname, GLuint index, GLint * param) {
  _glptr_glGetTransformFeedbacki_v = (PFN_glGetTransformFeedbacki_v)GalogenGetProcAddress("glGetTransformFeedbacki_v");
   _glptr_glGetTransformFeedbacki_v(xfb, pname, index, param);
}
PFN_glGetTransformFeedbacki_v _glptr_glGetTransformFeedbacki_v = _impl_glGetTransformFeedbacki_v;

static void  GL_APIENTRY _impl_glTransformFeedbackBufferRange (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
  _glptr_glTransformFeedbackBufferRange = (PFN_glTransformFeedbackBufferRange)GalogenGetProcAddress("glTransformFeedbackBufferRange");
   _glptr_glTransformFeedbackBufferRange(xfb, index, buffer, offset, size);
}
PFN_glTransformFeedbackBufferRange _glptr_glTransformFeedbackBufferRange = _impl_glTransformFeedbackBufferRange;

static void  GL_APIENTRY _impl_glVertexArrayAttribLFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
  _glptr_glVertexArrayAttribLFormat = (PFN_glVertexArrayAttribLFormat)GalogenGetProcAddress("glVertexArrayAttribLFormat");
   _glptr_glVertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
}
PFN_glVertexArrayAttribLFormat _glptr_glVertexArrayAttribLFormat = _impl_glVertexArrayAttribLFormat;

static void  GL_APIENTRY _impl_glBindImageTextures (GLuint first, GLsizei count, const GLuint * textures) {
  _glptr_glBindImageTextures = (PFN_glBindImageTextures)GalogenGetProcAddress("glBindImageTextures");
   _glptr_glBindImageTextures(first, count, textures);
}
PFN_glBindImageTextures _glptr_glBindImageTextures = _impl_glBindImageTextures;

static void  GL_APIENTRY _impl_glBindSamplers (GLuint first, GLsizei count, const GLuint * samplers) {
  _glptr_glBindSamplers = (PFN_glBindSamplers)GalogenGetProcAddress("glBindSamplers");
   _glptr_glBindSamplers(first, count, samplers);
}
PFN_glBindSamplers _glptr_glBindSamplers = _impl_glBindSamplers;

static void  GL_APIENTRY _impl_glBindTextures (GLuint first, GLsizei count, const GLuint * textures) {
  _glptr_glBindTextures = (PFN_glBindTextures)GalogenGetProcAddress("glBindTextures");
   _glptr_glBindTextures(first, count, textures);
}
PFN_glBindTextures _glptr_glBindTextures = _impl_glBindTextures;

static void  GL_APIENTRY _impl_glClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void * data) {
  _glptr_glClearTexImage = (PFN_glClearTexImage)GalogenGetProcAddress("glClearTexImage");
   _glptr_glClearTexImage(texture, level, format, type, data);
}
PFN_glClearTexImage _glptr_glClearTexImage = _impl_glClearTexImage;

static void  GL_APIENTRY _impl_glGetPointerv (GLenum pname, void ** params) {
  _glptr_glGetPointerv = (PFN_glGetPointerv)GalogenGetProcAddress("glGetPointerv");
   _glptr_glGetPointerv(pname, params);
}
PFN_glGetPointerv _glptr_glGetPointerv = _impl_glGetPointerv;

static void  GL_APIENTRY _impl_glGetnUniformiv (GLuint program, GLint location, GLsizei bufSize, GLint * params) {
  _glptr_glGetnUniformiv = (PFN_glGetnUniformiv)GalogenGetProcAddress("glGetnUniformiv");
   _glptr_glGetnUniformiv(program, location, bufSize, params);
}
PFN_glGetnUniformiv _glptr_glGetnUniformiv = _impl_glGetnUniformiv;

static void  GL_APIENTRY _impl_glGetObjectPtrLabel (const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label) {
  _glptr_glGetObjectPtrLabel = (PFN_glGetObjectPtrLabel)GalogenGetProcAddress("glGetObjectPtrLabel");
   _glptr_glGetObjectPtrLabel(ptr, bufSize, length, label);
}
PFN_glGetObjectPtrLabel _glptr_glGetObjectPtrLabel = _impl_glGetObjectPtrLabel;

static void  GL_APIENTRY _impl_glGetQueryBufferObjecti64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
  _glptr_glGetQueryBufferObjecti64v = (PFN_glGetQueryBufferObjecti64v)GalogenGetProcAddress("glGetQueryBufferObjecti64v");
   _glptr_glGetQueryBufferObjecti64v(id, buffer, pname, offset);
}
PFN_glGetQueryBufferObjecti64v _glptr_glGetQueryBufferObjecti64v = _impl_glGetQueryBufferObjecti64v;

static void  GL_APIENTRY _impl_glGetTransformFeedbacki64_v (GLuint xfb, GLenum pname, GLuint index, GLint64 * param) {
  _glptr_glGetTransformFeedbacki64_v = (PFN_glGetTransformFeedbacki64_v)GalogenGetProcAddress("glGetTransformFeedbacki64_v");
   _glptr_glGetTransformFeedbacki64_v(xfb, pname, index, param);
}
PFN_glGetTransformFeedbacki64_v _glptr_glGetTransformFeedbacki64_v = _impl_glGetTransformFeedbacki64_v;

static void  GL_APIENTRY _impl_glObjectPtrLabel (const void * ptr, GLsizei length, const GLchar * label) {
  _glptr_glObjectPtrLabel = (PFN_glObjectPtrLabel)GalogenGetProcAddress("glObjectPtrLabel");
   _glptr_glObjectPtrLabel(ptr, length, label);
}
PFN_glObjectPtrLabel _glptr_glObjectPtrLabel = _impl_glObjectPtrLabel;

static void  GL_APIENTRY _impl_glPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar * message) {
  _glptr_glPushDebugGroup = (PFN_glPushDebugGroup)GalogenGetProcAddress("glPushDebugGroup");
   _glptr_glPushDebugGroup(source, id, length, message);
}
PFN_glPushDebugGroup _glptr_glPushDebugGroup = _impl_glPushDebugGroup;

static void  GL_APIENTRY _impl_glDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled) {
  _glptr_glDebugMessageControl = (PFN_glDebugMessageControl)GalogenGetProcAddress("glDebugMessageControl");
   _glptr_glDebugMessageControl(source, type, severity, count, ids, enabled);
}
PFN_glDebugMessageControl _glptr_glDebugMessageControl = _impl_glDebugMessageControl;

static void  GL_APIENTRY _impl_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex) {
  _glptr_glVertexAttribBinding = (PFN_glVertexAttribBinding)GalogenGetProcAddress("glVertexAttribBinding");
   _glptr_glVertexAttribBinding(attribindex, bindingindex);
}
PFN_glVertexAttribBinding _glptr_glVertexAttribBinding = _impl_glVertexAttribBinding;

static void  GL_APIENTRY _impl_glVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
  _glptr_glVertexAttribLFormat = (PFN_glVertexAttribLFormat)GalogenGetProcAddress("glVertexAttribLFormat");
   _glptr_glVertexAttribLFormat(attribindex, size, type, relativeoffset);
}
PFN_glVertexAttribLFormat _glptr_glVertexAttribLFormat = _impl_glVertexAttribLFormat;

static void  GL_APIENTRY _impl_glVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) {
  _glptr_glVertexAttribIFormat = (PFN_glVertexAttribIFormat)GalogenGetProcAddress("glVertexAttribIFormat");
   _glptr_glVertexAttribIFormat(attribindex, size, type, relativeoffset);
}
PFN_glVertexAttribIFormat _glptr_glVertexAttribIFormat = _impl_glVertexAttribIFormat;

static void  GL_APIENTRY _impl_glVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) {
  _glptr_glVertexAttribFormat = (PFN_glVertexAttribFormat)GalogenGetProcAddress("glVertexAttribFormat");
   _glptr_glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
}
PFN_glVertexAttribFormat _glptr_glVertexAttribFormat = _impl_glVertexAttribFormat;

static void  GL_APIENTRY _impl_glTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
  _glptr_glTexStorage2DMultisample = (PFN_glTexStorage2DMultisample)GalogenGetProcAddress("glTexStorage2DMultisample");
   _glptr_glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}
PFN_glTexStorage2DMultisample _glptr_glTexStorage2DMultisample = _impl_glTexStorage2DMultisample;

static void  GL_APIENTRY _impl_glShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) {
  _glptr_glShaderStorageBlockBinding = (PFN_glShaderStorageBlockBinding)GalogenGetProcAddress("glShaderStorageBlockBinding");
   _glptr_glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
PFN_glShaderStorageBlockBinding _glptr_glShaderStorageBlockBinding = _impl_glShaderStorageBlockBinding;

static GLint GL_APIENTRY _impl_glGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar * name) {
  _glptr_glGetProgramResourceLocationIndex = (PFN_glGetProgramResourceLocationIndex)GalogenGetProcAddress("glGetProgramResourceLocationIndex");
  return _glptr_glGetProgramResourceLocationIndex(program, programInterface, name);
}
PFN_glGetProgramResourceLocationIndex _glptr_glGetProgramResourceLocationIndex = _impl_glGetProgramResourceLocationIndex;

static void  GL_APIENTRY _impl_glGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name) {
  _glptr_glGetProgramResourceName = (PFN_glGetProgramResourceName)GalogenGetProcAddress("glGetProgramResourceName");
   _glptr_glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
}
PFN_glGetProgramResourceName _glptr_glGetProgramResourceName = _impl_glGetProgramResourceName;

static GLuint GL_APIENTRY _impl_glGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar * name) {
  _glptr_glGetProgramResourceIndex = (PFN_glGetProgramResourceIndex)GalogenGetProcAddress("glGetProgramResourceIndex");
  return _glptr_glGetProgramResourceIndex(program, programInterface, name);
}
PFN_glGetProgramResourceIndex _glptr_glGetProgramResourceIndex = _impl_glGetProgramResourceIndex;

static void  GL_APIENTRY _impl_glMultiDrawElementsIndirect (GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride) {
  _glptr_glMultiDrawElementsIndirect = (PFN_glMultiDrawElementsIndirect)GalogenGetProcAddress("glMultiDrawElementsIndirect");
   _glptr_glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
}
PFN_glMultiDrawElementsIndirect _glptr_glMultiDrawElementsIndirect = _impl_glMultiDrawElementsIndirect;

static void  GL_APIENTRY _impl_glInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glInvalidateSubFramebuffer = (PFN_glInvalidateSubFramebuffer)GalogenGetProcAddress("glInvalidateSubFramebuffer");
   _glptr_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
}
PFN_glInvalidateSubFramebuffer _glptr_glInvalidateSubFramebuffer = _impl_glInvalidateSubFramebuffer;

static void  GL_APIENTRY _impl_glInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length) {
  _glptr_glInvalidateBufferSubData = (PFN_glInvalidateBufferSubData)GalogenGetProcAddress("glInvalidateBufferSubData");
   _glptr_glInvalidateBufferSubData(buffer, offset, length);
}
PFN_glInvalidateBufferSubData _glptr_glInvalidateBufferSubData = _impl_glInvalidateBufferSubData;

static void  GL_APIENTRY _impl_glInvalidateTexImage (GLuint texture, GLint level) {
  _glptr_glInvalidateTexImage = (PFN_glInvalidateTexImage)GalogenGetProcAddress("glInvalidateTexImage");
   _glptr_glInvalidateTexImage(texture, level);
}
PFN_glInvalidateTexImage _glptr_glInvalidateTexImage = _impl_glInvalidateTexImage;

static void  GL_APIENTRY _impl_glInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) {
  _glptr_glInvalidateTexSubImage = (PFN_glInvalidateTexSubImage)GalogenGetProcAddress("glInvalidateTexSubImage");
   _glptr_glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
PFN_glInvalidateTexSubImage _glptr_glInvalidateTexSubImage = _impl_glInvalidateTexSubImage;

static void  GL_APIENTRY _impl_glGetFramebufferParameteriv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetFramebufferParameteriv = (PFN_glGetFramebufferParameteriv)GalogenGetProcAddress("glGetFramebufferParameteriv");
   _glptr_glGetFramebufferParameteriv(target, pname, params);
}
PFN_glGetFramebufferParameteriv _glptr_glGetFramebufferParameteriv = _impl_glGetFramebufferParameteriv;

static void  GL_APIENTRY _impl_glFramebufferParameteri (GLenum target, GLenum pname, GLint param) {
  _glptr_glFramebufferParameteri = (PFN_glFramebufferParameteri)GalogenGetProcAddress("glFramebufferParameteri");
   _glptr_glFramebufferParameteri(target, pname, param);
}
PFN_glFramebufferParameteri _glptr_glFramebufferParameteri = _impl_glFramebufferParameteri;

static void  GL_APIENTRY _impl_glNamedRenderbufferStorage (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glNamedRenderbufferStorage = (PFN_glNamedRenderbufferStorage)GalogenGetProcAddress("glNamedRenderbufferStorage");
   _glptr_glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}
PFN_glNamedRenderbufferStorage _glptr_glNamedRenderbufferStorage = _impl_glNamedRenderbufferStorage;

static void  GL_APIENTRY _impl_glDispatchComputeIndirect (GLintptr indirect) {
  _glptr_glDispatchComputeIndirect = (PFN_glDispatchComputeIndirect)GalogenGetProcAddress("glDispatchComputeIndirect");
   _glptr_glDispatchComputeIndirect(indirect);
}
PFN_glDispatchComputeIndirect _glptr_glDispatchComputeIndirect = _impl_glDispatchComputeIndirect;

static void  GL_APIENTRY _impl_glDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
  _glptr_glDispatchCompute = (PFN_glDispatchCompute)GalogenGetProcAddress("glDispatchCompute");
   _glptr_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
PFN_glDispatchCompute _glptr_glDispatchCompute = _impl_glDispatchCompute;

static void  GL_APIENTRY _impl_glDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) {
  _glptr_glDrawTransformFeedbackStreamInstanced = (PFN_glDrawTransformFeedbackStreamInstanced)GalogenGetProcAddress("glDrawTransformFeedbackStreamInstanced");
   _glptr_glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
PFN_glDrawTransformFeedbackStreamInstanced _glptr_glDrawTransformFeedbackStreamInstanced = _impl_glDrawTransformFeedbackStreamInstanced;

static void  GL_APIENTRY _impl_glTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glTexStorage2D = (PFN_glTexStorage2D)GalogenGetProcAddress("glTexStorage2D");
   _glptr_glTexStorage2D(target, levels, internalformat, width, height);
}
PFN_glTexStorage2D _glptr_glTexStorage2D = _impl_glTexStorage2D;

static void  GL_APIENTRY _impl_glTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) {
  _glptr_glTexStorage1D = (PFN_glTexStorage1D)GalogenGetProcAddress("glTexStorage1D");
   _glptr_glTexStorage1D(target, levels, internalformat, width);
}
PFN_glTexStorage1D _glptr_glTexStorage1D = _impl_glTexStorage1D;

static void  GL_APIENTRY _impl_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor) {
  _glptr_glVertexBindingDivisor = (PFN_glVertexBindingDivisor)GalogenGetProcAddress("glVertexBindingDivisor");
   _glptr_glVertexBindingDivisor(bindingindex, divisor);
}
PFN_glVertexBindingDivisor _glptr_glVertexBindingDivisor = _impl_glVertexBindingDivisor;

static void  GL_APIENTRY _impl_glBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
  _glptr_glBindImageTexture = (PFN_glBindImageTexture)GalogenGetProcAddress("glBindImageTexture");
   _glptr_glBindImageTexture(unit, texture, level, layered, layer, access, format);
}
PFN_glBindImageTexture _glptr_glBindImageTexture = _impl_glBindImageTexture;

static void  GL_APIENTRY _impl_glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params) {
  _glptr_glGetInternalformativ = (PFN_glGetInternalformativ)GalogenGetProcAddress("glGetInternalformativ");
   _glptr_glGetInternalformativ(target, internalformat, pname, bufSize, params);
}
PFN_glGetInternalformativ _glptr_glGetInternalformativ = _impl_glGetInternalformativ;

static void  GL_APIENTRY _impl_glDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance) {
  _glptr_glDrawElementsInstancedBaseInstance = (PFN_glDrawElementsInstancedBaseInstance)GalogenGetProcAddress("glDrawElementsInstancedBaseInstance");
   _glptr_glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
}
PFN_glDrawElementsInstancedBaseInstance _glptr_glDrawElementsInstancedBaseInstance = _impl_glDrawElementsInstancedBaseInstance;

static void  GL_APIENTRY _impl_glBufferStorage (GLenum target, GLsizeiptr size, const void * data, GLbitfield flags) {
  _glptr_glBufferStorage = (PFN_glBufferStorage)GalogenGetProcAddress("glBufferStorage");
   _glptr_glBufferStorage(target, size, data, flags);
}
PFN_glBufferStorage _glptr_glBufferStorage = _impl_glBufferStorage;

static void  GL_APIENTRY _impl_glDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) {
  _glptr_glDrawArraysInstancedBaseInstance = (PFN_glDrawArraysInstancedBaseInstance)GalogenGetProcAddress("glDrawArraysInstancedBaseInstance");
   _glptr_glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
PFN_glDrawArraysInstancedBaseInstance _glptr_glDrawArraysInstancedBaseInstance = _impl_glDrawArraysInstancedBaseInstance;

static void  GL_APIENTRY _impl_glDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble * v) {
  _glptr_glDepthRangeArrayv = (PFN_glDepthRangeArrayv)GalogenGetProcAddress("glDepthRangeArrayv");
   _glptr_glDepthRangeArrayv(first, count, v);
}
PFN_glDepthRangeArrayv _glptr_glDepthRangeArrayv = _impl_glDepthRangeArrayv;

static void  GL_APIENTRY _impl_glNamedFramebufferParameteri (GLuint framebuffer, GLenum pname, GLint param) {
  _glptr_glNamedFramebufferParameteri = (PFN_glNamedFramebufferParameteri)GalogenGetProcAddress("glNamedFramebufferParameteri");
   _glptr_glNamedFramebufferParameteri(framebuffer, pname, param);
}
PFN_glNamedFramebufferParameteri _glptr_glNamedFramebufferParameteri = _impl_glNamedFramebufferParameteri;

static void  GL_APIENTRY _impl_glScissorIndexedv (GLuint index, const GLint * v) {
  _glptr_glScissorIndexedv = (PFN_glScissorIndexedv)GalogenGetProcAddress("glScissorIndexedv");
   _glptr_glScissorIndexedv(index, v);
}
PFN_glScissorIndexedv _glptr_glScissorIndexedv = _impl_glScissorIndexedv;

static void  GL_APIENTRY _impl_glViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
  _glptr_glViewportIndexedf = (PFN_glViewportIndexedf)GalogenGetProcAddress("glViewportIndexedf");
   _glptr_glViewportIndexedf(index, x, y, w, h);
}
PFN_glViewportIndexedf _glptr_glViewportIndexedf = _impl_glViewportIndexedf;

static void  GL_APIENTRY _impl_glVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) {
  _glptr_glVertexAttribLPointer = (PFN_glVertexAttribLPointer)GalogenGetProcAddress("glVertexAttribLPointer");
   _glptr_glVertexAttribLPointer(index, size, type, stride, pointer);
}
PFN_glVertexAttribLPointer _glptr_glVertexAttribLPointer = _impl_glVertexAttribLPointer;

static void  GL_APIENTRY _impl_glVertexAttribL4dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttribL4dv = (PFN_glVertexAttribL4dv)GalogenGetProcAddress("glVertexAttribL4dv");
   _glptr_glVertexAttribL4dv(index, v);
}
PFN_glVertexAttribL4dv _glptr_glVertexAttribL4dv = _impl_glVertexAttribL4dv;

static void  GL_APIENTRY _impl_glVertexAttribL3dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttribL3dv = (PFN_glVertexAttribL3dv)GalogenGetProcAddress("glVertexAttribL3dv");
   _glptr_glVertexAttribL3dv(index, v);
}
PFN_glVertexAttribL3dv _glptr_glVertexAttribL3dv = _impl_glVertexAttribL3dv;

static void  GL_APIENTRY _impl_glVertexAttribL2dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttribL2dv = (PFN_glVertexAttribL2dv)GalogenGetProcAddress("glVertexAttribL2dv");
   _glptr_glVertexAttribL2dv(index, v);
}
PFN_glVertexAttribL2dv _glptr_glVertexAttribL2dv = _impl_glVertexAttribL2dv;

static void  GL_APIENTRY _impl_glCreateTransformFeedbacks (GLsizei n, GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_transformfeedbacks += n;
	PFN_glCreateTransformFeedbacks
#endif
  _glptr_glCreateTransformFeedbacks = (PFN_glCreateTransformFeedbacks)GalogenGetProcAddress("glCreateTransformFeedbacks");
   _glptr_glCreateTransformFeedbacks(n, ids);
}
PFN_glCreateTransformFeedbacks _glptr_glCreateTransformFeedbacks = _impl_glCreateTransformFeedbacks;

static void  GL_APIENTRY _impl_glTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
  _glptr_glTexBufferRange = (PFN_glTexBufferRange)GalogenGetProcAddress("glTexBufferRange");
   _glptr_glTexBufferRange(target, internalformat, buffer, offset, size);
}
PFN_glTexBufferRange _glptr_glTexBufferRange = _impl_glTexBufferRange;

static void  GL_APIENTRY _impl_glVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
  _glptr_glVertexAttribL4d = (PFN_glVertexAttribL4d)GalogenGetProcAddress("glVertexAttribL4d");
   _glptr_glVertexAttribL4d(index, x, y, z, w);
}
PFN_glVertexAttribL4d _glptr_glVertexAttribL4d = _impl_glVertexAttribL4d;

static void  GL_APIENTRY _impl_glVertexAttribL2d (GLuint index, GLdouble x, GLdouble y) {
  _glptr_glVertexAttribL2d = (PFN_glVertexAttribL2d)GalogenGetProcAddress("glVertexAttribL2d");
   _glptr_glVertexAttribL2d(index, x, y);
}
PFN_glVertexAttribL2d _glptr_glVertexAttribL2d = _impl_glVertexAttribL2d;

static void  GL_APIENTRY _impl_glGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
  _glptr_glGetProgramPipelineInfoLog = (PFN_glGetProgramPipelineInfoLog)GalogenGetProcAddress("glGetProgramPipelineInfoLog");
   _glptr_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}
PFN_glGetProgramPipelineInfoLog _glptr_glGetProgramPipelineInfoLog = _impl_glGetProgramPipelineInfoLog;

static void  GL_APIENTRY _impl_glValidateProgramPipeline (GLuint pipeline) {
  _glptr_glValidateProgramPipeline = (PFN_glValidateProgramPipeline)GalogenGetProcAddress("glValidateProgramPipeline");
   _glptr_glValidateProgramPipeline(pipeline);
}
PFN_glValidateProgramPipeline _glptr_glValidateProgramPipeline = _impl_glValidateProgramPipeline;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix4x3dv = (PFN_glProgramUniformMatrix4x3dv)GalogenGetProcAddress("glProgramUniformMatrix4x3dv");
   _glptr_glProgramUniformMatrix4x3dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4x3dv _glptr_glProgramUniformMatrix4x3dv = _impl_glProgramUniformMatrix4x3dv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix3x4fv = (PFN_glProgramUniformMatrix3x4fv)GalogenGetProcAddress("glProgramUniformMatrix3x4fv");
   _glptr_glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3x4fv _glptr_glProgramUniformMatrix3x4fv = _impl_glProgramUniformMatrix3x4fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix4x2fv = (PFN_glProgramUniformMatrix4x2fv)GalogenGetProcAddress("glProgramUniformMatrix4x2fv");
   _glptr_glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4x2fv _glptr_glProgramUniformMatrix4x2fv = _impl_glProgramUniformMatrix4x2fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix2x4fv = (PFN_glProgramUniformMatrix2x4fv)GalogenGetProcAddress("glProgramUniformMatrix2x4fv");
   _glptr_glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2x4fv _glptr_glProgramUniformMatrix2x4fv = _impl_glProgramUniformMatrix2x4fv;

static void  GL_APIENTRY _impl_glPopDebugGroup () {
  _glptr_glPopDebugGroup = (PFN_glPopDebugGroup)GalogenGetProcAddress("glPopDebugGroup");
   _glptr_glPopDebugGroup();
}
PFN_glPopDebugGroup _glptr_glPopDebugGroup = _impl_glPopDebugGroup;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix3x2fv = (PFN_glProgramUniformMatrix3x2fv)GalogenGetProcAddress("glProgramUniformMatrix3x2fv");
   _glptr_glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3x2fv _glptr_glProgramUniformMatrix3x2fv = _impl_glProgramUniformMatrix3x2fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix4dv = (PFN_glProgramUniformMatrix4dv)GalogenGetProcAddress("glProgramUniformMatrix4dv");
   _glptr_glProgramUniformMatrix4dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4dv _glptr_glProgramUniformMatrix4dv = _impl_glProgramUniformMatrix4dv;

static void  GL_APIENTRY _impl_glTextureParameterf (GLuint texture, GLenum pname, GLfloat param) {
  _glptr_glTextureParameterf = (PFN_glTextureParameterf)GalogenGetProcAddress("glTextureParameterf");
   _glptr_glTextureParameterf(texture, pname, param);
}
PFN_glTextureParameterf _glptr_glTextureParameterf = _impl_glTextureParameterf;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix3dv = (PFN_glProgramUniformMatrix3dv)GalogenGetProcAddress("glProgramUniformMatrix3dv");
   _glptr_glProgramUniformMatrix3dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3dv _glptr_glProgramUniformMatrix3dv = _impl_glProgramUniformMatrix3dv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix4fv = (PFN_glProgramUniformMatrix4fv)GalogenGetProcAddress("glProgramUniformMatrix4fv");
   _glptr_glProgramUniformMatrix4fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4fv _glptr_glProgramUniformMatrix4fv = _impl_glProgramUniformMatrix4fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix3fv = (PFN_glProgramUniformMatrix3fv)GalogenGetProcAddress("glProgramUniformMatrix3fv");
   _glptr_glProgramUniformMatrix3fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3fv _glptr_glProgramUniformMatrix3fv = _impl_glProgramUniformMatrix3fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix2fv = (PFN_glProgramUniformMatrix2fv)GalogenGetProcAddress("glProgramUniformMatrix2fv");
   _glptr_glProgramUniformMatrix2fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2fv _glptr_glProgramUniformMatrix2fv = _impl_glProgramUniformMatrix2fv;

static void  GL_APIENTRY _impl_glProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glProgramUniform4dv = (PFN_glProgramUniform4dv)GalogenGetProcAddress("glProgramUniform4dv");
   _glptr_glProgramUniform4dv(program, location, count, value);
}
PFN_glProgramUniform4dv _glptr_glProgramUniform4dv = _impl_glProgramUniform4dv;

static void  GL_APIENTRY _impl_glProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) {
  _glptr_glProgramUniform4d = (PFN_glProgramUniform4d)GalogenGetProcAddress("glProgramUniform4d");
   _glptr_glProgramUniform4d(program, location, v0, v1, v2, v3);
}
PFN_glProgramUniform4d _glptr_glProgramUniform4d = _impl_glProgramUniform4d;

static void  GL_APIENTRY _impl_glProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
  _glptr_glProgramUniform4f = (PFN_glProgramUniform4f)GalogenGetProcAddress("glProgramUniform4f");
   _glptr_glProgramUniform4f(program, location, v0, v1, v2, v3);
}
PFN_glProgramUniform4f _glptr_glProgramUniform4f = _impl_glProgramUniform4f;

static void  GL_APIENTRY _impl_glProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
  _glptr_glProgramUniform4i = (PFN_glProgramUniform4i)GalogenGetProcAddress("glProgramUniform4i");
   _glptr_glProgramUniform4i(program, location, v0, v1, v2, v3);
}
PFN_glProgramUniform4i _glptr_glProgramUniform4i = _impl_glProgramUniform4i;

static void  GL_APIENTRY _impl_glProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glProgramUniform3dv = (PFN_glProgramUniform3dv)GalogenGetProcAddress("glProgramUniform3dv");
   _glptr_glProgramUniform3dv(program, location, count, value);
}
PFN_glProgramUniform3dv _glptr_glProgramUniform3dv = _impl_glProgramUniform3dv;

static void  GL_APIENTRY _impl_glProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) {
  _glptr_glProgramUniform3d = (PFN_glProgramUniform3d)GalogenGetProcAddress("glProgramUniform3d");
   _glptr_glProgramUniform3d(program, location, v0, v1, v2);
}
PFN_glProgramUniform3d _glptr_glProgramUniform3d = _impl_glProgramUniform3d;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix3x4dv = (PFN_glProgramUniformMatrix3x4dv)GalogenGetProcAddress("glProgramUniformMatrix3x4dv");
   _glptr_glProgramUniformMatrix3x4dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3x4dv _glptr_glProgramUniformMatrix3x4dv = _impl_glProgramUniformMatrix3x4dv;

static void  GL_APIENTRY _impl_glProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glProgramUniform3fv = (PFN_glProgramUniform3fv)GalogenGetProcAddress("glProgramUniform3fv");
   _glptr_glProgramUniform3fv(program, location, count, value);
}
PFN_glProgramUniform3fv _glptr_glProgramUniform3fv = _impl_glProgramUniform3fv;

static void  GL_APIENTRY _impl_glProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
  _glptr_glProgramUniform3f = (PFN_glProgramUniform3f)GalogenGetProcAddress("glProgramUniform3f");
   _glptr_glProgramUniform3f(program, location, v0, v1, v2);
}
PFN_glProgramUniform3f _glptr_glProgramUniform3f = _impl_glProgramUniform3f;

static void  GL_APIENTRY _impl_glProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1) {
  _glptr_glProgramUniform2ui = (PFN_glProgramUniform2ui)GalogenGetProcAddress("glProgramUniform2ui");
   _glptr_glProgramUniform2ui(program, location, v0, v1);
}
PFN_glProgramUniform2ui _glptr_glProgramUniform2ui = _impl_glProgramUniform2ui;

static void  GL_APIENTRY _impl_glProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glProgramUniform2dv = (PFN_glProgramUniform2dv)GalogenGetProcAddress("glProgramUniform2dv");
   _glptr_glProgramUniform2dv(program, location, count, value);
}
PFN_glProgramUniform2dv _glptr_glProgramUniform2dv = _impl_glProgramUniform2dv;

static void * GL_APIENTRY _impl_glMapNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) {
  _glptr_glMapNamedBufferRange = (PFN_glMapNamedBufferRange)GalogenGetProcAddress("glMapNamedBufferRange");
  return _glptr_glMapNamedBufferRange(buffer, offset, length, access);
}
PFN_glMapNamedBufferRange _glptr_glMapNamedBufferRange = _impl_glMapNamedBufferRange;

static void  GL_APIENTRY _impl_glProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1) {
  _glptr_glProgramUniform2d = (PFN_glProgramUniform2d)GalogenGetProcAddress("glProgramUniform2d");
   _glptr_glProgramUniform2d(program, location, v0, v1);
}
PFN_glProgramUniform2d _glptr_glProgramUniform2d = _impl_glProgramUniform2d;

static void  GL_APIENTRY _impl_glProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1) {
  _glptr_glProgramUniform2f = (PFN_glProgramUniform2f)GalogenGetProcAddress("glProgramUniform2f");
   _glptr_glProgramUniform2f(program, location, v0, v1);
}
PFN_glProgramUniform2f _glptr_glProgramUniform2f = _impl_glProgramUniform2f;

static void  GL_APIENTRY _impl_glVertexArrayVertexBuffer (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
  _glptr_glVertexArrayVertexBuffer = (PFN_glVertexArrayVertexBuffer)GalogenGetProcAddress("glVertexArrayVertexBuffer");
   _glptr_glVertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
}
PFN_glVertexArrayVertexBuffer _glptr_glVertexArrayVertexBuffer = _impl_glVertexArrayVertexBuffer;

static void  GL_APIENTRY _impl_glProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1) {
  _glptr_glProgramUniform2i = (PFN_glProgramUniform2i)GalogenGetProcAddress("glProgramUniform2i");
   _glptr_glProgramUniform2i(program, location, v0, v1);
}
PFN_glProgramUniform2i _glptr_glProgramUniform2i = _impl_glProgramUniform2i;

static void  GL_APIENTRY _impl_glProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint * value) {
  _glptr_glProgramUniform1uiv = (PFN_glProgramUniform1uiv)GalogenGetProcAddress("glProgramUniform1uiv");
   _glptr_glProgramUniform1uiv(program, location, count, value);
}
PFN_glProgramUniform1uiv _glptr_glProgramUniform1uiv = _impl_glProgramUniform1uiv;

static void  GL_APIENTRY _impl_glProgramUniform1d (GLuint program, GLint location, GLdouble v0) {
  _glptr_glProgramUniform1d = (PFN_glProgramUniform1d)GalogenGetProcAddress("glProgramUniform1d");
   _glptr_glProgramUniform1d(program, location, v0);
}
PFN_glProgramUniform1d _glptr_glProgramUniform1d = _impl_glProgramUniform1d;

static void  GL_APIENTRY _impl_glProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glProgramUniform1fv = (PFN_glProgramUniform1fv)GalogenGetProcAddress("glProgramUniform1fv");
   _glptr_glProgramUniform1fv(program, location, count, value);
}
PFN_glProgramUniform1fv _glptr_glProgramUniform1fv = _impl_glProgramUniform1fv;

static void  GL_APIENTRY _impl_glProgramUniform1f (GLuint program, GLint location, GLfloat v0) {
  _glptr_glProgramUniform1f = (PFN_glProgramUniform1f)GalogenGetProcAddress("glProgramUniform1f");
   _glptr_glProgramUniform1f(program, location, v0);
}
PFN_glProgramUniform1f _glptr_glProgramUniform1f = _impl_glProgramUniform1f;

static void  GL_APIENTRY _impl_glProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint * value) {
  _glptr_glProgramUniform1iv = (PFN_glProgramUniform1iv)GalogenGetProcAddress("glProgramUniform1iv");
   _glptr_glProgramUniform1iv(program, location, count, value);
}
PFN_glProgramUniform1iv _glptr_glProgramUniform1iv = _impl_glProgramUniform1iv;

static void  GL_APIENTRY _impl_glGenProgramPipelines (GLsizei n, GLuint * pipelines) {
#ifdef LEAK_COUNTER
	leak_programpipelines += n;
	PFN_glGenProgramPipelines
#endif
  _glptr_glGenProgramPipelines = (PFN_glGenProgramPipelines)GalogenGetProcAddress("glGenProgramPipelines");
   _glptr_glGenProgramPipelines(n, pipelines);
}
PFN_glGenProgramPipelines _glptr_glGenProgramPipelines = _impl_glGenProgramPipelines;

static void  GL_APIENTRY _impl_glBindVertexBuffers (GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) {
  _glptr_glBindVertexBuffers = (PFN_glBindVertexBuffers)GalogenGetProcAddress("glBindVertexBuffers");
   _glptr_glBindVertexBuffers(first, count, buffers, offsets, strides);
}
PFN_glBindVertexBuffers _glptr_glBindVertexBuffers = _impl_glBindVertexBuffers;

static void  GL_APIENTRY _impl_glActiveShaderProgram (GLuint pipeline, GLuint program) {
  _glptr_glActiveShaderProgram = (PFN_glActiveShaderProgram)GalogenGetProcAddress("glActiveShaderProgram");
   _glptr_glActiveShaderProgram(pipeline, program);
}
PFN_glActiveShaderProgram _glptr_glActiveShaderProgram = _impl_glActiveShaderProgram;

static void  GL_APIENTRY _impl_glProgramBinary (GLuint program, GLenum binaryFormat, const void * binary, GLsizei length) {
  _glptr_glProgramBinary = (PFN_glProgramBinary)GalogenGetProcAddress("glProgramBinary");
   _glptr_glProgramBinary(program, binaryFormat, binary, length);
}
PFN_glProgramBinary _glptr_glProgramBinary = _impl_glProgramBinary;

static void  GL_APIENTRY _impl_glGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary) {
  _glptr_glGetProgramBinary = (PFN_glGetProgramBinary)GalogenGetProcAddress("glGetProgramBinary");
   _glptr_glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
}
PFN_glGetProgramBinary _glptr_glGetProgramBinary = _impl_glGetProgramBinary;

static void  GL_APIENTRY _impl_glDebugMessageCallback (GLDEBUGPROC callback, const void * userParam) {
  _glptr_glDebugMessageCallback = (PFN_glDebugMessageCallback)GalogenGetProcAddress("glDebugMessageCallback");
   _glptr_glDebugMessageCallback(callback, userParam);
}
PFN_glDebugMessageCallback _glptr_glDebugMessageCallback = _impl_glDebugMessageCallback;

static void  GL_APIENTRY _impl_glClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) {
  _glptr_glClearBufferSubData = (PFN_glClearBufferSubData)GalogenGetProcAddress("glClearBufferSubData");
   _glptr_glClearBufferSubData(target, internalformat, offset, size, format, type, data);
}
PFN_glClearBufferSubData _glptr_glClearBufferSubData = _impl_glClearBufferSubData;

static void  GL_APIENTRY _impl_glClearDepthf (GLfloat d) {
  _glptr_glClearDepthf = (PFN_glClearDepthf)GalogenGetProcAddress("glClearDepthf");
   _glptr_glClearDepthf(d);
}
PFN_glClearDepthf _glptr_glClearDepthf = _impl_glClearDepthf;

static void  GL_APIENTRY _impl_glDepthRangef (GLfloat n, GLfloat f) {
  _glptr_glDepthRangef = (PFN_glDepthRangef)GalogenGetProcAddress("glDepthRangef");
   _glptr_glDepthRangef(n, f);
}
PFN_glDepthRangef _glptr_glDepthRangef = _impl_glDepthRangef;

static void  GL_APIENTRY _impl_glShaderBinary (GLsizei count, const GLuint * shaders, GLenum binaryformat, const void * binary, GLsizei length) {
  _glptr_glShaderBinary = (PFN_glShaderBinary)GalogenGetProcAddress("glShaderBinary");
   _glptr_glShaderBinary(count, shaders, binaryformat, binary, length);
}
PFN_glShaderBinary _glptr_glShaderBinary = _impl_glShaderBinary;

static void  GL_APIENTRY _impl_glGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint * params) {
  _glptr_glGetQueryIndexediv = (PFN_glGetQueryIndexediv)GalogenGetProcAddress("glGetQueryIndexediv");
   _glptr_glGetQueryIndexediv(target, index, pname, params);
}
PFN_glGetQueryIndexediv _glptr_glGetQueryIndexediv = _impl_glGetQueryIndexediv;

static void  GL_APIENTRY _impl_glEndQueryIndexed (GLenum target, GLuint index) {
  _glptr_glEndQueryIndexed = (PFN_glEndQueryIndexed)GalogenGetProcAddress("glEndQueryIndexed");
   _glptr_glEndQueryIndexed(target, index);
}
PFN_glEndQueryIndexed _glptr_glEndQueryIndexed = _impl_glEndQueryIndexed;

static void  GL_APIENTRY _impl_glBeginQueryIndexed (GLenum target, GLuint index, GLuint id) {
  _glptr_glBeginQueryIndexed = (PFN_glBeginQueryIndexed)GalogenGetProcAddress("glBeginQueryIndexed");
   _glptr_glBeginQueryIndexed(target, index, id);
}
PFN_glBeginQueryIndexed _glptr_glBeginQueryIndexed = _impl_glBeginQueryIndexed;

static void  GL_APIENTRY _impl_glDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream) {
  _glptr_glDrawTransformFeedbackStream = (PFN_glDrawTransformFeedbackStream)GalogenGetProcAddress("glDrawTransformFeedbackStream");
   _glptr_glDrawTransformFeedbackStream(mode, id, stream);
}
PFN_glDrawTransformFeedbackStream _glptr_glDrawTransformFeedbackStream = _impl_glDrawTransformFeedbackStream;

static void  GL_APIENTRY _impl_glBindProgramPipeline (GLuint pipeline) {
  _glptr_glBindProgramPipeline = (PFN_glBindProgramPipeline)GalogenGetProcAddress("glBindProgramPipeline");
   _glptr_glBindProgramPipeline(pipeline);
}
PFN_glBindProgramPipeline _glptr_glBindProgramPipeline = _impl_glBindProgramPipeline;

static void  GL_APIENTRY _impl_glResumeTransformFeedback () {
  _glptr_glResumeTransformFeedback = (PFN_glResumeTransformFeedback)GalogenGetProcAddress("glResumeTransformFeedback");
   _glptr_glResumeTransformFeedback();
}
PFN_glResumeTransformFeedback _glptr_glResumeTransformFeedback = _impl_glResumeTransformFeedback;

static void  GL_APIENTRY _impl_glGenTransformFeedbacks (GLsizei n, GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_transformfeedbacks += n;
	PFN_glGenTransformFeedbacks
#endif

  _glptr_glGenTransformFeedbacks = (PFN_glGenTransformFeedbacks)GalogenGetProcAddress("glGenTransformFeedbacks");
   _glptr_glGenTransformFeedbacks(n, ids);
}
PFN_glGenTransformFeedbacks _glptr_glGenTransformFeedbacks = _impl_glGenTransformFeedbacks;

static void  GL_APIENTRY _impl_glBindTransformFeedback (GLenum target, GLuint id) {
  _glptr_glBindTransformFeedback = (PFN_glBindTransformFeedback)GalogenGetProcAddress("glBindTransformFeedback");
   _glptr_glBindTransformFeedback(target, id);
}
PFN_glBindTransformFeedback _glptr_glBindTransformFeedback = _impl_glBindTransformFeedback;

static void  GL_APIENTRY _impl_glGetNamedBufferPointerv (GLuint buffer, GLenum pname, void ** params) {
  _glptr_glGetNamedBufferPointerv = (PFN_glGetNamedBufferPointerv)GalogenGetProcAddress("glGetNamedBufferPointerv");
   _glptr_glGetNamedBufferPointerv(buffer, pname, params);
}
PFN_glGetNamedBufferPointerv _glptr_glGetNamedBufferPointerv = _impl_glGetNamedBufferPointerv;

static void  GL_APIENTRY _impl_glGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params) {
  _glptr_glGetInternalformati64v = (PFN_glGetInternalformati64v)GalogenGetProcAddress("glGetInternalformati64v");
   _glptr_glGetInternalformati64v(target, internalformat, pname, bufSize, params);
}
PFN_glGetInternalformati64v _glptr_glGetInternalformati64v = _impl_glGetInternalformati64v;

static void  GL_APIENTRY _impl_glPatchParameterfv (GLenum pname, const GLfloat * values) {
  _glptr_glPatchParameterfv = (PFN_glPatchParameterfv)GalogenGetProcAddress("glPatchParameterfv");
   _glptr_glPatchParameterfv(pname, values);
}
PFN_glPatchParameterfv _glptr_glPatchParameterfv = _impl_glPatchParameterfv;

static void  GL_APIENTRY _impl_glScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
  _glptr_glScissorIndexed = (PFN_glScissorIndexed)GalogenGetProcAddress("glScissorIndexed");
   _glptr_glScissorIndexed(index, left, bottom, width, height);
}
PFN_glScissorIndexed _glptr_glScissorIndexed = _impl_glScissorIndexed;

static void  GL_APIENTRY _impl_glPatchParameteri (GLenum pname, GLint value) {
  _glptr_glPatchParameteri = (PFN_glPatchParameteri)GalogenGetProcAddress("glPatchParameteri");
   _glptr_glPatchParameteri(pname, value);
}
PFN_glPatchParameteri _glptr_glPatchParameteri = _impl_glPatchParameteri;

static void  GL_APIENTRY _impl_glGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint * values) {
  _glptr_glGetProgramStageiv = (PFN_glGetProgramStageiv)GalogenGetProcAddress("glGetProgramStageiv");
   _glptr_glGetProgramStageiv(program, shadertype, pname, values);
}
PFN_glGetProgramStageiv _glptr_glGetProgramStageiv = _impl_glGetProgramStageiv;

static void  GL_APIENTRY _impl_glMemoryBarrier (GLbitfield barriers) {
  _glptr_glMemoryBarrier = (PFN_glMemoryBarrier)GalogenGetProcAddress("glMemoryBarrier");
   _glptr_glMemoryBarrier(barriers);
}
PFN_glMemoryBarrier _glptr_glMemoryBarrier = _impl_glMemoryBarrier;

static void  GL_APIENTRY _impl_glGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint * params) {
  _glptr_glGetUniformSubroutineuiv = (PFN_glGetUniformSubroutineuiv)GalogenGetProcAddress("glGetUniformSubroutineuiv");
   _glptr_glGetUniformSubroutineuiv(shadertype, location, params);
}
PFN_glGetUniformSubroutineuiv _glptr_glGetUniformSubroutineuiv = _impl_glGetUniformSubroutineuiv;

static void  GL_APIENTRY _impl_glProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint * value) {
  _glptr_glProgramUniform4iv = (PFN_glProgramUniform4iv)GalogenGetProcAddress("glProgramUniform4iv");
   _glptr_glProgramUniform4iv(program, location, count, value);
}
PFN_glProgramUniform4iv _glptr_glProgramUniform4iv = _impl_glProgramUniform4iv;

static void  GL_APIENTRY _impl_glGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name) {
  _glptr_glGetActiveSubroutineUniformName = (PFN_glGetActiveSubroutineUniformName)GalogenGetProcAddress("glGetActiveSubroutineUniformName");
   _glptr_glGetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}
PFN_glGetActiveSubroutineUniformName _glptr_glGetActiveSubroutineUniformName = _impl_glGetActiveSubroutineUniformName;

static void  GL_APIENTRY _impl_glGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values) {
  _glptr_glGetActiveSubroutineUniformiv = (PFN_glGetActiveSubroutineUniformiv)GalogenGetProcAddress("glGetActiveSubroutineUniformiv");
   _glptr_glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
}
PFN_glGetActiveSubroutineUniformiv _glptr_glGetActiveSubroutineUniformiv = _impl_glGetActiveSubroutineUniformiv;

static void  GL_APIENTRY _impl_glProgramUniform1ui (GLuint program, GLint location, GLuint v0) {
  _glptr_glProgramUniform1ui = (PFN_glProgramUniform1ui)GalogenGetProcAddress("glProgramUniform1ui");
   _glptr_glProgramUniform1ui(program, location, v0);
}
PFN_glProgramUniform1ui _glptr_glProgramUniform1ui = _impl_glProgramUniform1ui;

static GLuint GL_APIENTRY _impl_glGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar * name) {
  _glptr_glGetSubroutineIndex = (PFN_glGetSubroutineIndex)GalogenGetProcAddress("glGetSubroutineIndex");
  return _glptr_glGetSubroutineIndex(program, shadertype, name);
}
PFN_glGetSubroutineIndex _glptr_glGetSubroutineIndex = _impl_glGetSubroutineIndex;

static GLint GL_APIENTRY _impl_glGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar * name) {
  _glptr_glGetSubroutineUniformLocation = (PFN_glGetSubroutineUniformLocation)GalogenGetProcAddress("glGetSubroutineUniformLocation");
  return _glptr_glGetSubroutineUniformLocation(program, shadertype, name);
}
PFN_glGetSubroutineUniformLocation _glptr_glGetSubroutineUniformLocation = _impl_glGetSubroutineUniformLocation;

static void  GL_APIENTRY _impl_glGetUniformdv (GLuint program, GLint location, GLdouble * params) {
  _glptr_glGetUniformdv = (PFN_glGetUniformdv)GalogenGetProcAddress("glGetUniformdv");
   _glptr_glGetUniformdv(program, location, params);
}
PFN_glGetUniformdv _glptr_glGetUniformdv = _impl_glGetUniformdv;

static void  GL_APIENTRY _impl_glUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix3x4dv = (PFN_glUniformMatrix3x4dv)GalogenGetProcAddress("glUniformMatrix3x4dv");
   _glptr_glUniformMatrix3x4dv(location, count, transpose, value);
}
PFN_glUniformMatrix3x4dv _glptr_glUniformMatrix3x4dv = _impl_glUniformMatrix3x4dv;

static void  GL_APIENTRY _impl_glUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix3x2dv = (PFN_glUniformMatrix3x2dv)GalogenGetProcAddress("glUniformMatrix3x2dv");
   _glptr_glUniformMatrix3x2dv(location, count, transpose, value);
}
PFN_glUniformMatrix3x2dv _glptr_glUniformMatrix3x2dv = _impl_glUniformMatrix3x2dv;

static void  GL_APIENTRY _impl_glNamedFramebufferTextureLayer (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) {
  _glptr_glNamedFramebufferTextureLayer = (PFN_glNamedFramebufferTextureLayer)GalogenGetProcAddress("glNamedFramebufferTextureLayer");
   _glptr_glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}
PFN_glNamedFramebufferTextureLayer _glptr_glNamedFramebufferTextureLayer = _impl_glNamedFramebufferTextureLayer;

static void  GL_APIENTRY _impl_glUniform4dv (GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glUniform4dv = (PFN_glUniform4dv)GalogenGetProcAddress("glUniform4dv");
   _glptr_glUniform4dv(location, count, value);
}
PFN_glUniform4dv _glptr_glUniform4dv = _impl_glUniform4dv;

static void  GL_APIENTRY _impl_glUniform3dv (GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glUniform3dv = (PFN_glUniform3dv)GalogenGetProcAddress("glUniform3dv");
   _glptr_glUniform3dv(location, count, value);
}
PFN_glUniform3dv _glptr_glUniform3dv = _impl_glUniform3dv;

static void  GL_APIENTRY _impl_glUniform2dv (GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glUniform2dv = (PFN_glUniform2dv)GalogenGetProcAddress("glUniform2dv");
   _glptr_glUniform2dv(location, count, value);
}
PFN_glUniform2dv _glptr_glUniform2dv = _impl_glUniform2dv;

static void  GL_APIENTRY _impl_glUniform1dv (GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glUniform1dv = (PFN_glUniform1dv)GalogenGetProcAddress("glUniform1dv");
   _glptr_glUniform1dv(location, count, value);
}
PFN_glUniform1dv _glptr_glUniform1dv = _impl_glUniform1dv;

static void  GL_APIENTRY _impl_glUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
  _glptr_glUniform4d = (PFN_glUniform4d)GalogenGetProcAddress("glUniform4d");
   _glptr_glUniform4d(location, x, y, z, w);
}
PFN_glUniform4d _glptr_glUniform4d = _impl_glUniform4d;

static void  GL_APIENTRY _impl_glUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z) {
  _glptr_glUniform3d = (PFN_glUniform3d)GalogenGetProcAddress("glUniform3d");
   _glptr_glUniform3d(location, x, y, z);
}
PFN_glUniform3d _glptr_glUniform3d = _impl_glUniform3d;

static void  GL_APIENTRY _impl_glDrawArraysIndirect (GLenum mode, const void * indirect) {
  _glptr_glDrawArraysIndirect = (PFN_glDrawArraysIndirect)GalogenGetProcAddress("glDrawArraysIndirect");
   _glptr_glDrawArraysIndirect(mode, indirect);
}
PFN_glDrawArraysIndirect _glptr_glDrawArraysIndirect = _impl_glDrawArraysIndirect;

static void  GL_APIENTRY _impl_glBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
  _glptr_glBlendFuncSeparatei = (PFN_glBlendFuncSeparatei)GalogenGetProcAddress("glBlendFuncSeparatei");
   _glptr_glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
PFN_glBlendFuncSeparatei _glptr_glBlendFuncSeparatei = _impl_glBlendFuncSeparatei;

static void  GL_APIENTRY _impl_glBlendFunci (GLuint buf, GLenum src, GLenum dst) {
  _glptr_glBlendFunci = (PFN_glBlendFunci)GalogenGetProcAddress("glBlendFunci");
   _glptr_glBlendFunci(buf, src, dst);
}
PFN_glBlendFunci _glptr_glBlendFunci = _impl_glBlendFunci;

static void  GL_APIENTRY _impl_glBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha) {
  _glptr_glBlendEquationSeparatei = (PFN_glBlendEquationSeparatei)GalogenGetProcAddress("glBlendEquationSeparatei");
   _glptr_glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
PFN_glBlendEquationSeparatei _glptr_glBlendEquationSeparatei = _impl_glBlendEquationSeparatei;

static void  GL_APIENTRY _impl_glGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label) {
  _glptr_glGetObjectLabel = (PFN_glGetObjectLabel)GalogenGetProcAddress("glGetObjectLabel");
   _glptr_glGetObjectLabel(identifier, name, bufSize, length, label);
}
PFN_glGetObjectLabel _glptr_glGetObjectLabel = _impl_glGetObjectLabel;

static void  GL_APIENTRY _impl_glBlendEquationi (GLuint buf, GLenum mode) {
  _glptr_glBlendEquationi = (PFN_glBlendEquationi)GalogenGetProcAddress("glBlendEquationi");
   _glptr_glBlendEquationi(buf, mode);
}
PFN_glBlendEquationi _glptr_glBlendEquationi = _impl_glBlendEquationi;

static void  GL_APIENTRY _impl_glVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
  _glptr_glVertexAttribP4uiv = (PFN_glVertexAttribP4uiv)GalogenGetProcAddress("glVertexAttribP4uiv");
   _glptr_glVertexAttribP4uiv(index, type, normalized, value);
}
PFN_glVertexAttribP4uiv _glptr_glVertexAttribP4uiv = _impl_glVertexAttribP4uiv;

static void  GL_APIENTRY _impl_glVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
  _glptr_glVertexAttribP3uiv = (PFN_glVertexAttribP3uiv)GalogenGetProcAddress("glVertexAttribP3uiv");
   _glptr_glVertexAttribP3uiv(index, type, normalized, value);
}
PFN_glVertexAttribP3uiv _glptr_glVertexAttribP3uiv = _impl_glVertexAttribP3uiv;

static void  GL_APIENTRY _impl_glVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
  _glptr_glVertexAttribP2uiv = (PFN_glVertexAttribP2uiv)GalogenGetProcAddress("glVertexAttribP2uiv");
   _glptr_glVertexAttribP2uiv(index, type, normalized, value);
}
PFN_glVertexAttribP2uiv _glptr_glVertexAttribP2uiv = _impl_glVertexAttribP2uiv;

static void  GL_APIENTRY _impl_glVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
  _glptr_glVertexAttribP2ui = (PFN_glVertexAttribP2ui)GalogenGetProcAddress("glVertexAttribP2ui");
   _glptr_glVertexAttribP2ui(index, type, normalized, value);
}
PFN_glVertexAttribP2ui _glptr_glVertexAttribP2ui = _impl_glVertexAttribP2ui;

static void  GL_APIENTRY _impl_glProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint * value) {
  _glptr_glProgramUniform4uiv = (PFN_glProgramUniform4uiv)GalogenGetProcAddress("glProgramUniform4uiv");
   _glptr_glProgramUniform4uiv(program, location, count, value);
}
PFN_glProgramUniform4uiv _glptr_glProgramUniform4uiv = _impl_glProgramUniform4uiv;

static void  GL_APIENTRY _impl_glVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint * value) {
  _glptr_glVertexAttribP1uiv = (PFN_glVertexAttribP1uiv)GalogenGetProcAddress("glVertexAttribP1uiv");
   _glptr_glVertexAttribP1uiv(index, type, normalized, value);
}
PFN_glVertexAttribP1uiv _glptr_glVertexAttribP1uiv = _impl_glVertexAttribP1uiv;

static void  GL_APIENTRY _impl_glGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 * params) {
  _glptr_glGetQueryObjectui64v = (PFN_glGetQueryObjectui64v)GalogenGetProcAddress("glGetQueryObjectui64v");
   _glptr_glGetQueryObjectui64v(id, pname, params);
}
PFN_glGetQueryObjectui64v _glptr_glGetQueryObjectui64v = _impl_glGetQueryObjectui64v;

static GLboolean GL_APIENTRY _impl_glIsTransformFeedback (GLuint id) {
  _glptr_glIsTransformFeedback = (PFN_glIsTransformFeedback)GalogenGetProcAddress("glIsTransformFeedback");
  return _glptr_glIsTransformFeedback(id);
}
PFN_glIsTransformFeedback _glptr_glIsTransformFeedback = _impl_glIsTransformFeedback;

static void  GL_APIENTRY _impl_glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat * params) {
  _glptr_glGetSamplerParameterfv = (PFN_glGetSamplerParameterfv)GalogenGetProcAddress("glGetSamplerParameterfv");
   _glptr_glGetSamplerParameterfv(sampler, pname, params);
}
PFN_glGetSamplerParameterfv _glptr_glGetSamplerParameterfv = _impl_glGetSamplerParameterfv;

static GLboolean GL_APIENTRY _impl_glIsProgramPipeline (GLuint pipeline) {
  _glptr_glIsProgramPipeline = (PFN_glIsProgramPipeline)GalogenGetProcAddress("glIsProgramPipeline");
  return _glptr_glIsProgramPipeline(pipeline);
}
PFN_glIsProgramPipeline _glptr_glIsProgramPipeline = _impl_glIsProgramPipeline;

static void  GL_APIENTRY _impl_glSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint * param) {
  _glptr_glSamplerParameterIuiv = (PFN_glSamplerParameterIuiv)GalogenGetProcAddress("glSamplerParameterIuiv");
   _glptr_glSamplerParameterIuiv(sampler, pname, param);
}
PFN_glSamplerParameterIuiv _glptr_glSamplerParameterIuiv = _impl_glSamplerParameterIuiv;

static void  GL_APIENTRY _impl_glSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat * param) {
  _glptr_glSamplerParameterfv = (PFN_glSamplerParameterfv)GalogenGetProcAddress("glSamplerParameterfv");
   _glptr_glSamplerParameterfv(sampler, pname, param);
}
PFN_glSamplerParameterfv _glptr_glSamplerParameterfv = _impl_glSamplerParameterfv;

static void  GL_APIENTRY _impl_glDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf) {
  _glptr_glDebugMessageInsert = (PFN_glDebugMessageInsert)GalogenGetProcAddress("glDebugMessageInsert");
   _glptr_glDebugMessageInsert(source, type, id, severity, length, buf);
}
PFN_glDebugMessageInsert _glptr_glDebugMessageInsert = _impl_glDebugMessageInsert;

static void  GL_APIENTRY _impl_glSamplerParameteriv (GLuint sampler, GLenum pname, const GLint * param) {
  _glptr_glSamplerParameteriv = (PFN_glSamplerParameteriv)GalogenGetProcAddress("glSamplerParameteriv");
   _glptr_glSamplerParameteriv(sampler, pname, param);
}
PFN_glSamplerParameteriv _glptr_glSamplerParameteriv = _impl_glSamplerParameteriv;

static void  GL_APIENTRY _impl_glSamplerParameteri (GLuint sampler, GLenum pname, GLint param) {
  _glptr_glSamplerParameteri = (PFN_glSamplerParameteri)GalogenGetProcAddress("glSamplerParameteri");
   _glptr_glSamplerParameteri(sampler, pname, param);
}
PFN_glSamplerParameteri _glptr_glSamplerParameteri = _impl_glSamplerParameteri;

static void  GL_APIENTRY _impl_glBindSampler (GLuint unit, GLuint sampler) {
  _glptr_glBindSampler = (PFN_glBindSampler)GalogenGetProcAddress("glBindSampler");
   _glptr_glBindSampler(unit, sampler);
}
PFN_glBindSampler _glptr_glBindSampler = _impl_glBindSampler;

static void  GL_APIENTRY _impl_glSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param) {
  _glptr_glSamplerParameterf = (PFN_glSamplerParameterf)GalogenGetProcAddress("glSamplerParameterf");
   _glptr_glSamplerParameterf(sampler, pname, param);
}
PFN_glSamplerParameterf _glptr_glSamplerParameterf = _impl_glSamplerParameterf;

static GLboolean GL_APIENTRY _impl_glIsSampler (GLuint sampler) {
  _glptr_glIsSampler = (PFN_glIsSampler)GalogenGetProcAddress("glIsSampler");
  return _glptr_glIsSampler(sampler);
}
PFN_glIsSampler _glptr_glIsSampler = _impl_glIsSampler;

static void  GL_APIENTRY _impl_glGenSamplers (GLsizei count, GLuint * samplers) {
#ifdef LEAK_COUNTER
	leak_samplers += count;
	PFN_glGenSamplers
#endif

  _glptr_glGenSamplers = (PFN_glGenSamplers)GalogenGetProcAddress("glGenSamplers");
   _glptr_glGenSamplers(count, samplers);
}
PFN_glGenSamplers _glptr_glGenSamplers = _impl_glGenSamplers;

static void  GL_APIENTRY _impl_glGetNamedFramebufferParameteriv (GLuint framebuffer, GLenum pname, GLint * param) {
  _glptr_glGetNamedFramebufferParameteriv = (PFN_glGetNamedFramebufferParameteriv)GalogenGetProcAddress("glGetNamedFramebufferParameteriv");
   _glptr_glGetNamedFramebufferParameteriv(framebuffer, pname, param);
}
PFN_glGetNamedFramebufferParameteriv _glptr_glGetNamedFramebufferParameteriv = _impl_glGetNamedFramebufferParameteriv;

static void  GL_APIENTRY _impl_glCreateBuffers (GLsizei n, GLuint * buffers) {
#ifdef LEAK_COUNTER
	leak_buffers += n;
	PFN_glCreateBuffers
#endif
  _glptr_glCreateBuffers = (PFN_glCreateBuffers)GalogenGetProcAddress("glCreateBuffers");
   _glptr_glCreateBuffers(n, buffers);
}
PFN_glCreateBuffers _glptr_glCreateBuffers = _impl_glCreateBuffers;

static void  GL_APIENTRY _impl_glBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name) {
  _glptr_glBindFragDataLocationIndexed = (PFN_glBindFragDataLocationIndexed)GalogenGetProcAddress("glBindFragDataLocationIndexed");
   _glptr_glBindFragDataLocationIndexed(program, colorNumber, index, name);
}
PFN_glBindFragDataLocationIndexed _glptr_glBindFragDataLocationIndexed = _impl_glBindFragDataLocationIndexed;

static void  GL_APIENTRY _impl_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat * val) {
  _glptr_glGetMultisamplefv = (PFN_glGetMultisamplefv)GalogenGetProcAddress("glGetMultisamplefv");
   _glptr_glGetMultisamplefv(pname, index, val);
}
PFN_glGetMultisamplefv _glptr_glGetMultisamplefv = _impl_glGetMultisamplefv;

static void  GL_APIENTRY _impl_glGetTextureParameterfv (GLuint texture, GLenum pname, GLfloat * params) {
  _glptr_glGetTextureParameterfv = (PFN_glGetTextureParameterfv)GalogenGetProcAddress("glGetTextureParameterfv");
   _glptr_glGetTextureParameterfv(texture, pname, params);
}
PFN_glGetTextureParameterfv _glptr_glGetTextureParameterfv = _impl_glGetTextureParameterfv;

static void  GL_APIENTRY _impl_glTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
  _glptr_glTexImage3DMultisample = (PFN_glTexImage3DMultisample)GalogenGetProcAddress("glTexImage3DMultisample");
   _glptr_glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
PFN_glTexImage3DMultisample _glptr_glTexImage3DMultisample = _impl_glTexImage3DMultisample;

static void  GL_APIENTRY _impl_glFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level) {
  _glptr_glFramebufferTexture = (PFN_glFramebufferTexture)GalogenGetProcAddress("glFramebufferTexture");
   _glptr_glFramebufferTexture(target, attachment, texture, level);
}
PFN_glFramebufferTexture _glptr_glFramebufferTexture = _impl_glFramebufferTexture;

static void  GL_APIENTRY _impl_glGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 * params) {
  _glptr_glGetBufferParameteri64v = (PFN_glGetBufferParameteri64v)GalogenGetProcAddress("glGetBufferParameteri64v");
   _glptr_glGetBufferParameteri64v(target, pname, params);
}
PFN_glGetBufferParameteri64v _glptr_glGetBufferParameteri64v = _impl_glGetBufferParameteri64v;

static void  GL_APIENTRY _impl_glCreateVertexArrays (GLsizei n, GLuint * arrays) {
#ifdef LEAK_COUNTER
	leak_vertexarrays += n;
	PFN_glCreateVertexArrays
#endif
  _glptr_glCreateVertexArrays = (PFN_glCreateVertexArrays)GalogenGetProcAddress("glCreateVertexArrays");
   _glptr_glCreateVertexArrays(n, arrays);
}
PFN_glCreateVertexArrays _glptr_glCreateVertexArrays = _impl_glCreateVertexArrays;

static void  GL_APIENTRY _impl_glGetInteger64i_v (GLenum target, GLuint index, GLint64 * data) {
  _glptr_glGetInteger64i_v = (PFN_glGetInteger64i_v)GalogenGetProcAddress("glGetInteger64i_v");
   _glptr_glGetInteger64i_v(target, index, data);
}
PFN_glGetInteger64i_v _glptr_glGetInteger64i_v = _impl_glGetInteger64i_v;

static void  GL_APIENTRY _impl_glUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix2dv = (PFN_glUniformMatrix2dv)GalogenGetProcAddress("glUniformMatrix2dv");
   _glptr_glUniformMatrix2dv(location, count, transpose, value);
}
PFN_glUniformMatrix2dv _glptr_glUniformMatrix2dv = _impl_glUniformMatrix2dv;

static void  GL_APIENTRY _impl_glWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
  _glptr_glWaitSync = (PFN_glWaitSync)GalogenGetProcAddress("glWaitSync");
   _glptr_glWaitSync(sync, flags, timeout);
}
PFN_glWaitSync _glptr_glWaitSync = _impl_glWaitSync;

static GLboolean GL_APIENTRY _impl_glIsSync (GLsync sync) {
  _glptr_glIsSync = (PFN_glIsSync)GalogenGetProcAddress("glIsSync");
  return _glptr_glIsSync(sync);
}
PFN_glIsSync _glptr_glIsSync = _impl_glIsSync;

static GLsync GL_APIENTRY _impl_glFenceSync (GLenum condition, GLbitfield flags) {
  _glptr_glFenceSync = (PFN_glFenceSync)GalogenGetProcAddress("glFenceSync");
  return _glptr_glFenceSync(condition, flags);
}
PFN_glFenceSync _glptr_glFenceSync = _impl_glFenceSync;

static void  GL_APIENTRY _impl_glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex) {
  _glptr_glMultiDrawElementsBaseVertex = (PFN_glMultiDrawElementsBaseVertex)GalogenGetProcAddress("glMultiDrawElementsBaseVertex");
   _glptr_glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}
PFN_glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex = _impl_glMultiDrawElementsBaseVertex;

static void  GL_APIENTRY _impl_glProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
  _glptr_glProgramUniform4ui = (PFN_glProgramUniform4ui)GalogenGetProcAddress("glProgramUniform4ui");
   _glptr_glProgramUniform4ui(program, location, v0, v1, v2, v3);
}
PFN_glProgramUniform4ui _glptr_glProgramUniform4ui = _impl_glProgramUniform4ui;

static void  GL_APIENTRY _impl_glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex) {
  _glptr_glDrawElementsInstancedBaseVertex = (PFN_glDrawElementsInstancedBaseVertex)GalogenGetProcAddress("glDrawElementsInstancedBaseVertex");
   _glptr_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}
PFN_glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex = _impl_glDrawElementsInstancedBaseVertex;

static void  GL_APIENTRY _impl_glGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) {
  _glptr_glGetActiveUniformBlockName = (PFN_glGetActiveUniformBlockName)GalogenGetProcAddress("glGetActiveUniformBlockName");
   _glptr_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}
PFN_glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName = _impl_glGetActiveUniformBlockName;

static void  GL_APIENTRY _impl_glFlushMappedNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length) {
  _glptr_glFlushMappedNamedBufferRange = (PFN_glFlushMappedNamedBufferRange)GalogenGetProcAddress("glFlushMappedNamedBufferRange");
   _glptr_glFlushMappedNamedBufferRange(buffer, offset, length);
}
PFN_glFlushMappedNamedBufferRange _glptr_glFlushMappedNamedBufferRange = _impl_glFlushMappedNamedBufferRange;

static GLuint GL_APIENTRY _impl_glGetUniformBlockIndex (GLuint program, const GLchar * uniformBlockName) {
  _glptr_glGetUniformBlockIndex = (PFN_glGetUniformBlockIndex)GalogenGetProcAddress("glGetUniformBlockIndex");
  return _glptr_glGetUniformBlockIndex(program, uniformBlockName);
}
PFN_glGetUniformBlockIndex _glptr_glGetUniformBlockIndex = _impl_glGetUniformBlockIndex;

static void  GL_APIENTRY _impl_glGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName) {
  _glptr_glGetActiveUniformName = (PFN_glGetActiveUniformName)GalogenGetProcAddress("glGetActiveUniformName");
   _glptr_glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}
PFN_glGetActiveUniformName _glptr_glGetActiveUniformName = _impl_glGetActiveUniformName;

static void  GL_APIENTRY _impl_glGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params) {
  _glptr_glGetProgramResourceiv = (PFN_glGetProgramResourceiv)GalogenGetProcAddress("glGetProgramResourceiv");
   _glptr_glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
}
PFN_glGetProgramResourceiv _glptr_glGetProgramResourceiv = _impl_glGetProgramResourceiv;

static void  GL_APIENTRY _impl_glGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices) {
  _glptr_glGetUniformIndices = (PFN_glGetUniformIndices)GalogenGetProcAddress("glGetUniformIndices");
   _glptr_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}
PFN_glGetUniformIndices _glptr_glGetUniformIndices = _impl_glGetUniformIndices;

static void  GL_APIENTRY _impl_glTexBuffer (GLenum target, GLenum internalformat, GLuint buffer) {
  _glptr_glTexBuffer = (PFN_glTexBuffer)GalogenGetProcAddress("glTexBuffer");
   _glptr_glTexBuffer(target, internalformat, buffer);
}
PFN_glTexBuffer _glptr_glTexBuffer = _impl_glTexBuffer;

static void  GL_APIENTRY _impl_glUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix4dv = (PFN_glUniformMatrix4dv)GalogenGetProcAddress("glUniformMatrix4dv");
   _glptr_glUniformMatrix4dv(location, count, transpose, value);
}
PFN_glUniformMatrix4dv _glptr_glUniformMatrix4dv = _impl_glUniformMatrix4dv;

static GLboolean GL_APIENTRY _impl_glIsVertexArray (GLuint array) {
  _glptr_glIsVertexArray = (PFN_glIsVertexArray)GalogenGetProcAddress("glIsVertexArray");
  return _glptr_glIsVertexArray(array);
}
PFN_glIsVertexArray _glptr_glIsVertexArray = _impl_glIsVertexArray;

static void  GL_APIENTRY _impl_glBindVertexArray (GLuint array) {
  _glptr_glBindVertexArray = (PFN_glBindVertexArray)GalogenGetProcAddress("glBindVertexArray");
   _glptr_glBindVertexArray(array);
}
PFN_glBindVertexArray _glptr_glBindVertexArray = _impl_glBindVertexArray;

static void  GL_APIENTRY _impl_glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length) {
  _glptr_glFlushMappedBufferRange = (PFN_glFlushMappedBufferRange)GalogenGetProcAddress("glFlushMappedBufferRange");
   _glptr_glFlushMappedBufferRange(target, offset, length);
}
PFN_glFlushMappedBufferRange _glptr_glFlushMappedBufferRange = _impl_glFlushMappedBufferRange;

static void  GL_APIENTRY _impl_glProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glProgramUniform2fv = (PFN_glProgramUniform2fv)GalogenGetProcAddress("glProgramUniform2fv");
   _glptr_glProgramUniform2fv(program, location, count, value);
}
PFN_glProgramUniform2fv _glptr_glProgramUniform2fv = _impl_glProgramUniform2fv;

static void * GL_APIENTRY _impl_glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
  _glptr_glMapBufferRange = (PFN_glMapBufferRange)GalogenGetProcAddress("glMapBufferRange");
  return _glptr_glMapBufferRange(target, offset, length, access);
}
PFN_glMapBufferRange _glptr_glMapBufferRange = _impl_glMapBufferRange;

static void  GL_APIENTRY _impl_glCreateQueries (GLenum target, GLsizei n, GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_queries += n;
	PFN_glCreateQueries
#endif
  _glptr_glCreateQueries = (PFN_glCreateQueries)GalogenGetProcAddress("glCreateQueries");
   _glptr_glCreateQueries(target, n, ids);
}
PFN_glCreateQueries _glptr_glCreateQueries = _impl_glCreateQueries;

static void  GL_APIENTRY _impl_glGetNamedRenderbufferParameteriv (GLuint renderbuffer, GLenum pname, GLint * params) {
  _glptr_glGetNamedRenderbufferParameteriv = (PFN_glGetNamedRenderbufferParameteriv)GalogenGetProcAddress("glGetNamedRenderbufferParameteriv");
   _glptr_glGetNamedRenderbufferParameteriv(renderbuffer, pname, params);
}
PFN_glGetNamedRenderbufferParameteriv _glptr_glGetNamedRenderbufferParameteriv = _impl_glGetNamedRenderbufferParameteriv;

static void  GL_APIENTRY _impl_glGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) {
  _glptr_glGetActiveUniformsiv = (PFN_glGetActiveUniformsiv)GalogenGetProcAddress("glGetActiveUniformsiv");
   _glptr_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}
PFN_glGetActiveUniformsiv _glptr_glGetActiveUniformsiv = _impl_glGetActiveUniformsiv;

static void  GL_APIENTRY _impl_glFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
  _glptr_glFramebufferTextureLayer = (PFN_glFramebufferTextureLayer)GalogenGetProcAddress("glFramebufferTextureLayer");
   _glptr_glFramebufferTextureLayer(target, attachment, texture, level, layer);
}
PFN_glFramebufferTextureLayer _glptr_glFramebufferTextureLayer = _impl_glFramebufferTextureLayer;

static void  GL_APIENTRY _impl_glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint * params) {
  _glptr_glGetFramebufferAttachmentParameteriv = (PFN_glGetFramebufferAttachmentParameteriv)GalogenGetProcAddress("glGetFramebufferAttachmentParameteriv");
   _glptr_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
PFN_glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv = _impl_glGetFramebufferAttachmentParameteriv;

static void  GL_APIENTRY _impl_glFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
  _glptr_glFramebufferTexture3D = (PFN_glFramebufferTexture3D)GalogenGetProcAddress("glFramebufferTexture3D");
   _glptr_glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
PFN_glFramebufferTexture3D _glptr_glFramebufferTexture3D = _impl_glFramebufferTexture3D;

static void  GL_APIENTRY _impl_glFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
  _glptr_glFramebufferTexture1D = (PFN_glFramebufferTexture1D)GalogenGetProcAddress("glFramebufferTexture1D");
   _glptr_glFramebufferTexture1D(target, attachment, textarget, texture, level);
}
PFN_glFramebufferTexture1D _glptr_glFramebufferTexture1D = _impl_glFramebufferTexture1D;

static void  GL_APIENTRY _impl_glGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint * params) {
  _glptr_glGetProgramInterfaceiv = (PFN_glGetProgramInterfaceiv)GalogenGetProcAddress("glGetProgramInterfaceiv");
   _glptr_glGetProgramInterfaceiv(program, programInterface, pname, params);
}
PFN_glGetProgramInterfaceiv _glptr_glGetProgramInterfaceiv = _impl_glGetProgramInterfaceiv;

static void  GL_APIENTRY _impl_glGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint * params) {
  _glptr_glGetProgramPipelineiv = (PFN_glGetProgramPipelineiv)GalogenGetProcAddress("glGetProgramPipelineiv");
   _glptr_glGetProgramPipelineiv(pipeline, pname, params);
}
PFN_glGetProgramPipelineiv _glptr_glGetProgramPipelineiv = _impl_glGetProgramPipelineiv;

static void  GL_APIENTRY _impl_glGenFramebuffers (GLsizei n, GLuint * framebuffers) {
#ifdef LEAK_COUNTER
	leak_framebuffers += n;
	PFN_glGenFramebuffers
#endif

  _glptr_glGenFramebuffers = (PFN_glGenFramebuffers)GalogenGetProcAddress("glGenFramebuffers");
   _glptr_glGenFramebuffers(n, framebuffers);
}
PFN_glGenFramebuffers _glptr_glGenFramebuffers = _impl_glGenFramebuffers;

static void  GL_APIENTRY _impl_glBindFramebuffer (GLenum target, GLuint framebuffer) {
  _glptr_glBindFramebuffer = (PFN_glBindFramebuffer)GalogenGetProcAddress("glBindFramebuffer");
   _glptr_glBindFramebuffer(target, framebuffer);
}
PFN_glBindFramebuffer _glptr_glBindFramebuffer = _impl_glBindFramebuffer;

static void  GL_APIENTRY _impl_glProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {
  _glptr_glProgramUniform3i = (PFN_glProgramUniform3i)GalogenGetProcAddress("glProgramUniform3i");
   _glptr_glProgramUniform3i(program, location, v0, v1, v2);
}
PFN_glProgramUniform3i _glptr_glProgramUniform3i = _impl_glProgramUniform3i;

static void  GL_APIENTRY _impl_glGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 * params) {
  _glptr_glGetQueryObjecti64v = (PFN_glGetQueryObjecti64v)GalogenGetProcAddress("glGetQueryObjecti64v");
   _glptr_glGetQueryObjecti64v(id, pname, params);
}
PFN_glGetQueryObjecti64v _glptr_glGetQueryObjecti64v = _impl_glGetQueryObjecti64v;

static void  GL_APIENTRY _impl_glGetInteger64v (GLenum pname, GLint64 * data) {
  _glptr_glGetInteger64v = (PFN_glGetInteger64v)GalogenGetProcAddress("glGetInteger64v");
   _glptr_glGetInteger64v(pname, data);
}
PFN_glGetInteger64v _glptr_glGetInteger64v = _impl_glGetInteger64v;

static GLboolean GL_APIENTRY _impl_glIsFramebuffer (GLuint framebuffer) {
  _glptr_glIsFramebuffer = (PFN_glIsFramebuffer)GalogenGetProcAddress("glIsFramebuffer");
  return _glptr_glIsFramebuffer(framebuffer);
}
PFN_glIsFramebuffer _glptr_glIsFramebuffer = _impl_glIsFramebuffer;

static void  GL_APIENTRY _impl_glUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix4x3dv = (PFN_glUniformMatrix4x3dv)GalogenGetProcAddress("glUniformMatrix4x3dv");
   _glptr_glUniformMatrix4x3dv(location, count, transpose, value);
}
PFN_glUniformMatrix4x3dv _glptr_glUniformMatrix4x3dv = _impl_glUniformMatrix4x3dv;

static void  GL_APIENTRY _impl_glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetRenderbufferParameteriv = (PFN_glGetRenderbufferParameteriv)GalogenGetProcAddress("glGetRenderbufferParameteriv");
   _glptr_glGetRenderbufferParameteriv(target, pname, params);
}
PFN_glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv = _impl_glGetRenderbufferParameteriv;

static void  GL_APIENTRY _impl_glUniform1d (GLint location, GLdouble x) {
  _glptr_glUniform1d = (PFN_glUniform1d)GalogenGetProcAddress("glUniform1d");
   _glptr_glUniform1d(location, x);
}
PFN_glUniform1d _glptr_glUniform1d = _impl_glUniform1d;

static void  GL_APIENTRY _impl_glBindRenderbuffer (GLenum target, GLuint renderbuffer) {
  _glptr_glBindRenderbuffer = (PFN_glBindRenderbuffer)GalogenGetProcAddress("glBindRenderbuffer");
   _glptr_glBindRenderbuffer(target, renderbuffer);
}
PFN_glBindRenderbuffer _glptr_glBindRenderbuffer = _impl_glBindRenderbuffer;

static GLboolean GL_APIENTRY _impl_glIsRenderbuffer (GLuint renderbuffer) {
  _glptr_glIsRenderbuffer = (PFN_glIsRenderbuffer)GalogenGetProcAddress("glIsRenderbuffer");
  return _glptr_glIsRenderbuffer(renderbuffer);
}
PFN_glIsRenderbuffer _glptr_glIsRenderbuffer = _impl_glIsRenderbuffer;

static const GLubyte * GL_APIENTRY _impl_glGetStringi (GLenum name, GLuint index) {
  _glptr_glGetStringi = (PFN_glGetStringi)GalogenGetProcAddress("glGetStringi");
  return _glptr_glGetStringi(name, index);
}
PFN_glGetStringi _glptr_glGetStringi = _impl_glGetStringi;

static void  GL_APIENTRY _impl_glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
  _glptr_glClearBufferfi = (PFN_glClearBufferfi)GalogenGetProcAddress("glClearBufferfi");
   _glptr_glClearBufferfi(buffer, drawbuffer, depth, stencil);
}
PFN_glClearBufferfi _glptr_glClearBufferfi = _impl_glClearBufferfi;

static void  GL_APIENTRY _impl_glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat * value) {
  _glptr_glClearBufferfv = (PFN_glClearBufferfv)GalogenGetProcAddress("glClearBufferfv");
   _glptr_glClearBufferfv(buffer, drawbuffer, value);
}
PFN_glClearBufferfv _glptr_glClearBufferfv = _impl_glClearBufferfv;

static GLuint GL_APIENTRY _impl_glCreateShaderProgramv (GLenum type, GLsizei count, const GLchar *const* strings) {
#ifdef LEAK_COUNTER
	leak_shaderprograms += count;
	PFN_glCreateShaderProgramv
#endif
  _glptr_glCreateShaderProgramv = (PFN_glCreateShaderProgramv)GalogenGetProcAddress("glCreateShaderProgramv");
  return _glptr_glCreateShaderProgramv(type, count, strings);
}
PFN_glCreateShaderProgramv _glptr_glCreateShaderProgramv = _impl_glCreateShaderProgramv;

static void  GL_APIENTRY _impl_glGetTexParameterIiv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetTexParameterIiv = (PFN_glGetTexParameterIiv)GalogenGetProcAddress("glGetTexParameterIiv");
   _glptr_glGetTexParameterIiv(target, pname, params);
}
PFN_glGetTexParameterIiv _glptr_glGetTexParameterIiv = _impl_glGetTexParameterIiv;

static void  GL_APIENTRY _impl_glGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint * params) {
  _glptr_glGetSamplerParameterIuiv = (PFN_glGetSamplerParameterIuiv)GalogenGetProcAddress("glGetSamplerParameterIuiv");
   _glptr_glGetSamplerParameterIuiv(sampler, pname, params);
}
PFN_glGetSamplerParameterIuiv _glptr_glGetSamplerParameterIuiv = _impl_glGetSamplerParameterIuiv;

static void  GL_APIENTRY _impl_glTexParameterIiv (GLenum target, GLenum pname, const GLint * params) {
  _glptr_glTexParameterIiv = (PFN_glTexParameterIiv)GalogenGetProcAddress("glTexParameterIiv");
   _glptr_glTexParameterIiv(target, pname, params);
}
PFN_glTexParameterIiv _glptr_glTexParameterIiv = _impl_glTexParameterIiv;

static void  GL_APIENTRY _impl_glUniform4uiv (GLint location, GLsizei count, const GLuint * value) {
  _glptr_glUniform4uiv = (PFN_glUniform4uiv)GalogenGetProcAddress("glUniform4uiv");
   _glptr_glUniform4uiv(location, count, value);
}
PFN_glUniform4uiv _glptr_glUniform4uiv = _impl_glUniform4uiv;

static void  GL_APIENTRY _impl_glVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) {
  _glptr_glVertexAttribL3d = (PFN_glVertexAttribL3d)GalogenGetProcAddress("glVertexAttribL3d");
   _glptr_glVertexAttribL3d(index, x, y, z);
}
PFN_glVertexAttribL3d _glptr_glVertexAttribL3d = _impl_glVertexAttribL3d;

static void  GL_APIENTRY _impl_glUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2) {
  _glptr_glUniform3ui = (PFN_glUniform3ui)GalogenGetProcAddress("glUniform3ui");
   _glptr_glUniform3ui(location, v0, v1, v2);
}
PFN_glUniform3ui _glptr_glUniform3ui = _impl_glUniform3ui;

static void  GL_APIENTRY _impl_glBindBuffersBase (GLenum target, GLuint first, GLsizei count, const GLuint * buffers) {
  _glptr_glBindBuffersBase = (PFN_glBindBuffersBase)GalogenGetProcAddress("glBindBuffersBase");
   _glptr_glBindBuffersBase(target, first, count, buffers);
}
PFN_glBindBuffersBase _glptr_glBindBuffersBase = _impl_glBindBuffersBase;

static void  GL_APIENTRY _impl_glDrawTransformFeedback (GLenum mode, GLuint id) {
  _glptr_glDrawTransformFeedback = (PFN_glDrawTransformFeedback)GalogenGetProcAddress("glDrawTransformFeedback");
   _glptr_glDrawTransformFeedback(mode, id);
}
PFN_glDrawTransformFeedback _glptr_glDrawTransformFeedback = _impl_glDrawTransformFeedback;

static void  GL_APIENTRY _impl_glUniform1ui (GLint location, GLuint v0) {
  _glptr_glUniform1ui = (PFN_glUniform1ui)GalogenGetProcAddress("glUniform1ui");
   _glptr_glUniform1ui(location, v0);
}
PFN_glUniform1ui _glptr_glUniform1ui = _impl_glUniform1ui;

static GLint GL_APIENTRY _impl_glGetFragDataLocation (GLuint program, const GLchar * name) {
  _glptr_glGetFragDataLocation = (PFN_glGetFragDataLocation)GalogenGetProcAddress("glGetFragDataLocation");
  return _glptr_glGetFragDataLocation(program, name);
}
PFN_glGetFragDataLocation _glptr_glGetFragDataLocation = _impl_glGetFragDataLocation;

static void  GL_APIENTRY _impl_glBindFragDataLocation (GLuint program, GLuint color, const GLchar * name) {
  _glptr_glBindFragDataLocation = (PFN_glBindFragDataLocation)GalogenGetProcAddress("glBindFragDataLocation");
   _glptr_glBindFragDataLocation(program, color, name);
}
PFN_glBindFragDataLocation _glptr_glBindFragDataLocation = _impl_glBindFragDataLocation;

static void  GL_APIENTRY _impl_glClearNamedFramebufferiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value) {
  _glptr_glClearNamedFramebufferiv = (PFN_glClearNamedFramebufferiv)GalogenGetProcAddress("glClearNamedFramebufferiv");
   _glptr_glClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
}
PFN_glClearNamedFramebufferiv _glptr_glClearNamedFramebufferiv = _impl_glClearNamedFramebufferiv;

static void  GL_APIENTRY _impl_glVertexAttribI4iv (GLuint index, const GLint * v) {
  _glptr_glVertexAttribI4iv = (PFN_glVertexAttribI4iv)GalogenGetProcAddress("glVertexAttribI4iv");
   _glptr_glVertexAttribI4iv(index, v);
}
PFN_glVertexAttribI4iv _glptr_glVertexAttribI4iv = _impl_glVertexAttribI4iv;

static void  GL_APIENTRY _impl_glVertexAttribI2iv (GLuint index, const GLint * v) {
  _glptr_glVertexAttribI2iv = (PFN_glVertexAttribI2iv)GalogenGetProcAddress("glVertexAttribI2iv");
   _glptr_glVertexAttribI2iv(index, v);
}
PFN_glVertexAttribI2iv _glptr_glVertexAttribI2iv = _impl_glVertexAttribI2iv;

static void  GL_APIENTRY _impl_glNamedFramebufferDrawBuffers (GLuint framebuffer, GLsizei n, const GLenum * bufs) {
  _glptr_glNamedFramebufferDrawBuffers = (PFN_glNamedFramebufferDrawBuffers)GalogenGetProcAddress("glNamedFramebufferDrawBuffers");
   _glptr_glNamedFramebufferDrawBuffers(framebuffer, n, bufs);
}
PFN_glNamedFramebufferDrawBuffers _glptr_glNamedFramebufferDrawBuffers = _impl_glNamedFramebufferDrawBuffers;

static void  GL_APIENTRY _impl_glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision) {
  _glptr_glGetShaderPrecisionFormat = (PFN_glGetShaderPrecisionFormat)GalogenGetProcAddress("glGetShaderPrecisionFormat");
   _glptr_glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
PFN_glGetShaderPrecisionFormat _glptr_glGetShaderPrecisionFormat = _impl_glGetShaderPrecisionFormat;

static void  GL_APIENTRY _impl_glVertexAttribI1iv (GLuint index, const GLint * v) {
  _glptr_glVertexAttribI1iv = (PFN_glVertexAttribI1iv)GalogenGetProcAddress("glVertexAttribI1iv");
   _glptr_glVertexAttribI1iv(index, v);
}
PFN_glVertexAttribI1iv _glptr_glVertexAttribI1iv = _impl_glVertexAttribI1iv;

static void  GL_APIENTRY _impl_glVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {
  _glptr_glVertexAttribI4ui = (PFN_glVertexAttribI4ui)GalogenGetProcAddress("glVertexAttribI4ui");
   _glptr_glVertexAttribI4ui(index, x, y, z, w);
}
PFN_glVertexAttribI4ui _glptr_glVertexAttribI4ui = _impl_glVertexAttribI4ui;

static void  GL_APIENTRY _impl_glVertexArrayVertexBuffers (GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) {
  _glptr_glVertexArrayVertexBuffers = (PFN_glVertexArrayVertexBuffers)GalogenGetProcAddress("glVertexArrayVertexBuffers");
   _glptr_glVertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
}
PFN_glVertexArrayVertexBuffers _glptr_glVertexArrayVertexBuffers = _impl_glVertexArrayVertexBuffers;

static void  GL_APIENTRY _impl_glVertexAttribI2ui (GLuint index, GLuint x, GLuint y) {
  _glptr_glVertexAttribI2ui = (PFN_glVertexAttribI2ui)GalogenGetProcAddress("glVertexAttribI2ui");
   _glptr_glVertexAttribI2ui(index, x, y);
}
PFN_glVertexAttribI2ui _glptr_glVertexAttribI2ui = _impl_glVertexAttribI2ui;

static void  GL_APIENTRY _impl_glVertexAttribI1ui (GLuint index, GLuint x) {
  _glptr_glVertexAttribI1ui = (PFN_glVertexAttribI1ui)GalogenGetProcAddress("glVertexAttribI1ui");
   _glptr_glVertexAttribI1ui(index, x);
}
PFN_glVertexAttribI1ui _glptr_glVertexAttribI1ui = _impl_glVertexAttribI1ui;

static GLboolean GL_APIENTRY _impl_glUnmapNamedBuffer (GLuint buffer) {
  _glptr_glUnmapNamedBuffer = (PFN_glUnmapNamedBuffer)GalogenGetProcAddress("glUnmapNamedBuffer");
  return _glptr_glUnmapNamedBuffer(buffer);
}
PFN_glUnmapNamedBuffer _glptr_glUnmapNamedBuffer = _impl_glUnmapNamedBuffer;

static void  GL_APIENTRY _impl_glProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint * value) {
  _glptr_glProgramUniform3iv = (PFN_glProgramUniform3iv)GalogenGetProcAddress("glProgramUniform3iv");
   _glptr_glProgramUniform3iv(program, location, count, value);
}
PFN_glProgramUniform3iv _glptr_glProgramUniform3iv = _impl_glProgramUniform3iv;

static void  GL_APIENTRY _impl_glVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w) {
  _glptr_glVertexAttribI4i = (PFN_glVertexAttribI4i)GalogenGetProcAddress("glVertexAttribI4i");
   _glptr_glVertexAttribI4i(index, x, y, z, w);
}
PFN_glVertexAttribI4i _glptr_glVertexAttribI4i = _impl_glVertexAttribI4i;

static void  GL_APIENTRY _impl_glVertexAttribI4bv (GLuint index, const GLbyte * v) {
  _glptr_glVertexAttribI4bv = (PFN_glVertexAttribI4bv)GalogenGetProcAddress("glVertexAttribI4bv");
   _glptr_glVertexAttribI4bv(index, v);
}
PFN_glVertexAttribI4bv _glptr_glVertexAttribI4bv = _impl_glVertexAttribI4bv;

static void  GL_APIENTRY _impl_glVertexAttribI2i (GLuint index, GLint x, GLint y) {
  _glptr_glVertexAttribI2i = (PFN_glVertexAttribI2i)GalogenGetProcAddress("glVertexAttribI2i");
   _glptr_glVertexAttribI2i(index, x, y);
}
PFN_glVertexAttribI2i _glptr_glVertexAttribI2i = _impl_glVertexAttribI2i;

static void  GL_APIENTRY _impl_glVertexAttribI1i (GLuint index, GLint x) {
  _glptr_glVertexAttribI1i = (PFN_glVertexAttribI1i)GalogenGetProcAddress("glVertexAttribI1i");
   _glptr_glVertexAttribI1i(index, x);
}
PFN_glVertexAttribI1i _glptr_glVertexAttribI1i = _impl_glVertexAttribI1i;

static void  GL_APIENTRY _impl_glGetVertexAttribIiv (GLuint index, GLenum pname, GLint * params) {
  _glptr_glGetVertexAttribIiv = (PFN_glGetVertexAttribIiv)GalogenGetProcAddress("glGetVertexAttribIiv");
   _glptr_glGetVertexAttribIiv(index, pname, params);
}
PFN_glGetVertexAttribIiv _glptr_glGetVertexAttribIiv = _impl_glGetVertexAttribIiv;

static void  GL_APIENTRY _impl_glProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint * value) {
  _glptr_glProgramUniform2uiv = (PFN_glProgramUniform2uiv)GalogenGetProcAddress("glProgramUniform2uiv");
   _glptr_glProgramUniform2uiv(program, location, count, value);
}
PFN_glProgramUniform2uiv _glptr_glProgramUniform2uiv = _impl_glProgramUniform2uiv;

static void  GL_APIENTRY _impl_glVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) {
  _glptr_glVertexAttribIPointer = (PFN_glVertexAttribIPointer)GalogenGetProcAddress("glVertexAttribIPointer");
   _glptr_glVertexAttribIPointer(index, size, type, stride, pointer);
}
PFN_glVertexAttribIPointer _glptr_glVertexAttribIPointer = _impl_glVertexAttribIPointer;

static void  GL_APIENTRY _impl_glBeginConditionalRender (GLuint id, GLenum mode) {
  _glptr_glBeginConditionalRender = (PFN_glBeginConditionalRender)GalogenGetProcAddress("glBeginConditionalRender");
   _glptr_glBeginConditionalRender(id, mode);
}
PFN_glBeginConditionalRender _glptr_glBeginConditionalRender = _impl_glBeginConditionalRender;

static void  GL_APIENTRY _impl_glClampColor (GLenum target, GLenum clamp) {
  _glptr_glClampColor = (PFN_glClampColor)GalogenGetProcAddress("glClampColor");
   _glptr_glClampColor(target, clamp);
}
PFN_glClampColor _glptr_glClampColor = _impl_glClampColor;

static void  GL_APIENTRY _impl_glGetNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, void * data) {
  _glptr_glGetNamedBufferSubData = (PFN_glGetNamedBufferSubData)GalogenGetProcAddress("glGetNamedBufferSubData");
   _glptr_glGetNamedBufferSubData(buffer, offset, size, data);
}
PFN_glGetNamedBufferSubData _glptr_glGetNamedBufferSubData = _impl_glGetNamedBufferSubData;

static void  GL_APIENTRY _impl_glBindBufferBase (GLenum target, GLuint index, GLuint buffer) {
  _glptr_glBindBufferBase = (PFN_glBindBufferBase)GalogenGetProcAddress("glBindBufferBase");
   _glptr_glBindBufferBase(target, index, buffer);
}
PFN_glBindBufferBase _glptr_glBindBufferBase = _impl_glBindBufferBase;

static void  GL_APIENTRY _impl_glBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {
  _glptr_glBindBufferRange = (PFN_glBindBufferRange)GalogenGetProcAddress("glBindBufferRange");
   _glptr_glBindBufferRange(target, index, buffer, offset, size);
}
PFN_glBindBufferRange _glptr_glBindBufferRange = _impl_glBindBufferRange;

static void  GL_APIENTRY _impl_glCompressedTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTextureSubImage1D = (PFN_glCompressedTextureSubImage1D)GalogenGetProcAddress("glCompressedTextureSubImage1D");
   _glptr_glCompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}
PFN_glCompressedTextureSubImage1D _glptr_glCompressedTextureSubImage1D = _impl_glCompressedTextureSubImage1D;

static void  GL_APIENTRY _impl_glBeginTransformFeedback (GLenum primitiveMode) {
  _glptr_glBeginTransformFeedback = (PFN_glBeginTransformFeedback)GalogenGetProcAddress("glBeginTransformFeedback");
   _glptr_glBeginTransformFeedback(primitiveMode);
}
PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback = _impl_glBeginTransformFeedback;

static void  GL_APIENTRY _impl_glTextureBufferRange (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) {
  _glptr_glTextureBufferRange = (PFN_glTextureBufferRange)GalogenGetProcAddress("glTextureBufferRange");
   _glptr_glTextureBufferRange(texture, internalformat, buffer, offset, size);
}
PFN_glTextureBufferRange _glptr_glTextureBufferRange = _impl_glTextureBufferRange;

static GLboolean GL_APIENTRY _impl_glIsEnabledi (GLenum target, GLuint index) {
  _glptr_glIsEnabledi = (PFN_glIsEnabledi)GalogenGetProcAddress("glIsEnabledi");
  return _glptr_glIsEnabledi(target, index);
}
PFN_glIsEnabledi _glptr_glIsEnabledi = _impl_glIsEnabledi;

static void  GL_APIENTRY _impl_glGetIntegeri_v (GLenum target, GLuint index, GLint * data) {
  _glptr_glGetIntegeri_v = (PFN_glGetIntegeri_v)GalogenGetProcAddress("glGetIntegeri_v");
   _glptr_glGetIntegeri_v(target, index, data);
}
PFN_glGetIntegeri_v _glptr_glGetIntegeri_v = _impl_glGetIntegeri_v;

static void  GL_APIENTRY _impl_glNamedRenderbufferStorageMultisample (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glNamedRenderbufferStorageMultisample = (PFN_glNamedRenderbufferStorageMultisample)GalogenGetProcAddress("glNamedRenderbufferStorageMultisample");
   _glptr_glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
}
PFN_glNamedRenderbufferStorageMultisample _glptr_glNamedRenderbufferStorageMultisample = _impl_glNamedRenderbufferStorageMultisample;

static void  GL_APIENTRY _impl_glProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glProgramUniform4fv = (PFN_glProgramUniform4fv)GalogenGetProcAddress("glProgramUniform4fv");
   _glptr_glProgramUniform4fv(program, location, count, value);
}
PFN_glProgramUniform4fv _glptr_glProgramUniform4fv = _impl_glProgramUniform4fv;

static void  GL_APIENTRY _impl_glColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
  _glptr_glColorMaski = (PFN_glColorMaski)GalogenGetProcAddress("glColorMaski");
   _glptr_glColorMaski(index, r, g, b, a);
}
PFN_glColorMaski _glptr_glColorMaski = _impl_glColorMaski;

static void  GL_APIENTRY _impl_glUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix4x3fv = (PFN_glUniformMatrix4x3fv)GalogenGetProcAddress("glUniformMatrix4x3fv");
   _glptr_glUniformMatrix4x3fv(location, count, transpose, value);
}
PFN_glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv = _impl_glUniformMatrix4x3fv;

static void  GL_APIENTRY _impl_glUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix3x4fv = (PFN_glUniformMatrix3x4fv)GalogenGetProcAddress("glUniformMatrix3x4fv");
   _glptr_glUniformMatrix3x4fv(location, count, transpose, value);
}
PFN_glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv = _impl_glUniformMatrix3x4fv;

static GLenum GL_APIENTRY _impl_glGetGraphicsResetStatus () {
  _glptr_glGetGraphicsResetStatus = (PFN_glGetGraphicsResetStatus)GalogenGetProcAddress("glGetGraphicsResetStatus");
  return _glptr_glGetGraphicsResetStatus();
}
PFN_glGetGraphicsResetStatus _glptr_glGetGraphicsResetStatus = _impl_glGetGraphicsResetStatus;

static void  GL_APIENTRY _impl_glUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix2x4fv = (PFN_glUniformMatrix2x4fv)GalogenGetProcAddress("glUniformMatrix2x4fv");
   _glptr_glUniformMatrix2x4fv(location, count, transpose, value);
}
PFN_glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv = _impl_glUniformMatrix2x4fv;

static void  GL_APIENTRY _impl_glUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix3x2fv = (PFN_glUniformMatrix3x2fv)GalogenGetProcAddress("glUniformMatrix3x2fv");
   _glptr_glUniformMatrix3x2fv(location, count, transpose, value);
}
PFN_glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv = _impl_glUniformMatrix3x2fv;

static void  GL_APIENTRY _impl_glUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix2x3fv = (PFN_glUniformMatrix2x3fv)GalogenGetProcAddress("glUniformMatrix2x3fv");
   _glptr_glUniformMatrix2x3fv(location, count, transpose, value);
}
PFN_glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv = _impl_glUniformMatrix2x3fv;

static void  GL_APIENTRY _impl_glVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
  _glptr_glVertexAttribP4ui = (PFN_glVertexAttribP4ui)GalogenGetProcAddress("glVertexAttribP4ui");
   _glptr_glVertexAttribP4ui(index, type, normalized, value);
}
PFN_glVertexAttribP4ui _glptr_glVertexAttribP4ui = _impl_glVertexAttribP4ui;

static void  GL_APIENTRY _impl_glVertexAttrib4ubv (GLuint index, const GLubyte * v) {
  _glptr_glVertexAttrib4ubv = (PFN_glVertexAttrib4ubv)GalogenGetProcAddress("glVertexAttrib4ubv");
   _glptr_glVertexAttrib4ubv(index, v);
}
PFN_glVertexAttrib4ubv _glptr_glVertexAttrib4ubv = _impl_glVertexAttrib4ubv;

static void  GL_APIENTRY _impl_glProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble * value) {
  _glptr_glProgramUniform1dv = (PFN_glProgramUniform1dv)GalogenGetProcAddress("glProgramUniform1dv");
   _glptr_glProgramUniform1dv(program, location, count, value);
}
PFN_glProgramUniform1dv _glptr_glProgramUniform1dv = _impl_glProgramUniform1dv;

static void  GL_APIENTRY _impl_glVertexAttrib4sv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttrib4sv = (PFN_glVertexAttrib4sv)GalogenGetProcAddress("glVertexAttrib4sv");
   _glptr_glVertexAttrib4sv(index, v);
}
PFN_glVertexAttrib4sv _glptr_glVertexAttrib4sv = _impl_glVertexAttrib4sv;

static void  GL_APIENTRY _impl_glGetTransformFeedbackiv (GLuint xfb, GLenum pname, GLint * param) {
  _glptr_glGetTransformFeedbackiv = (PFN_glGetTransformFeedbackiv)GalogenGetProcAddress("glGetTransformFeedbackiv");
   _glptr_glGetTransformFeedbackiv(xfb, pname, param);
}
PFN_glGetTransformFeedbackiv _glptr_glGetTransformFeedbackiv = _impl_glGetTransformFeedbackiv;

static void  GL_APIENTRY _impl_glVertexAttrib4fv (GLuint index, const GLfloat * v) {
  _glptr_glVertexAttrib4fv = (PFN_glVertexAttrib4fv)GalogenGetProcAddress("glVertexAttrib4fv");
   _glptr_glVertexAttrib4fv(index, v);
}
PFN_glVertexAttrib4fv _glptr_glVertexAttrib4fv = _impl_glVertexAttrib4fv;

static void  GL_APIENTRY _impl_glVertexAttrib4Nusv (GLuint index, const GLushort * v) {
  _glptr_glVertexAttrib4Nusv = (PFN_glVertexAttrib4Nusv)GalogenGetProcAddress("glVertexAttrib4Nusv");
   _glptr_glVertexAttrib4Nusv(index, v);
}
PFN_glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv = _impl_glVertexAttrib4Nusv;

static void  GL_APIENTRY _impl_glBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) {
  _glptr_glBindVertexBuffer = (PFN_glBindVertexBuffer)GalogenGetProcAddress("glBindVertexBuffer");
   _glptr_glBindVertexBuffer(bindingindex, buffer, offset, stride);
}
PFN_glBindVertexBuffer _glptr_glBindVertexBuffer = _impl_glBindVertexBuffer;

static void  GL_APIENTRY _impl_glVertexAttrib4Nuiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttrib4Nuiv = (PFN_glVertexAttrib4Nuiv)GalogenGetProcAddress("glVertexAttrib4Nuiv");
   _glptr_glVertexAttrib4Nuiv(index, v);
}
PFN_glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv = _impl_glVertexAttrib4Nuiv;

static void  GL_APIENTRY _impl_glVertexAttrib4Nubv (GLuint index, const GLubyte * v) {
  _glptr_glVertexAttrib4Nubv = (PFN_glVertexAttrib4Nubv)GalogenGetProcAddress("glVertexAttrib4Nubv");
   _glptr_glVertexAttrib4Nubv(index, v);
}
PFN_glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv = _impl_glVertexAttrib4Nubv;

static void  GL_APIENTRY _impl_glProvokingVertex (GLenum mode) {
  _glptr_glProvokingVertex = (PFN_glProvokingVertex)GalogenGetProcAddress("glProvokingVertex");
   _glptr_glProvokingVertex(mode);
}
PFN_glProvokingVertex _glptr_glProvokingVertex = _impl_glProvokingVertex;

static void  GL_APIENTRY _impl_glVertexAttrib4Nsv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttrib4Nsv = (PFN_glVertexAttrib4Nsv)GalogenGetProcAddress("glVertexAttrib4Nsv");
   _glptr_glVertexAttrib4Nsv(index, v);
}
PFN_glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv = _impl_glVertexAttrib4Nsv;

static void  GL_APIENTRY _impl_glGetTextureParameterIiv (GLuint texture, GLenum pname, GLint * params) {
  _glptr_glGetTextureParameterIiv = (PFN_glGetTextureParameterIiv)GalogenGetProcAddress("glGetTextureParameterIiv");
   _glptr_glGetTextureParameterIiv(texture, pname, params);
}
PFN_glGetTextureParameterIiv _glptr_glGetTextureParameterIiv = _impl_glGetTextureParameterIiv;

static void  GL_APIENTRY _impl_glVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z) {
  _glptr_glVertexAttrib3f = (PFN_glVertexAttrib3f)GalogenGetProcAddress("glVertexAttrib3f");
   _glptr_glVertexAttrib3f(index, x, y, z);
}
PFN_glVertexAttrib3f _glptr_glVertexAttrib3f = _impl_glVertexAttrib3f;

static void  GL_APIENTRY _impl_glClearNamedFramebufferfv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value) {
  _glptr_glClearNamedFramebufferfv = (PFN_glClearNamedFramebufferfv)GalogenGetProcAddress("glClearNamedFramebufferfv");
   _glptr_glClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
}
PFN_glClearNamedFramebufferfv _glptr_glClearNamedFramebufferfv = _impl_glClearNamedFramebufferfv;

static void  GL_APIENTRY _impl_glVertexAttribI1uiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttribI1uiv = (PFN_glVertexAttribI1uiv)GalogenGetProcAddress("glVertexAttribI1uiv");
   _glptr_glVertexAttribI1uiv(index, v);
}
PFN_glVertexAttribI1uiv _glptr_glVertexAttribI1uiv = _impl_glVertexAttribI1uiv;

static void  GL_APIENTRY _impl_glVertexAttrib3dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttrib3dv = (PFN_glVertexAttrib3dv)GalogenGetProcAddress("glVertexAttrib3dv");
   _glptr_glVertexAttrib3dv(index, v);
}
PFN_glVertexAttrib3dv _glptr_glVertexAttrib3dv = _impl_glVertexAttrib3dv;

static void  GL_APIENTRY _impl_glVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) {
  _glptr_glVertexAttrib3d = (PFN_glVertexAttrib3d)GalogenGetProcAddress("glVertexAttrib3d");
   _glptr_glVertexAttrib3d(index, x, y, z);
}
PFN_glVertexAttrib3d _glptr_glVertexAttrib3d = _impl_glVertexAttrib3d;

static void  GL_APIENTRY _impl_glVertexAttrib2sv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttrib2sv = (PFN_glVertexAttrib2sv)GalogenGetProcAddress("glVertexAttrib2sv");
   _glptr_glVertexAttrib2sv(index, v);
}
PFN_glVertexAttrib2sv _glptr_glVertexAttrib2sv = _impl_glVertexAttrib2sv;

static void  GL_APIENTRY _impl_glTextureParameteriv (GLuint texture, GLenum pname, const GLint * param) {
  _glptr_glTextureParameteriv = (PFN_glTextureParameteriv)GalogenGetProcAddress("glTextureParameteriv");
   _glptr_glTextureParameteriv(texture, pname, param);
}
PFN_glTextureParameteriv _glptr_glTextureParameteriv = _impl_glTextureParameteriv;

static void  GL_APIENTRY _impl_glClearTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data) {
  _glptr_glClearTexSubImage = (PFN_glClearTexSubImage)GalogenGetProcAddress("glClearTexSubImage");
   _glptr_glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}
PFN_glClearTexSubImage _glptr_glClearTexSubImage = _impl_glClearTexSubImage;

static void  GL_APIENTRY _impl_glUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program) {
  _glptr_glUseProgramStages = (PFN_glUseProgramStages)GalogenGetProcAddress("glUseProgramStages");
   _glptr_glUseProgramStages(pipeline, stages, program);
}
PFN_glUseProgramStages _glptr_glUseProgramStages = _impl_glUseProgramStages;

static void  GL_APIENTRY _impl_glVertexAttrib2fv (GLuint index, const GLfloat * v) {
  _glptr_glVertexAttrib2fv = (PFN_glVertexAttrib2fv)GalogenGetProcAddress("glVertexAttrib2fv");
   _glptr_glVertexAttrib2fv(index, v);
}
PFN_glVertexAttrib2fv _glptr_glVertexAttrib2fv = _impl_glVertexAttrib2fv;

static void  GL_APIENTRY _impl_glVertexAttrib2dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttrib2dv = (PFN_glVertexAttrib2dv)GalogenGetProcAddress("glVertexAttrib2dv");
   _glptr_glVertexAttrib2dv(index, v);
}
PFN_glVertexAttrib2dv _glptr_glVertexAttrib2dv = _impl_glVertexAttrib2dv;

static void  GL_APIENTRY _impl_glVertexAttrib2d (GLuint index, GLdouble x, GLdouble y) {
  _glptr_glVertexAttrib2d = (PFN_glVertexAttrib2d)GalogenGetProcAddress("glVertexAttrib2d");
   _glptr_glVertexAttrib2d(index, x, y);
}
PFN_glVertexAttrib2d _glptr_glVertexAttrib2d = _impl_glVertexAttrib2d;

static void  GL_APIENTRY _impl_glVertexAttrib2f (GLuint index, GLfloat x, GLfloat y) {
  _glptr_glVertexAttrib2f = (PFN_glVertexAttrib2f)GalogenGetProcAddress("glVertexAttrib2f");
   _glptr_glVertexAttrib2f(index, x, y);
}
PFN_glVertexAttrib2f _glptr_glVertexAttrib2f = _impl_glVertexAttrib2f;

static void  GL_APIENTRY _impl_glVertexAttrib1s (GLuint index, GLshort x) {
  _glptr_glVertexAttrib1s = (PFN_glVertexAttrib1s)GalogenGetProcAddress("glVertexAttrib1s");
   _glptr_glVertexAttrib1s(index, x);
}
PFN_glVertexAttrib1s _glptr_glVertexAttrib1s = _impl_glVertexAttrib1s;

static void  GL_APIENTRY _impl_glVertexAttrib1fv (GLuint index, const GLfloat * v) {
  _glptr_glVertexAttrib1fv = (PFN_glVertexAttrib1fv)GalogenGetProcAddress("glVertexAttrib1fv");
   _glptr_glVertexAttrib1fv(index, v);
}
PFN_glVertexAttrib1fv _glptr_glVertexAttrib1fv = _impl_glVertexAttrib1fv;

static void  GL_APIENTRY _impl_glVertexAttrib1f (GLuint index, GLfloat x) {
  _glptr_glVertexAttrib1f = (PFN_glVertexAttrib1f)GalogenGetProcAddress("glVertexAttrib1f");
   _glptr_glVertexAttrib1f(index, x);
}
PFN_glVertexAttrib1f _glptr_glVertexAttrib1f = _impl_glVertexAttrib1f;

static void  GL_APIENTRY _impl_glVertexAttrib1dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttrib1dv = (PFN_glVertexAttrib1dv)GalogenGetProcAddress("glVertexAttrib1dv");
   _glptr_glVertexAttrib1dv(index, v);
}
PFN_glVertexAttrib1dv _glptr_glVertexAttrib1dv = _impl_glVertexAttrib1dv;

static void  GL_APIENTRY _impl_glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint * value) {
  _glptr_glClearBufferuiv = (PFN_glClearBufferuiv)GalogenGetProcAddress("glClearBufferuiv");
   _glptr_glClearBufferuiv(buffer, drawbuffer, value);
}
PFN_glClearBufferuiv _glptr_glClearBufferuiv = _impl_glClearBufferuiv;

static void  GL_APIENTRY _impl_glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix3fv = (PFN_glUniformMatrix3fv)GalogenGetProcAddress("glUniformMatrix3fv");
   _glptr_glUniformMatrix3fv(location, count, transpose, value);
}
PFN_glUniformMatrix3fv _glptr_glUniformMatrix3fv = _impl_glUniformMatrix3fv;

static void  GL_APIENTRY _impl_glDeleteRenderbuffers (GLsizei n, const GLuint * renderbuffers) {
#ifdef LEAK_COUNTER
	leak_renderbuffers -= n;
	PFN_glDeleteRenderbuffers
#endif
  _glptr_glDeleteRenderbuffers = (PFN_glDeleteRenderbuffers)GalogenGetProcAddress("glDeleteRenderbuffers");
   _glptr_glDeleteRenderbuffers(n, renderbuffers);
}
PFN_glDeleteRenderbuffers _glptr_glDeleteRenderbuffers = _impl_glDeleteRenderbuffers;

static void  GL_APIENTRY _impl_glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix2fv = (PFN_glUniformMatrix2fv)GalogenGetProcAddress("glUniformMatrix2fv");
   _glptr_glUniformMatrix2fv(location, count, transpose, value);
}
PFN_glUniformMatrix2fv _glptr_glUniformMatrix2fv = _impl_glUniformMatrix2fv;

static void  GL_APIENTRY _impl_glNamedFramebufferDrawBuffer (GLuint framebuffer, GLenum buf) {
  _glptr_glNamedFramebufferDrawBuffer = (PFN_glNamedFramebufferDrawBuffer)GalogenGetProcAddress("glNamedFramebufferDrawBuffer");
   _glptr_glNamedFramebufferDrawBuffer(framebuffer, buf);
}
PFN_glNamedFramebufferDrawBuffer _glptr_glNamedFramebufferDrawBuffer = _impl_glNamedFramebufferDrawBuffer;

static void  GL_APIENTRY _impl_glUniform2d (GLint location, GLdouble x, GLdouble y) {
  _glptr_glUniform2d = (PFN_glUniform2d)GalogenGetProcAddress("glUniform2d");
   _glptr_glUniform2d(location, x, y);
}
PFN_glUniform2d _glptr_glUniform2d = _impl_glUniform2d;

static void  GL_APIENTRY _impl_glUniform4iv (GLint location, GLsizei count, const GLint * value) {
  _glptr_glUniform4iv = (PFN_glUniform4iv)GalogenGetProcAddress("glUniform4iv");
   _glptr_glUniform4iv(location, count, value);
}
PFN_glUniform4iv _glptr_glUniform4iv = _impl_glUniform4iv;

static void  GL_APIENTRY _impl_glUniform1iv (GLint location, GLsizei count, const GLint * value) {
  _glptr_glUniform1iv = (PFN_glUniform1iv)GalogenGetProcAddress("glUniform1iv");
   _glptr_glUniform1iv(location, count, value);
}
PFN_glUniform1iv _glptr_glUniform1iv = _impl_glUniform1iv;

static void  GL_APIENTRY _impl_glUniform4fv (GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glUniform4fv = (PFN_glUniform4fv)GalogenGetProcAddress("glUniform4fv");
   _glptr_glUniform4fv(location, count, value);
}
PFN_glUniform4fv _glptr_glUniform4fv = _impl_glUniform4fv;

static void  GL_APIENTRY _impl_glUniform2fv (GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glUniform2fv = (PFN_glUniform2fv)GalogenGetProcAddress("glUniform2fv");
   _glptr_glUniform2fv(location, count, value);
}
PFN_glUniform2fv _glptr_glUniform2fv = _impl_glUniform2fv;

static void  GL_APIENTRY _impl_glProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) {
  _glptr_glProgramUniform3ui = (PFN_glProgramUniform3ui)GalogenGetProcAddress("glProgramUniform3ui");
   _glptr_glProgramUniform3ui(program, location, v0, v1, v2);
}
PFN_glProgramUniform3ui _glptr_glProgramUniform3ui = _impl_glProgramUniform3ui;

static void  GL_APIENTRY _impl_glUniform3i (GLint location, GLint v0, GLint v1, GLint v2) {
  _glptr_glUniform3i = (PFN_glUniform3i)GalogenGetProcAddress("glUniform3i");
   _glptr_glUniform3i(location, v0, v1, v2);
}
PFN_glUniform3i _glptr_glUniform3i = _impl_glUniform3i;

static void  GL_APIENTRY _impl_glUniform2i (GLint location, GLint v0, GLint v1) {
  _glptr_glUniform2i = (PFN_glUniform2i)GalogenGetProcAddress("glUniform2i");
   _glptr_glUniform2i(location, v0, v1);
}
PFN_glUniform2i _glptr_glUniform2i = _impl_glUniform2i;

static void  GL_APIENTRY _impl_glUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
  _glptr_glUniform4f = (PFN_glUniform4f)GalogenGetProcAddress("glUniform4f");
   _glptr_glUniform4f(location, v0, v1, v2, v3);
}
PFN_glUniform4f _glptr_glUniform4f = _impl_glUniform4f;

static void  GL_APIENTRY _impl_glUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
  _glptr_glUniform3f = (PFN_glUniform3f)GalogenGetProcAddress("glUniform3f");
   _glptr_glUniform3f(location, v0, v1, v2);
}
PFN_glUniform3f _glptr_glUniform3f = _impl_glUniform3f;

static void  GL_APIENTRY _impl_glUniform1f (GLint location, GLfloat v0) {
  _glptr_glUniform1f = (PFN_glUniform1f)GalogenGetProcAddress("glUniform1f");
   _glptr_glUniform1f(location, v0);
}
PFN_glUniform1f _glptr_glUniform1f = _impl_glUniform1f;

static void  GL_APIENTRY _impl_glUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix2x3dv = (PFN_glUniformMatrix2x3dv)GalogenGetProcAddress("glUniformMatrix2x3dv");
   _glptr_glUniformMatrix2x3dv(location, count, transpose, value);
}
PFN_glUniformMatrix2x3dv _glptr_glUniformMatrix2x3dv = _impl_glUniformMatrix2x3dv;

static void  GL_APIENTRY _impl_glUseProgram (GLuint program) {
  _glptr_glUseProgram = (PFN_glUseProgram)GalogenGetProcAddress("glUseProgram");
   _glptr_glUseProgram(program);
}
PFN_glUseProgram _glptr_glUseProgram = _impl_glUseProgram;

static void  GL_APIENTRY _impl_glShaderSource (GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length) {
  _glptr_glShaderSource = (PFN_glShaderSource)GalogenGetProcAddress("glShaderSource");
   _glptr_glShaderSource(shader, count, string, length);
}
PFN_glShaderSource _glptr_glShaderSource = _impl_glShaderSource;

static void  GL_APIENTRY _impl_glCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
  _glptr_glCopyImageSubData = (PFN_glCopyImageSubData)GalogenGetProcAddress("glCopyImageSubData");
   _glptr_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
PFN_glCopyImageSubData _glptr_glCopyImageSubData = _impl_glCopyImageSubData;

static void  GL_APIENTRY _impl_glLinkProgram (GLuint program) {
  _glptr_glLinkProgram = (PFN_glLinkProgram)GalogenGetProcAddress("glLinkProgram");
   _glptr_glLinkProgram(program);
}
PFN_glLinkProgram _glptr_glLinkProgram = _impl_glLinkProgram;

static GLboolean GL_APIENTRY _impl_glIsShader (GLuint shader) {
  _glptr_glIsShader = (PFN_glIsShader)GalogenGetProcAddress("glIsShader");
  return _glptr_glIsShader(shader);
}
PFN_glIsShader _glptr_glIsShader = _impl_glIsShader;

static void  GL_APIENTRY _impl_glUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix3dv = (PFN_glUniformMatrix3dv)GalogenGetProcAddress("glUniformMatrix3dv");
   _glptr_glUniformMatrix3dv(location, count, transpose, value);
}
PFN_glUniformMatrix3dv _glptr_glUniformMatrix3dv = _impl_glUniformMatrix3dv;

static void  GL_APIENTRY _impl_glGetVertexAttribPointerv (GLuint index, GLenum pname, void ** pointer) {
  _glptr_glGetVertexAttribPointerv = (PFN_glGetVertexAttribPointerv)GalogenGetProcAddress("glGetVertexAttribPointerv");
   _glptr_glGetVertexAttribPointerv(index, pname, pointer);
}
PFN_glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv = _impl_glGetVertexAttribPointerv;

static void  GL_APIENTRY _impl_glGetVertexAttribiv (GLuint index, GLenum pname, GLint * params) {
  _glptr_glGetVertexAttribiv = (PFN_glGetVertexAttribiv)GalogenGetProcAddress("glGetVertexAttribiv");
   _glptr_glGetVertexAttribiv(index, pname, params);
}
PFN_glGetVertexAttribiv _glptr_glGetVertexAttribiv = _impl_glGetVertexAttribiv;

static void  GL_APIENTRY _impl_glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat * params) {
  _glptr_glGetVertexAttribfv = (PFN_glGetVertexAttribfv)GalogenGetProcAddress("glGetVertexAttribfv");
   _glptr_glGetVertexAttribfv(index, pname, params);
}
PFN_glGetVertexAttribfv _glptr_glGetVertexAttribfv = _impl_glGetVertexAttribfv;

static void  GL_APIENTRY _impl_glUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
  _glptr_glUniformBlockBinding = (PFN_glUniformBlockBinding)GalogenGetProcAddress("glUniformBlockBinding");
   _glptr_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
PFN_glUniformBlockBinding _glptr_glUniformBlockBinding = _impl_glUniformBlockBinding;

static GLint GL_APIENTRY _impl_glGetUniformLocation (GLuint program, const GLchar * name) {
  _glptr_glGetUniformLocation = (PFN_glGetUniformLocation)GalogenGetProcAddress("glGetUniformLocation");
  return _glptr_glGetUniformLocation(program, name);
}
PFN_glGetUniformLocation _glptr_glGetUniformLocation = _impl_glGetUniformLocation;

static void  GL_APIENTRY _impl_glGetShaderiv (GLuint shader, GLenum pname, GLint * params) {
  _glptr_glGetShaderiv = (PFN_glGetShaderiv)GalogenGetProcAddress("glGetShaderiv");
   _glptr_glGetShaderiv(shader, pname, params);
}
PFN_glGetShaderiv _glptr_glGetShaderiv = _impl_glGetShaderiv;

static void  GL_APIENTRY _impl_glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
  _glptr_glGetProgramInfoLog = (PFN_glGetProgramInfoLog)GalogenGetProcAddress("glGetProgramInfoLog");
   _glptr_glGetProgramInfoLog(program, bufSize, length, infoLog);
}
PFN_glGetProgramInfoLog _glptr_glGetProgramInfoLog = _impl_glGetProgramInfoLog;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix2x3fv = (PFN_glProgramUniformMatrix2x3fv)GalogenGetProcAddress("glProgramUniformMatrix2x3fv");
   _glptr_glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2x3fv _glptr_glProgramUniformMatrix2x3fv = _impl_glProgramUniformMatrix2x3fv;

static GLint GL_APIENTRY _impl_glGetAttribLocation (GLuint program, const GLchar * name) {
  _glptr_glGetAttribLocation = (PFN_glGetAttribLocation)GalogenGetProcAddress("glGetAttribLocation");
  return _glptr_glGetAttribLocation(program, name);
}
PFN_glGetAttribLocation _glptr_glGetAttribLocation = _impl_glGetAttribLocation;

static void  GL_APIENTRY _impl_glBlitNamedFramebuffer (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
  _glptr_glBlitNamedFramebuffer = (PFN_glBlitNamedFramebuffer)GalogenGetProcAddress("glBlitNamedFramebuffer");
   _glptr_glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
PFN_glBlitNamedFramebuffer _glptr_glBlitNamedFramebuffer = _impl_glBlitNamedFramebuffer;

static void  GL_APIENTRY _impl_glGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders) {
  _glptr_glGetAttachedShaders = (PFN_glGetAttachedShaders)GalogenGetProcAddress("glGetAttachedShaders");
   _glptr_glGetAttachedShaders(program, maxCount, count, shaders);
}
PFN_glGetAttachedShaders _glptr_glGetAttachedShaders = _impl_glGetAttachedShaders;

static void  GL_APIENTRY _impl_glGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
  _glptr_glGetActiveUniform = (PFN_glGetActiveUniform)GalogenGetProcAddress("glGetActiveUniform");
   _glptr_glGetActiveUniform(program, index, bufSize, length, size, type, name);
}
PFN_glGetActiveUniform _glptr_glGetActiveUniform = _impl_glGetActiveUniform;

static void  GL_APIENTRY _impl_glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {
  _glptr_glGetActiveAttrib = (PFN_glGetActiveAttrib)GalogenGetProcAddress("glGetActiveAttrib");
   _glptr_glGetActiveAttrib(program, index, bufSize, length, size, type, name);
}
PFN_glGetActiveAttrib _glptr_glGetActiveAttrib = _impl_glGetActiveAttrib;

static void  GL_APIENTRY _impl_glVertexAttrib4iv (GLuint index, const GLint * v) {
  _glptr_glVertexAttrib4iv = (PFN_glVertexAttrib4iv)GalogenGetProcAddress("glVertexAttrib4iv");
   _glptr_glVertexAttrib4iv(index, v);
}
PFN_glVertexAttrib4iv _glptr_glVertexAttrib4iv = _impl_glVertexAttrib4iv;

static void  GL_APIENTRY _impl_glDisableVertexAttribArray (GLuint index) {
  _glptr_glDisableVertexAttribArray = (PFN_glDisableVertexAttribArray)GalogenGetProcAddress("glDisableVertexAttribArray");
   _glptr_glDisableVertexAttribArray(index);
}
PFN_glDisableVertexAttribArray _glptr_glDisableVertexAttribArray = _impl_glDisableVertexAttribArray;

static void  GL_APIENTRY _impl_glDeleteShader (GLuint shader) {
#ifdef LEAK_COUNTER
	leak_shaders--;
	PFN_glDeleteShader
#endif

  _glptr_glDeleteShader = (PFN_glDeleteShader)GalogenGetProcAddress("glDeleteShader");
   _glptr_glDeleteShader(shader);
}
PFN_glDeleteShader _glptr_glDeleteShader = _impl_glDeleteShader;

static void  GL_APIENTRY _impl_glProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint * value) {
  _glptr_glProgramUniform3uiv = (PFN_glProgramUniform3uiv)GalogenGetProcAddress("glProgramUniform3uiv");
   _glptr_glProgramUniform3uiv(program, location, count, value);
}
PFN_glProgramUniform3uiv _glptr_glProgramUniform3uiv = _impl_glProgramUniform3uiv;

static void  GL_APIENTRY _impl_glDeleteProgram (GLuint program) {
#ifdef LEAK_COUNTER
	leak_programs -= 1;
	PFN_glDeleteProgram
#endif

  _glptr_glDeleteProgram = (PFN_glDeleteProgram)GalogenGetProcAddress("glDeleteProgram");
   _glptr_glDeleteProgram(program);
}
PFN_glDeleteProgram _glptr_glDeleteProgram = _impl_glDeleteProgram;

static void  GL_APIENTRY _impl_glGetBooleani_v (GLenum target, GLuint index, GLboolean * data) {
  _glptr_glGetBooleani_v = (PFN_glGetBooleani_v)GalogenGetProcAddress("glGetBooleani_v");
   _glptr_glGetBooleani_v(target, index, data);
}
PFN_glGetBooleani_v _glptr_glGetBooleani_v = _impl_glGetBooleani_v;

static void  GL_APIENTRY _impl_glCompileShader (GLuint shader) {
  _glptr_glCompileShader = (PFN_glCompileShader)GalogenGetProcAddress("glCompileShader");
   _glptr_glCompileShader(shader);
}
PFN_glCompileShader _glptr_glCompileShader = _impl_glCompileShader;

static void  GL_APIENTRY _impl_glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask) {
  _glptr_glStencilFuncSeparate = (PFN_glStencilFuncSeparate)GalogenGetProcAddress("glStencilFuncSeparate");
   _glptr_glStencilFuncSeparate(face, func, ref, mask);
}
PFN_glStencilFuncSeparate _glptr_glStencilFuncSeparate = _impl_glStencilFuncSeparate;

static void  GL_APIENTRY _impl_glStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
  _glptr_glStencilOpSeparate = (PFN_glStencilOpSeparate)GalogenGetProcAddress("glStencilOpSeparate");
   _glptr_glStencilOpSeparate(face, sfail, dpfail, dppass);
}
PFN_glStencilOpSeparate _glptr_glStencilOpSeparate = _impl_glStencilOpSeparate;

static void  GL_APIENTRY _impl_glRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glRenderbufferStorageMultisample = (PFN_glRenderbufferStorageMultisample)GalogenGetProcAddress("glRenderbufferStorageMultisample");
   _glptr_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
PFN_glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample = _impl_glRenderbufferStorageMultisample;

static void  GL_APIENTRY _impl_glDrawBuffers (GLsizei n, const GLenum * bufs) {
  _glptr_glDrawBuffers = (PFN_glDrawBuffers)GalogenGetProcAddress("glDrawBuffers");
   _glptr_glDrawBuffers(n, bufs);
}
PFN_glDrawBuffers _glptr_glDrawBuffers = _impl_glDrawBuffers;

static void  GL_APIENTRY _impl_glGetBufferParameteriv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetBufferParameteriv = (PFN_glGetBufferParameteriv)GalogenGetProcAddress("glGetBufferParameteriv");
   _glptr_glGetBufferParameteriv(target, pname, params);
}
PFN_glGetBufferParameteriv _glptr_glGetBufferParameteriv = _impl_glGetBufferParameteriv;

static void  GL_APIENTRY _impl_glVertexAttribDivisor (GLuint index, GLuint divisor) {
  _glptr_glVertexAttribDivisor = (PFN_glVertexAttribDivisor)GalogenGetProcAddress("glVertexAttribDivisor");
   _glptr_glVertexAttribDivisor(index, divisor);
}
PFN_glVertexAttribDivisor _glptr_glVertexAttribDivisor = _impl_glVertexAttribDivisor;

static GLboolean GL_APIENTRY _impl_glUnmapBuffer (GLenum target) {
  _glptr_glUnmapBuffer = (PFN_glUnmapBuffer)GalogenGetProcAddress("glUnmapBuffer");
  return _glptr_glUnmapBuffer(target);
}
PFN_glUnmapBuffer _glptr_glUnmapBuffer = _impl_glUnmapBuffer;

static void  GL_APIENTRY _impl_glGetCompressedTextureImage (GLuint texture, GLint level, GLsizei bufSize, void * pixels) {
  _glptr_glGetCompressedTextureImage = (PFN_glGetCompressedTextureImage)GalogenGetProcAddress("glGetCompressedTextureImage");
   _glptr_glGetCompressedTextureImage(texture, level, bufSize, pixels);
}
PFN_glGetCompressedTextureImage _glptr_glGetCompressedTextureImage = _impl_glGetCompressedTextureImage;

static void  GL_APIENTRY _impl_glDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f) {
  _glptr_glDepthRangeIndexed = (PFN_glDepthRangeIndexed)GalogenGetProcAddress("glDepthRangeIndexed");
   _glptr_glDepthRangeIndexed(index, n, f);
}
PFN_glDepthRangeIndexed _glptr_glDepthRangeIndexed = _impl_glDepthRangeIndexed;

static void  GL_APIENTRY _impl_glVertexAttrib4dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttrib4dv = (PFN_glVertexAttrib4dv)GalogenGetProcAddress("glVertexAttrib4dv");
   _glptr_glVertexAttrib4dv(index, v);
}
PFN_glVertexAttrib4dv _glptr_glVertexAttrib4dv = _impl_glVertexAttrib4dv;

static void * GL_APIENTRY _impl_glMapBuffer (GLenum target, GLenum access) {
  _glptr_glMapBuffer = (PFN_glMapBuffer)GalogenGetProcAddress("glMapBuffer");
  return _glptr_glMapBuffer(target, access);
}
PFN_glMapBuffer _glptr_glMapBuffer = _impl_glMapBuffer;

static void  GL_APIENTRY _impl_glUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix2x4dv = (PFN_glUniformMatrix2x4dv)GalogenGetProcAddress("glUniformMatrix2x4dv");
   _glptr_glUniformMatrix2x4dv(location, count, transpose, value);
}
PFN_glUniformMatrix2x4dv _glptr_glUniformMatrix2x4dv = _impl_glUniformMatrix2x4dv;

static void  GL_APIENTRY _impl_glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void * data) {
  _glptr_glBufferSubData = (PFN_glBufferSubData)GalogenGetProcAddress("glBufferSubData");
   _glptr_glBufferSubData(target, offset, size, data);
}
PFN_glBufferSubData _glptr_glBufferSubData = _impl_glBufferSubData;

static void  GL_APIENTRY _impl_glGetQueryObjectuiv (GLuint id, GLenum pname, GLuint * params) {
  _glptr_glGetQueryObjectuiv = (PFN_glGetQueryObjectuiv)GalogenGetProcAddress("glGetQueryObjectuiv");
   _glptr_glGetQueryObjectuiv(id, pname, params);
}
PFN_glGetQueryObjectuiv _glptr_glGetQueryObjectuiv = _impl_glGetQueryObjectuiv;

static void  GL_APIENTRY _impl_glGetQueryObjectiv (GLuint id, GLenum pname, GLint * params) {
  _glptr_glGetQueryObjectiv = (PFN_glGetQueryObjectiv)GalogenGetProcAddress("glGetQueryObjectiv");
   _glptr_glGetQueryObjectiv(id, pname, params);
}
PFN_glGetQueryObjectiv _glptr_glGetQueryObjectiv = _impl_glGetQueryObjectiv;

static void  GL_APIENTRY _impl_glTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
  _glptr_glTextureView = (PFN_glTextureView)GalogenGetProcAddress("glTextureView");
   _glptr_glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
PFN_glTextureView _glptr_glTextureView = _impl_glTextureView;

static GLboolean GL_APIENTRY _impl_glIsQuery (GLuint id) {
  _glptr_glIsQuery = (PFN_glIsQuery)GalogenGetProcAddress("glIsQuery");
  return _glptr_glIsQuery(id);
}
PFN_glIsQuery _glptr_glIsQuery = _impl_glIsQuery;

static void  GL_APIENTRY _impl_glDeleteQueries (GLsizei n, const GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_queries -= n;
	PFN_glDeleteQueries
#endif

  _glptr_glDeleteQueries = (PFN_glDeleteQueries)GalogenGetProcAddress("glDeleteQueries");
   _glptr_glDeleteQueries(n, ids);
}
PFN_glDeleteQueries _glptr_glDeleteQueries = _impl_glDeleteQueries;

static void  GL_APIENTRY _impl_glGenQueries (GLsizei n, GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_queries += n;
	PFN_glGenQueries
#endif

  _glptr_glGenQueries = (PFN_glGenQueries)GalogenGetProcAddress("glGenQueries");
   _glptr_glGenQueries(n, ids);
}
PFN_glGenQueries _glptr_glGenQueries = _impl_glGenQueries;

static void  GL_APIENTRY _impl_glBlendEquation (GLenum mode) {
  _glptr_glBlendEquation = (PFN_glBlendEquation)GalogenGetProcAddress("glBlendEquation");
   _glptr_glBlendEquation(mode);
}
PFN_glBlendEquation _glptr_glBlendEquation = _impl_glBlendEquation;

static void  GL_APIENTRY _impl_glVertexAttrib3sv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttrib3sv = (PFN_glVertexAttrib3sv)GalogenGetProcAddress("glVertexAttrib3sv");
   _glptr_glVertexAttrib3sv(index, v);
}
PFN_glVertexAttrib3sv _glptr_glVertexAttrib3sv = _impl_glVertexAttrib3sv;

static void  GL_APIENTRY _impl_glVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z) {
  _glptr_glVertexAttribI3ui = (PFN_glVertexAttribI3ui)GalogenGetProcAddress("glVertexAttribI3ui");
   _glptr_glVertexAttribI3ui(index, x, y, z);
}
PFN_glVertexAttribI3ui _glptr_glVertexAttribI3ui = _impl_glVertexAttribI3ui;

static void  GL_APIENTRY _impl_glGetNamedBufferParameteriv (GLuint buffer, GLenum pname, GLint * params) {
  _glptr_glGetNamedBufferParameteriv = (PFN_glGetNamedBufferParameteriv)GalogenGetProcAddress("glGetNamedBufferParameteriv");
   _glptr_glGetNamedBufferParameteriv(buffer, pname, params);
}
PFN_glGetNamedBufferParameteriv _glptr_glGetNamedBufferParameteriv = _impl_glGetNamedBufferParameteriv;

static void  GL_APIENTRY _impl_glGenBuffers (GLsizei n, GLuint * buffers) {
#ifdef LEAK_COUNTER
	leak_buffers += n;
	PFN_glGenBuffers
#endif

  _glptr_glGenBuffers = (PFN_glGenBuffers)GalogenGetProcAddress("glGenBuffers");
   _glptr_glGenBuffers(n, buffers);
}
PFN_glGenBuffers _glptr_glGenBuffers = _impl_glGenBuffers;

static GLenum GL_APIENTRY _impl_glCheckNamedFramebufferStatus (GLuint framebuffer, GLenum target) {
  _glptr_glCheckNamedFramebufferStatus = (PFN_glCheckNamedFramebufferStatus)GalogenGetProcAddress("glCheckNamedFramebufferStatus");
  return _glptr_glCheckNamedFramebufferStatus(framebuffer, target);
}
PFN_glCheckNamedFramebufferStatus _glptr_glCheckNamedFramebufferStatus = _impl_glCheckNamedFramebufferStatus;

static GLuint GL_APIENTRY _impl_glGetDebugMessageLog (GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog) {
  _glptr_glGetDebugMessageLog = (PFN_glGetDebugMessageLog)GalogenGetProcAddress("glGetDebugMessageLog");
  return _glptr_glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}
PFN_glGetDebugMessageLog _glptr_glGetDebugMessageLog = _impl_glGetDebugMessageLog;

static GLenum GL_APIENTRY _impl_glCheckFramebufferStatus (GLenum target) {
  _glptr_glCheckFramebufferStatus = (PFN_glCheckFramebufferStatus)GalogenGetProcAddress("glCheckFramebufferStatus");
  return _glptr_glCheckFramebufferStatus(target);
}
PFN_glCheckFramebufferStatus _glptr_glCheckFramebufferStatus = _impl_glCheckFramebufferStatus;

static void  GL_APIENTRY _impl_glUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
  _glptr_glUniform4i = (PFN_glUniform4i)GalogenGetProcAddress("glUniform4i");
   _glptr_glUniform4i(location, v0, v1, v2, v3);
}
PFN_glUniform4i _glptr_glUniform4i = _impl_glUniform4i;

static void  GL_APIENTRY _impl_glPointParameteriv (GLenum pname, const GLint * params) {
  _glptr_glPointParameteriv = (PFN_glPointParameteriv)GalogenGetProcAddress("glPointParameteriv");
   _glptr_glPointParameteriv(pname, params);
}
PFN_glPointParameteriv _glptr_glPointParameteriv = _impl_glPointParameteriv;

static void  GL_APIENTRY _impl_glVertexAttrib2s (GLuint index, GLshort x, GLshort y) {
  _glptr_glVertexAttrib2s = (PFN_glVertexAttrib2s)GalogenGetProcAddress("glVertexAttrib2s");
   _glptr_glVertexAttrib2s(index, x, y);
}
PFN_glVertexAttrib2s _glptr_glVertexAttrib2s = _impl_glVertexAttrib2s;

static void  GL_APIENTRY _impl_glFinish () {
  _glptr_glFinish = (PFN_glFinish)GalogenGetProcAddress("glFinish");
   _glptr_glFinish();
}
PFN_glFinish _glptr_glFinish = _impl_glFinish;

static void  GL_APIENTRY _impl_glPointParameteri (GLenum pname, GLint param) {
  _glptr_glPointParameteri = (PFN_glPointParameteri)GalogenGetProcAddress("glPointParameteri");
   _glptr_glPointParameteri(pname, param);
}
PFN_glPointParameteri _glptr_glPointParameteri = _impl_glPointParameteri;

static void  GL_APIENTRY _impl_glMultiDrawArrays (GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount) {
  _glptr_glMultiDrawArrays = (PFN_glMultiDrawArrays)GalogenGetProcAddress("glMultiDrawArrays");
   _glptr_glMultiDrawArrays(mode, first, count, drawcount);
}
PFN_glMultiDrawArrays _glptr_glMultiDrawArrays = _impl_glMultiDrawArrays;

static void  GL_APIENTRY _impl_glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
  _glptr_glFramebufferRenderbuffer = (PFN_glFramebufferRenderbuffer)GalogenGetProcAddress("glFramebufferRenderbuffer");
   _glptr_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
PFN_glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer = _impl_glFramebufferRenderbuffer;

static void  GL_APIENTRY _impl_glGetTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void * pixels) {
  _glptr_glGetTextureSubImage = (PFN_glGetTextureSubImage)GalogenGetProcAddress("glGetTextureSubImage");
   _glptr_glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
}
PFN_glGetTextureSubImage _glptr_glGetTextureSubImage = _impl_glGetTextureSubImage;

static void  GL_APIENTRY _impl_glGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble * params) {
  _glptr_glGetVertexAttribLdv = (PFN_glGetVertexAttribLdv)GalogenGetProcAddress("glGetVertexAttribLdv");
   _glptr_glGetVertexAttribLdv(index, pname, params);
}
PFN_glGetVertexAttribLdv _glptr_glGetVertexAttribLdv = _impl_glGetVertexAttribLdv;

static GLint GL_APIENTRY _impl_glGetFragDataIndex (GLuint program, const GLchar * name) {
  _glptr_glGetFragDataIndex = (PFN_glGetFragDataIndex)GalogenGetProcAddress("glGetFragDataIndex");
  return _glptr_glGetFragDataIndex(program, name);
}
PFN_glGetFragDataIndex _glptr_glGetFragDataIndex = _impl_glGetFragDataIndex;

static void  GL_APIENTRY _impl_glGetQueryiv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetQueryiv = (PFN_glGetQueryiv)GalogenGetProcAddress("glGetQueryiv");
   _glptr_glGetQueryiv(target, pname, params);
}
PFN_glGetQueryiv _glptr_glGetQueryiv = _impl_glGetQueryiv;

static void  GL_APIENTRY _impl_glGetUniformfv (GLuint program, GLint location, GLfloat * params) {
  _glptr_glGetUniformfv = (PFN_glGetUniformfv)GalogenGetProcAddress("glGetUniformfv");
   _glptr_glGetUniformfv(program, location, params);
}
PFN_glGetUniformfv _glptr_glGetUniformfv = _impl_glGetUniformfv;

static void  GL_APIENTRY _impl_glVertexAttrib4usv (GLuint index, const GLushort * v) {
  _glptr_glVertexAttrib4usv = (PFN_glVertexAttrib4usv)GalogenGetProcAddress("glVertexAttrib4usv");
   _glptr_glVertexAttrib4usv(index, v);
}
PFN_glVertexAttrib4usv _glptr_glVertexAttrib4usv = _impl_glVertexAttrib4usv;

static void  GL_APIENTRY _impl_glDeleteSync (GLsync sync) {
  _glptr_glDeleteSync = (PFN_glDeleteSync)GalogenGetProcAddress("glDeleteSync");
   _glptr_glDeleteSync(sync);
}
PFN_glDeleteSync _glptr_glDeleteSync = _impl_glDeleteSync;

static void  GL_APIENTRY _impl_glVertexAttribL1d (GLuint index, GLdouble x) {
  _glptr_glVertexAttribL1d = (PFN_glVertexAttribL1d)GalogenGetProcAddress("glVertexAttribL1d");
   _glptr_glVertexAttribL1d(index, x);
}
PFN_glVertexAttribL1d _glptr_glVertexAttribL1d = _impl_glVertexAttribL1d;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix2x3dv = (PFN_glProgramUniformMatrix2x3dv)GalogenGetProcAddress("glProgramUniformMatrix2x3dv");
   _glptr_glProgramUniformMatrix2x3dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2x3dv _glptr_glProgramUniformMatrix2x3dv = _impl_glProgramUniformMatrix2x3dv;

static void  GL_APIENTRY _impl_glGetCompressedTexImage (GLenum target, GLint level, void * img) {
  _glptr_glGetCompressedTexImage = (PFN_glGetCompressedTexImage)GalogenGetProcAddress("glGetCompressedTexImage");
   _glptr_glGetCompressedTexImage(target, level, img);
}
PFN_glGetCompressedTexImage _glptr_glGetCompressedTexImage = _impl_glGetCompressedTexImage;

static void  GL_APIENTRY _impl_glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexSubImage2D = (PFN_glCompressedTexSubImage2D)GalogenGetProcAddress("glCompressedTexSubImage2D");
   _glptr_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
PFN_glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D = _impl_glCompressedTexSubImage2D;

static void  GL_APIENTRY _impl_glGetTextureLevelParameteriv (GLuint texture, GLint level, GLenum pname, GLint * params) {
  _glptr_glGetTextureLevelParameteriv = (PFN_glGetTextureLevelParameteriv)GalogenGetProcAddress("glGetTextureLevelParameteriv");
   _glptr_glGetTextureLevelParameteriv(texture, level, pname, params);
}
PFN_glGetTextureLevelParameteriv _glptr_glGetTextureLevelParameteriv = _impl_glGetTextureLevelParameteriv;

static void  GL_APIENTRY _impl_glUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
  _glptr_glUniform4ui = (PFN_glUniform4ui)GalogenGetProcAddress("glUniform4ui");
   _glptr_glUniform4ui(location, v0, v1, v2, v3);
}
PFN_glUniform4ui _glptr_glUniform4ui = _impl_glUniform4ui;

static void  GL_APIENTRY _impl_glVertexAttribI4usv (GLuint index, const GLushort * v) {
  _glptr_glVertexAttribI4usv = (PFN_glVertexAttribI4usv)GalogenGetProcAddress("glVertexAttribI4usv");
   _glptr_glVertexAttribI4usv(index, v);
}
PFN_glVertexAttribI4usv _glptr_glVertexAttribI4usv = _impl_glVertexAttribI4usv;

static void  GL_APIENTRY _impl_glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexImage2D = (PFN_glCompressedTexImage2D)GalogenGetProcAddress("glCompressedTexImage2D");
   _glptr_glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
PFN_glCompressedTexImage2D _glptr_glCompressedTexImage2D = _impl_glCompressedTexImage2D;

static void  GL_APIENTRY _impl_glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexImage3D = (PFN_glCompressedTexImage3D)GalogenGetProcAddress("glCompressedTexImage3D");
   _glptr_glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}
PFN_glCompressedTexImage3D _glptr_glCompressedTexImage3D = _impl_glCompressedTexImage3D;

static void  GL_APIENTRY _impl_glSampleCoverage (GLfloat value, GLboolean invert) {
  _glptr_glSampleCoverage = (PFN_glSampleCoverage)GalogenGetProcAddress("glSampleCoverage");
   _glptr_glSampleCoverage(value, invert);
}
PFN_glSampleCoverage _glptr_glSampleCoverage = _impl_glSampleCoverage;

static GLint GL_APIENTRY _impl_glGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar * name) {
  _glptr_glGetProgramResourceLocation = (PFN_glGetProgramResourceLocation)GalogenGetProcAddress("glGetProgramResourceLocation");
  return _glptr_glGetProgramResourceLocation(program, programInterface, name);
}
PFN_glGetProgramResourceLocation _glptr_glGetProgramResourceLocation = _impl_glGetProgramResourceLocation;

static void  GL_APIENTRY _impl_glActiveTexture (GLenum texture) {
  _glptr_glActiveTexture = (PFN_glActiveTexture)GalogenGetProcAddress("glActiveTexture");
   _glptr_glActiveTexture(texture);
}
PFN_glActiveTexture _glptr_glActiveTexture = _impl_glActiveTexture;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix4x2dv = (PFN_glProgramUniformMatrix4x2dv)GalogenGetProcAddress("glProgramUniformMatrix4x2dv");
   _glptr_glProgramUniformMatrix4x2dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4x2dv _glptr_glProgramUniformMatrix4x2dv = _impl_glProgramUniformMatrix4x2dv;

static void  GL_APIENTRY _impl_glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glCopyTexSubImage3D = (PFN_glCopyTexSubImage3D)GalogenGetProcAddress("glCopyTexSubImage3D");
   _glptr_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
PFN_glCopyTexSubImage3D _glptr_glCopyTexSubImage3D = _impl_glCopyTexSubImage3D;

static void  GL_APIENTRY _impl_glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexImage1D = (PFN_glCompressedTexImage1D)GalogenGetProcAddress("glCompressedTexImage1D");
   _glptr_glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}
PFN_glCompressedTexImage1D _glptr_glCompressedTexImage1D = _impl_glCompressedTexImage1D;

static void  GL_APIENTRY _impl_glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexSubImage3D = (PFN_glTexSubImage3D)GalogenGetProcAddress("glTexSubImage3D");
   _glptr_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
PFN_glTexSubImage3D _glptr_glTexSubImage3D = _impl_glTexSubImage3D;

static void  GL_APIENTRY _impl_glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix4fv = (PFN_glUniformMatrix4fv)GalogenGetProcAddress("glUniformMatrix4fv");
   _glptr_glUniformMatrix4fv(location, count, transpose, value);
}
PFN_glUniformMatrix4fv _glptr_glUniformMatrix4fv = _impl_glUniformMatrix4fv;

static void  GL_APIENTRY _impl_glObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar * label) {
  _glptr_glObjectLabel = (PFN_glObjectLabel)GalogenGetProcAddress("glObjectLabel");
   _glptr_glObjectLabel(identifier, name, length, label);
}
PFN_glObjectLabel _glptr_glObjectLabel = _impl_glObjectLabel;

static const GLubyte * GL_APIENTRY _impl_glGetString (GLenum name) {
  _glptr_glGetString = (PFN_glGetString)GalogenGetProcAddress("glGetString");
  return _glptr_glGetString(name);
}
PFN_glGetString _glptr_glGetString = _impl_glGetString;

static void  GL_APIENTRY _impl_glUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glUniformMatrix4x2dv = (PFN_glUniformMatrix4x2dv)GalogenGetProcAddress("glUniformMatrix4x2dv");
   _glptr_glUniformMatrix4x2dv(location, count, transpose, value);
}
PFN_glUniformMatrix4x2dv _glptr_glUniformMatrix4x2dv = _impl_glUniformMatrix4x2dv;

static void  GL_APIENTRY _impl_glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
  _glptr_glRenderbufferStorage = (PFN_glRenderbufferStorage)GalogenGetProcAddress("glRenderbufferStorage");
   _glptr_glRenderbufferStorage(target, internalformat, width, height);
}
PFN_glRenderbufferStorage _glptr_glRenderbufferStorage = _impl_glRenderbufferStorage;

static GLboolean GL_APIENTRY _impl_glIsTexture (GLuint texture) {
  _glptr_glIsTexture = (PFN_glIsTexture)GalogenGetProcAddress("glIsTexture");
  return _glptr_glIsTexture(texture);
}
PFN_glIsTexture _glptr_glIsTexture = _impl_glIsTexture;

static void  GL_APIENTRY _impl_glGetNamedFramebufferAttachmentParameteriv (GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params) {
  _glptr_glGetNamedFramebufferAttachmentParameteriv = (PFN_glGetNamedFramebufferAttachmentParameteriv)GalogenGetProcAddress("glGetNamedFramebufferAttachmentParameteriv");
   _glptr_glGetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
}
PFN_glGetNamedFramebufferAttachmentParameteriv _glptr_glGetNamedFramebufferAttachmentParameteriv = _impl_glGetNamedFramebufferAttachmentParameteriv;

static void  GL_APIENTRY _impl_glGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint * params) {
  _glptr_glGetActiveAtomicCounterBufferiv = (PFN_glGetActiveAtomicCounterBufferiv)GalogenGetProcAddress("glGetActiveAtomicCounterBufferiv");
   _glptr_glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}
PFN_glGetActiveAtomicCounterBufferiv _glptr_glGetActiveAtomicCounterBufferiv = _impl_glGetActiveAtomicCounterBufferiv;

static void  GL_APIENTRY _impl_glGenTextures (GLsizei n, GLuint * textures) {
#ifdef LEAK_COUNTER
	leak_textures += n;
	PFN_glGenTextures
#endif

  _glptr_glGenTextures = (PFN_glGenTextures)GalogenGetProcAddress("glGenTextures");
   _glptr_glGenTextures(n, textures);
}
PFN_glGenTextures _glptr_glGenTextures = _impl_glGenTextures;

static void  GL_APIENTRY _impl_glVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
  _glptr_glVertexAttribP3ui = (PFN_glVertexAttribP3ui)GalogenGetProcAddress("glVertexAttribP3ui");
   _glptr_glVertexAttribP3ui(index, type, normalized, value);
}
PFN_glVertexAttribP3ui _glptr_glVertexAttribP3ui = _impl_glVertexAttribP3ui;

static void  GL_APIENTRY _impl_glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexSubImage1D = (PFN_glTexSubImage1D)GalogenGetProcAddress("glTexSubImage1D");
   _glptr_glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
}
PFN_glTexSubImage1D _glptr_glTexSubImage1D = _impl_glTexSubImage1D;

static void  GL_APIENTRY _impl_glTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) {
  _glptr_glTexStorage3D = (PFN_glTexStorage3D)GalogenGetProcAddress("glTexStorage3D");
   _glptr_glTexStorage3D(target, levels, internalformat, width, height, depth);
}
PFN_glTexStorage3D _glptr_glTexStorage3D = _impl_glTexStorage3D;

static GLenum GL_APIENTRY _impl_glClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) {
  _glptr_glClientWaitSync = (PFN_glClientWaitSync)GalogenGetProcAddress("glClientWaitSync");
  return _glptr_glClientWaitSync(sync, flags, timeout);
}
PFN_glClientWaitSync _glptr_glClientWaitSync = _impl_glClientWaitSync;

static void  GL_APIENTRY _impl_glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glCopyTexSubImage2D = (PFN_glCopyTexSubImage2D)GalogenGetProcAddress("glCopyTexSubImage2D");
   _glptr_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
PFN_glCopyTexSubImage2D _glptr_glCopyTexSubImage2D = _impl_glCopyTexSubImage2D;

static void  GL_APIENTRY _impl_glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {
  _glptr_glCopyTexSubImage1D = (PFN_glCopyTexSubImage1D)GalogenGetProcAddress("glCopyTexSubImage1D");
   _glptr_glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}
PFN_glCopyTexSubImage1D _glptr_glCopyTexSubImage1D = _impl_glCopyTexSubImage1D;

static void  GL_APIENTRY _impl_glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {
  _glptr_glCopyTexImage1D = (PFN_glCopyTexImage1D)GalogenGetProcAddress("glCopyTexImage1D");
   _glptr_glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}
PFN_glCopyTexImage1D _glptr_glCopyTexImage1D = _impl_glCopyTexImage1D;

static void  GL_APIENTRY _impl_glPolygonOffset (GLfloat factor, GLfloat units) {
  _glptr_glPolygonOffset = (PFN_glPolygonOffset)GalogenGetProcAddress("glPolygonOffset");
   _glptr_glPolygonOffset(factor, units);
}
PFN_glPolygonOffset _glptr_glPolygonOffset = _impl_glPolygonOffset;

static void  GL_APIENTRY _impl_glTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
  _glptr_glTexImage2DMultisample = (PFN_glTexImage2DMultisample)GalogenGetProcAddress("glTexImage2DMultisample");
   _glptr_glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}
PFN_glTexImage2DMultisample _glptr_glTexImage2DMultisample = _impl_glTexImage2DMultisample;

static void  GL_APIENTRY _impl_glDrawElements (GLenum mode, GLsizei count, GLenum type, const void * indices) {
  _glptr_glDrawElements = (PFN_glDrawElements)GalogenGetProcAddress("glDrawElements");
   _glptr_glDrawElements(mode, count, type, indices);
}
PFN_glDrawElements _glptr_glDrawElements = _impl_glDrawElements;

static void  GL_APIENTRY _impl_glEndConditionalRender () {
  _glptr_glEndConditionalRender = (PFN_glEndConditionalRender)GalogenGetProcAddress("glEndConditionalRender");
   _glptr_glEndConditionalRender();
}
PFN_glEndConditionalRender _glptr_glEndConditionalRender = _impl_glEndConditionalRender;

static void  GL_APIENTRY _impl_glGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) {
  _glptr_glGetTransformFeedbackVarying = (PFN_glGetTransformFeedbackVarying)GalogenGetProcAddress("glGetTransformFeedbackVarying");
   _glptr_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}
PFN_glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying = _impl_glGetTransformFeedbackVarying;

static void  GL_APIENTRY _impl_glTexParameteriv (GLenum target, GLenum pname, const GLint * params) {
  _glptr_glTexParameteriv = (PFN_glTexParameteriv)GalogenGetProcAddress("glTexParameteriv");
   _glptr_glTexParameteriv(target, pname, params);
}
PFN_glTexParameteriv _glptr_glTexParameteriv = _impl_glTexParameteriv;

static void  GL_APIENTRY _impl_glDeleteFramebuffers (GLsizei n, const GLuint * framebuffers) {
#ifdef LEAK_COUNTER
	leak_framebuffers -= n;
	PFN_glDeleteFramebuffers
#endif

  _glptr_glDeleteFramebuffers = (PFN_glDeleteFramebuffers)GalogenGetProcAddress("glDeleteFramebuffers");
   _glptr_glDeleteFramebuffers(n, framebuffers);
}
PFN_glDeleteFramebuffers _glptr_glDeleteFramebuffers = _impl_glDeleteFramebuffers;

static void  GL_APIENTRY _impl_glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha) {
  _glptr_glBlendEquationSeparate = (PFN_glBlendEquationSeparate)GalogenGetProcAddress("glBlendEquationSeparate");
   _glptr_glBlendEquationSeparate(modeRGB, modeAlpha);
}
PFN_glBlendEquationSeparate _glptr_glBlendEquationSeparate = _impl_glBlendEquationSeparate;

static void  GL_APIENTRY _impl_glDeleteTextures (GLsizei n, const GLuint * textures) {
#ifdef LEAK_COUNTER
	leak_textures -= n;
	PFN_glDeleteTextures
#endif

  _glptr_glDeleteTextures = (PFN_glDeleteTextures)GalogenGetProcAddress("glDeleteTextures");
   _glptr_glDeleteTextures(n, textures);
}
PFN_glDeleteTextures _glptr_glDeleteTextures = _impl_glDeleteTextures;

static void  GL_APIENTRY _impl_glGetProgramiv (GLuint program, GLenum pname, GLint * params) {
  _glptr_glGetProgramiv = (PFN_glGetProgramiv)GalogenGetProcAddress("glGetProgramiv");
   _glptr_glGetProgramiv(program, pname, params);
}
PFN_glGetProgramiv _glptr_glGetProgramiv = _impl_glGetProgramiv;

static void  GL_APIENTRY _impl_glUniform1uiv (GLint location, GLsizei count, const GLuint * value) {
  _glptr_glUniform1uiv = (PFN_glUniform1uiv)GalogenGetProcAddress("glUniform1uiv");
   _glptr_glUniform1uiv(location, count, value);
}
PFN_glUniform1uiv _glptr_glUniform1uiv = _impl_glUniform1uiv;

static void  GL_APIENTRY _impl_glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
  _glptr_glCopyTexImage2D = (PFN_glCopyTexImage2D)GalogenGetProcAddress("glCopyTexImage2D");
   _glptr_glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
PFN_glCopyTexImage2D _glptr_glCopyTexImage2D = _impl_glCopyTexImage2D;

static void  GL_APIENTRY _impl_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat * params) {
  _glptr_glGetTexLevelParameterfv = (PFN_glGetTexLevelParameterfv)GalogenGetProcAddress("glGetTexLevelParameterfv");
   _glptr_glGetTexLevelParameterfv(target, level, pname, params);
}
PFN_glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv = _impl_glGetTexLevelParameterfv;

static void  GL_APIENTRY _impl_glSampleMaski (GLuint maskNumber, GLbitfield mask) {
  _glptr_glSampleMaski = (PFN_glSampleMaski)GalogenGetProcAddress("glSampleMaski");
   _glptr_glSampleMaski(maskNumber, mask);
}
PFN_glSampleMaski _glptr_glSampleMaski = _impl_glSampleMaski;

static void  GL_APIENTRY _impl_glBindTexture (GLenum target, GLuint texture) {
  _glptr_glBindTexture = (PFN_glBindTexture)GalogenGetProcAddress("glBindTexture");
   _glptr_glBindTexture(target, texture);
}
PFN_glBindTexture _glptr_glBindTexture = _impl_glBindTexture;

static void  GL_APIENTRY _impl_glGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) {
  _glptr_glGetActiveUniformBlockiv = (PFN_glGetActiveUniformBlockiv)GalogenGetProcAddress("glGetActiveUniformBlockiv");
   _glptr_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}
PFN_glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv = _impl_glGetActiveUniformBlockiv;

static void  GL_APIENTRY _impl_glMinSampleShading (GLfloat value) {
  _glptr_glMinSampleShading = (PFN_glMinSampleShading)GalogenGetProcAddress("glMinSampleShading");
   _glptr_glMinSampleShading(value);
}
PFN_glMinSampleShading _glptr_glMinSampleShading = _impl_glMinSampleShading;

static void  GL_APIENTRY _impl_glGetUniformuiv (GLuint program, GLint location, GLuint * params) {
  _glptr_glGetUniformuiv = (PFN_glGetUniformuiv)GalogenGetProcAddress("glGetUniformuiv");
   _glptr_glGetUniformuiv(program, location, params);
}
PFN_glGetUniformuiv _glptr_glGetUniformuiv = _impl_glGetUniformuiv;

static void  GL_APIENTRY _impl_glVertexAttrib4Nbv (GLuint index, const GLbyte * v) {
  _glptr_glVertexAttrib4Nbv = (PFN_glVertexAttrib4Nbv)GalogenGetProcAddress("glVertexAttrib4Nbv");
   _glptr_glVertexAttrib4Nbv(index, v);
}
PFN_glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv = _impl_glVertexAttrib4Nbv;

static void  GL_APIENTRY _impl_glCopyTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glCopyTextureSubImage2D = (PFN_glCopyTextureSubImage2D)GalogenGetProcAddress("glCopyTextureSubImage2D");
   _glptr_glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}
PFN_glCopyTextureSubImage2D _glptr_glCopyTextureSubImage2D = _impl_glCopyTextureSubImage2D;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix2x4dv = (PFN_glProgramUniformMatrix2x4dv)GalogenGetProcAddress("glProgramUniformMatrix2x4dv");
   _glptr_glProgramUniformMatrix2x4dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2x4dv _glptr_glProgramUniformMatrix2x4dv = _impl_glProgramUniformMatrix2x4dv;

static void  GL_APIENTRY _impl_glTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexImage3D = (PFN_glTexImage3D)GalogenGetProcAddress("glTexImage3D");
   _glptr_glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
}
PFN_glTexImage3D _glptr_glTexImage3D = _impl_glTexImage3D;

static void  GL_APIENTRY _impl_glQueryCounter (GLuint id, GLenum target) {
  _glptr_glQueryCounter = (PFN_glQueryCounter)GalogenGetProcAddress("glQueryCounter");
   _glptr_glQueryCounter(id, target);
}
PFN_glQueryCounter _glptr_glQueryCounter = _impl_glQueryCounter;

static void  GL_APIENTRY _impl_glVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
  _glptr_glVertexAttrib4f = (PFN_glVertexAttrib4f)GalogenGetProcAddress("glVertexAttrib4f");
   _glptr_glVertexAttrib4f(index, x, y, z, w);
}
PFN_glVertexAttrib4f _glptr_glVertexAttrib4f = _impl_glVertexAttrib4f;

static void  GL_APIENTRY _impl_glUniform2ui (GLint location, GLuint v0, GLuint v1) {
  _glptr_glUniform2ui = (PFN_glUniform2ui)GalogenGetProcAddress("glUniform2ui");
   _glptr_glUniform2ui(location, v0, v1);
}
PFN_glUniform2ui _glptr_glUniform2ui = _impl_glUniform2ui;

static void  GL_APIENTRY _impl_glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void * pixels) {
  _glptr_glGetTexImage = (PFN_glGetTexImage)GalogenGetProcAddress("glGetTexImage");
   _glptr_glGetTexImage(target, level, format, type, pixels);
}
PFN_glGetTexImage _glptr_glGetTexImage = _impl_glGetTexImage;

static void  GL_APIENTRY _impl_glGetTexParameterIuiv (GLenum target, GLenum pname, GLuint * params) {
  _glptr_glGetTexParameterIuiv = (PFN_glGetTexParameterIuiv)GalogenGetProcAddress("glGetTexParameterIuiv");
   _glptr_glGetTexParameterIuiv(target, pname, params);
}
PFN_glGetTexParameterIuiv _glptr_glGetTexParameterIuiv = _impl_glGetTexParameterIuiv;

static void  GL_APIENTRY _impl_glInvalidateBufferData (GLuint buffer) {
  _glptr_glInvalidateBufferData = (PFN_glInvalidateBufferData)GalogenGetProcAddress("glInvalidateBufferData");
   _glptr_glInvalidateBufferData(buffer);
}
PFN_glInvalidateBufferData _glptr_glInvalidateBufferData = _impl_glInvalidateBufferData;

static void  GL_APIENTRY _impl_glVertexAttrib4bv (GLuint index, const GLbyte * v) {
  _glptr_glVertexAttrib4bv = (PFN_glVertexAttrib4bv)GalogenGetProcAddress("glVertexAttrib4bv");
   _glptr_glVertexAttrib4bv(index, v);
}
PFN_glVertexAttrib4bv _glptr_glVertexAttrib4bv = _impl_glVertexAttrib4bv;

static void  GL_APIENTRY _impl_glUniform2uiv (GLint location, GLsizei count, const GLuint * value) {
  _glptr_glUniform2uiv = (PFN_glUniform2uiv)GalogenGetProcAddress("glUniform2uiv");
   _glptr_glUniform2uiv(location, count, value);
}
PFN_glUniform2uiv _glptr_glUniform2uiv = _impl_glUniform2uiv;

static void  GL_APIENTRY _impl_glGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) {
  _glptr_glGetShaderSource = (PFN_glGetShaderSource)GalogenGetProcAddress("glGetShaderSource");
   _glptr_glGetShaderSource(shader, bufSize, length, source);
}
PFN_glGetShaderSource _glptr_glGetShaderSource = _impl_glGetShaderSource;

static GLboolean GL_APIENTRY _impl_glIsBuffer (GLuint buffer) {
  _glptr_glIsBuffer = (PFN_glIsBuffer)GalogenGetProcAddress("glIsBuffer");
  return _glptr_glIsBuffer(buffer);
}
PFN_glIsBuffer _glptr_glIsBuffer = _impl_glIsBuffer;

static void  GL_APIENTRY _impl_glPauseTransformFeedback () {
  _glptr_glPauseTransformFeedback = (PFN_glPauseTransformFeedback)GalogenGetProcAddress("glPauseTransformFeedback");
   _glptr_glPauseTransformFeedback();
}
PFN_glPauseTransformFeedback _glptr_glPauseTransformFeedback = _impl_glPauseTransformFeedback;

static void  GL_APIENTRY _impl_glGetBufferPointerv (GLenum target, GLenum pname, void ** params) {
  _glptr_glGetBufferPointerv = (PFN_glGetBufferPointerv)GalogenGetProcAddress("glGetBufferPointerv");
   _glptr_glGetBufferPointerv(target, pname, params);
}
PFN_glGetBufferPointerv _glptr_glGetBufferPointerv = _impl_glGetBufferPointerv;

static void  GL_APIENTRY _impl_glPolygonMode (GLenum face, GLenum mode) {
  _glptr_glPolygonMode = (PFN_glPolygonMode)GalogenGetProcAddress("glPolygonMode");
   _glptr_glPolygonMode(face, mode);
}
PFN_glPolygonMode _glptr_glPolygonMode = _impl_glPolygonMode;

static void  GL_APIENTRY _impl_glGetnTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels) {
  _glptr_glGetnTexImage = (PFN_glGetnTexImage)GalogenGetProcAddress("glGetnTexImage");
   _glptr_glGetnTexImage(target, level, format, type, bufSize, pixels);
}
PFN_glGetnTexImage _glptr_glGetnTexImage = _impl_glGetnTexImage;

static void  GL_APIENTRY _impl_glBindAttribLocation (GLuint program, GLuint index, const GLchar * name) {
  _glptr_glBindAttribLocation = (PFN_glBindAttribLocation)GalogenGetProcAddress("glBindAttribLocation");
   _glptr_glBindAttribLocation(program, index, name);
}
PFN_glBindAttribLocation _glptr_glBindAttribLocation = _impl_glBindAttribLocation;

static void  GL_APIENTRY _impl_glGetQueryBufferObjectiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) {
  _glptr_glGetQueryBufferObjectiv = (PFN_glGetQueryBufferObjectiv)GalogenGetProcAddress("glGetQueryBufferObjectiv");
   _glptr_glGetQueryBufferObjectiv(id, buffer, pname, offset);
}
PFN_glGetQueryBufferObjectiv _glptr_glGetQueryBufferObjectiv = _impl_glGetQueryBufferObjectiv;

static void  GL_APIENTRY _impl_glDeleteSamplers (GLsizei count, const GLuint * samplers) {
#ifdef LEAK_COUNTER
	leak_samplers -= count;
	PFN_glDeleteSamplers
#endif

  _glptr_glDeleteSamplers = (PFN_glDeleteSamplers)GalogenGetProcAddress("glDeleteSamplers");
   _glptr_glDeleteSamplers(count, samplers);
}
PFN_glDeleteSamplers _glptr_glDeleteSamplers = _impl_glDeleteSamplers;

static void  GL_APIENTRY _impl_glUniform2f (GLint location, GLfloat v0, GLfloat v1) {
  _glptr_glUniform2f = (PFN_glUniform2f)GalogenGetProcAddress("glUniform2f");
   _glptr_glUniform2f(location, v0, v1);
}
PFN_glUniform2f _glptr_glUniform2f = _impl_glUniform2f;

static void  GL_APIENTRY _impl_glPixelStoref (GLenum pname, GLfloat param) {
  _glptr_glPixelStoref = (PFN_glPixelStoref)GalogenGetProcAddress("glPixelStoref");
   _glptr_glPixelStoref(pname, param);
}
PFN_glPixelStoref _glptr_glPixelStoref = _impl_glPixelStoref;

static void  GL_APIENTRY _impl_glLogicOp (GLenum opcode) {
  _glptr_glLogicOp = (PFN_glLogicOp)GalogenGetProcAddress("glLogicOp");
   _glptr_glLogicOp(opcode);
}
PFN_glLogicOp _glptr_glLogicOp = _impl_glLogicOp;

static GLuint GL_APIENTRY _impl_glCreateShader (GLenum type) {
#ifdef LEAK_COUNTER
	leak_shaders += 1;
	PFN_glCreateShader
#endif
  _glptr_glCreateShader = (PFN_glCreateShader)GalogenGetProcAddress("glCreateShader");
  return _glptr_glCreateShader(type);
}
PFN_glCreateShader _glptr_glCreateShader = _impl_glCreateShader;

static void  GL_APIENTRY _impl_glDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount) {
  _glptr_glDrawTransformFeedbackInstanced = (PFN_glDrawTransformFeedbackInstanced)GalogenGetProcAddress("glDrawTransformFeedbackInstanced");
   _glptr_glDrawTransformFeedbackInstanced(mode, id, instancecount);
}
PFN_glDrawTransformFeedbackInstanced _glptr_glDrawTransformFeedbackInstanced = _impl_glDrawTransformFeedbackInstanced;

static void  GL_APIENTRY _impl_glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexSubImage2D = (PFN_glTexSubImage2D)GalogenGetProcAddress("glTexSubImage2D");
   _glptr_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
PFN_glTexSubImage2D _glptr_glTexSubImage2D = _impl_glTexSubImage2D;

static void  GL_APIENTRY _impl_glGetFloati_v (GLenum target, GLuint index, GLfloat * data) {
  _glptr_glGetFloati_v = (PFN_glGetFloati_v)GalogenGetProcAddress("glGetFloati_v");
   _glptr_glGetFloati_v(target, index, data);
}
PFN_glGetFloati_v _glptr_glGetFloati_v = _impl_glGetFloati_v;

static void  GL_APIENTRY _impl_glClearDepth (GLdouble depth) {
  _glptr_glClearDepth = (PFN_glClearDepth)GalogenGetProcAddress("glClearDepth");
   _glptr_glClearDepth(depth);
}
PFN_glClearDepth _glptr_glClearDepth = _impl_glClearDepth;

static void  GL_APIENTRY _impl_glGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void * data) {
  _glptr_glGetBufferSubData = (PFN_glGetBufferSubData)GalogenGetProcAddress("glGetBufferSubData");
   _glptr_glGetBufferSubData(target, offset, size, data);
}
PFN_glGetBufferSubData _glptr_glGetBufferSubData = _impl_glGetBufferSubData;

static void  GL_APIENTRY _impl_glReleaseShaderCompiler () {
  _glptr_glReleaseShaderCompiler = (PFN_glReleaseShaderCompiler)GalogenGetProcAddress("glReleaseShaderCompiler");
   _glptr_glReleaseShaderCompiler();
}
PFN_glReleaseShaderCompiler _glptr_glReleaseShaderCompiler = _impl_glReleaseShaderCompiler;

static void  GL_APIENTRY _impl_glVertexAttrib4uiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttrib4uiv = (PFN_glVertexAttrib4uiv)GalogenGetProcAddress("glVertexAttrib4uiv");
   _glptr_glVertexAttrib4uiv(index, v);
}
PFN_glVertexAttrib4uiv _glptr_glVertexAttrib4uiv = _impl_glVertexAttrib4uiv;

static void  GL_APIENTRY _impl_glTransformFeedbackBufferBase (GLuint xfb, GLuint index, GLuint buffer) {
  _glptr_glTransformFeedbackBufferBase = (PFN_glTransformFeedbackBufferBase)GalogenGetProcAddress("glTransformFeedbackBufferBase");
   _glptr_glTransformFeedbackBufferBase(xfb, index, buffer);
}
PFN_glTransformFeedbackBufferBase _glptr_glTransformFeedbackBufferBase = _impl_glTransformFeedbackBufferBase;

static void  GL_APIENTRY _impl_glCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
  _glptr_glCopyBufferSubData = (PFN_glCopyBufferSubData)GalogenGetProcAddress("glCopyBufferSubData");
   _glptr_glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
PFN_glCopyBufferSubData _glptr_glCopyBufferSubData = _impl_glCopyBufferSubData;

static void  GL_APIENTRY _impl_glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
  _glptr_glFramebufferTexture2D = (PFN_glFramebufferTexture2D)GalogenGetProcAddress("glFramebufferTexture2D");
   _glptr_glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
PFN_glFramebufferTexture2D _glptr_glFramebufferTexture2D = _impl_glFramebufferTexture2D;

static void  GL_APIENTRY _impl_glScissorArrayv (GLuint first, GLsizei count, const GLint * v) {
  _glptr_glScissorArrayv = (PFN_glScissorArrayv)GalogenGetProcAddress("glScissorArrayv");
   _glptr_glScissorArrayv(first, count, v);
}
PFN_glScissorArrayv _glptr_glScissorArrayv = _impl_glScissorArrayv;

static void  GL_APIENTRY _impl_glPointParameterf (GLenum pname, GLfloat param) {
  _glptr_glPointParameterf = (PFN_glPointParameterf)GalogenGetProcAddress("glPointParameterf");
   _glptr_glPointParameterf(pname, param);
}
PFN_glPointParameterf _glptr_glPointParameterf = _impl_glPointParameterf;

static void  GL_APIENTRY _impl_glDisablei (GLenum target, GLuint index) {
  _glptr_glDisablei = (PFN_glDisablei)GalogenGetProcAddress("glDisablei");
   _glptr_glDisablei(target, index);
}
PFN_glDisablei _glptr_glDisablei = _impl_glDisablei;

static void  GL_APIENTRY _impl_glUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glUniformMatrix4x2fv = (PFN_glUniformMatrix4x2fv)GalogenGetProcAddress("glUniformMatrix4x2fv");
   _glptr_glUniformMatrix4x2fv(location, count, transpose, value);
}
PFN_glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv = _impl_glUniformMatrix4x2fv;

static void  GL_APIENTRY _impl_glVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
  _glptr_glVertexAttrib4d = (PFN_glVertexAttrib4d)GalogenGetProcAddress("glVertexAttrib4d");
   _glptr_glVertexAttrib4d(index, x, y, z, w);
}
PFN_glVertexAttrib4d _glptr_glVertexAttrib4d = _impl_glVertexAttrib4d;

static void  GL_APIENTRY _impl_glTexParameterIuiv (GLenum target, GLenum pname, const GLuint * params) {
  _glptr_glTexParameterIuiv = (PFN_glTexParameterIuiv)GalogenGetProcAddress("glTexParameterIuiv");
   _glptr_glTexParameterIuiv(target, pname, params);
}
PFN_glTexParameterIuiv _glptr_glTexParameterIuiv = _impl_glTexParameterIuiv;

static void  GL_APIENTRY _impl_glGetFloatv (GLenum pname, GLfloat * data) {
  _glptr_glGetFloatv = (PFN_glGetFloatv)GalogenGetProcAddress("glGetFloatv");
   _glptr_glGetFloatv(pname, data);
}
PFN_glGetFloatv _glptr_glGetFloatv = _impl_glGetFloatv;

static GLuint GL_APIENTRY _impl_glCreateProgram () {
#ifdef LEAK_COUNTER
	leak_programs += 1;
	PFN_glCreateProgram
#endif
  _glptr_glCreateProgram = (PFN_glCreateProgram)GalogenGetProcAddress("glCreateProgram");
  return _glptr_glCreateProgram();
}
PFN_glCreateProgram _glptr_glCreateProgram = _impl_glCreateProgram;

static void  GL_APIENTRY _impl_glTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode) {
  _glptr_glTransformFeedbackVaryings = (PFN_glTransformFeedbackVaryings)GalogenGetProcAddress("glTransformFeedbackVaryings");
   _glptr_glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}
PFN_glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings = _impl_glTransformFeedbackVaryings;

static void  GL_APIENTRY _impl_glProgramUniform1i (GLuint program, GLint location, GLint v0) {
  _glptr_glProgramUniform1i = (PFN_glProgramUniform1i)GalogenGetProcAddress("glProgramUniform1i");
   _glptr_glProgramUniform1i(program, location, v0);
}
PFN_glProgramUniform1i _glptr_glProgramUniform1i = _impl_glProgramUniform1i;

static void  GL_APIENTRY _impl_glVertexAttrib1d (GLuint index, GLdouble x) {
  _glptr_glVertexAttrib1d = (PFN_glVertexAttrib1d)GalogenGetProcAddress("glVertexAttrib1d");
   _glptr_glVertexAttrib1d(index, x);
}
PFN_glVertexAttrib1d _glptr_glVertexAttrib1d = _impl_glVertexAttrib1d;

static void  GL_APIENTRY _impl_glViewport (GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glViewport = (PFN_glViewport)GalogenGetProcAddress("glViewport");
   _glptr_glViewport(x, y, width, height);
}
PFN_glViewport _glptr_glViewport = _impl_glViewport;

static void  GL_APIENTRY _impl_glDeleteBuffers (GLsizei n, const GLuint * buffers) {
#ifdef LEAK_COUNTER
	leak_buffers -= n;
	PFN_glDeleteBuffers
#endif

  _glptr_glDeleteBuffers = (PFN_glDeleteBuffers)GalogenGetProcAddress("glDeleteBuffers");
   _glptr_glDeleteBuffers(n, buffers);
}
PFN_glDeleteBuffers _glptr_glDeleteBuffers = _impl_glDeleteBuffers;

static void  GL_APIENTRY _impl_glTextureStorage3DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
  _glptr_glTextureStorage3DMultisample = (PFN_glTextureStorage3DMultisample)GalogenGetProcAddress("glTextureStorage3DMultisample");
   _glptr_glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
}
PFN_glTextureStorage3DMultisample _glptr_glTextureStorage3DMultisample = _impl_glTextureStorage3DMultisample;

static void  GL_APIENTRY _impl_glFlush () {
  _glptr_glFlush = (PFN_glFlush)GalogenGetProcAddress("glFlush");
   _glptr_glFlush();
}
PFN_glFlush _glptr_glFlush = _impl_glFlush;

static void  GL_APIENTRY _impl_glVertexAttribI4sv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttribI4sv = (PFN_glVertexAttribI4sv)GalogenGetProcAddress("glVertexAttribI4sv");
   _glptr_glVertexAttribI4sv(index, v);
}
PFN_glVertexAttribI4sv _glptr_glVertexAttribI4sv = _impl_glVertexAttribI4sv;

static void  GL_APIENTRY _impl_glDrawArrays (GLenum mode, GLint first, GLsizei count) {
  _glptr_glDrawArrays = (PFN_glDrawArrays)GalogenGetProcAddress("glDrawArrays");
   _glptr_glDrawArrays(mode, first, count);
}
PFN_glDrawArrays _glptr_glDrawArrays = _impl_glDrawArrays;

static void  GL_APIENTRY _impl_glVertexArrayAttribFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) {
  _glptr_glVertexArrayAttribFormat = (PFN_glVertexArrayAttribFormat)GalogenGetProcAddress("glVertexArrayAttribFormat");
   _glptr_glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
}
PFN_glVertexArrayAttribFormat _glptr_glVertexArrayAttribFormat = _impl_glVertexArrayAttribFormat;

static void  GL_APIENTRY _impl_glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount) {
  _glptr_glDrawElementsInstanced = (PFN_glDrawElementsInstanced)GalogenGetProcAddress("glDrawElementsInstanced");
   _glptr_glDrawElementsInstanced(mode, count, type, indices, instancecount);
}
PFN_glDrawElementsInstanced _glptr_glDrawElementsInstanced = _impl_glDrawElementsInstanced;

static void  GL_APIENTRY _impl_glTextureParameteri (GLuint texture, GLenum pname, GLint param) {
  _glptr_glTextureParameteri = (PFN_glTextureParameteri)GalogenGetProcAddress("glTextureParameteri");
   _glptr_glTextureParameteri(texture, pname, param);
}
PFN_glTextureParameteri _glptr_glTextureParameteri = _impl_glTextureParameteri;

static void  GL_APIENTRY _impl_glDeleteTransformFeedbacks (GLsizei n, const GLuint * ids) {
#ifdef LEAK_COUNTER
	leak_transformfeedbacks -= n;
	PFN_glDeleteTransformFeedbacks
#endif

  _glptr_glDeleteTransformFeedbacks = (PFN_glDeleteTransformFeedbacks)GalogenGetProcAddress("glDeleteTransformFeedbacks");
   _glptr_glDeleteTransformFeedbacks(n, ids);
}
PFN_glDeleteTransformFeedbacks _glptr_glDeleteTransformFeedbacks = _impl_glDeleteTransformFeedbacks;

static void  GL_APIENTRY _impl_glUniform3iv (GLint location, GLsizei count, const GLint * value) {
  _glptr_glUniform3iv = (PFN_glUniform3iv)GalogenGetProcAddress("glUniform3iv");
   _glptr_glUniform3iv(location, count, value);
}
PFN_glUniform3iv _glptr_glUniform3iv = _impl_glUniform3iv;

static void  GL_APIENTRY _impl_glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer) {
  _glptr_glVertexAttribPointer = (PFN_glVertexAttribPointer)GalogenGetProcAddress("glVertexAttribPointer");
   _glptr_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}
PFN_glVertexAttribPointer _glptr_glVertexAttribPointer = _impl_glVertexAttribPointer;

static void  GL_APIENTRY _impl_glGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values) {
  _glptr_glGetSynciv = (PFN_glGetSynciv)GalogenGetProcAddress("glGetSynciv");
   _glptr_glGetSynciv(sync, pname, bufSize, length, values);
}
PFN_glGetSynciv _glptr_glGetSynciv = _impl_glGetSynciv;

static void  GL_APIENTRY _impl_glPrimitiveRestartIndex (GLuint index) {
  _glptr_glPrimitiveRestartIndex = (PFN_glPrimitiveRestartIndex)GalogenGetProcAddress("glPrimitiveRestartIndex");
   _glptr_glPrimitiveRestartIndex(index);
}
PFN_glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex = _impl_glPrimitiveRestartIndex;

static void  GL_APIENTRY _impl_glUniform1i (GLint location, GLint v0) {
  _glptr_glUniform1i = (PFN_glUniform1i)GalogenGetProcAddress("glUniform1i");
   _glptr_glUniform1i(location, v0);
}
PFN_glUniform1i _glptr_glUniform1i = _impl_glUniform1i;

static void  GL_APIENTRY _impl_glVertexAttrib1sv (GLuint index, const GLshort * v) {
  _glptr_glVertexAttrib1sv = (PFN_glVertexAttrib1sv)GalogenGetProcAddress("glVertexAttrib1sv");
   _glptr_glVertexAttrib1sv(index, v);
}
PFN_glVertexAttrib1sv _glptr_glVertexAttrib1sv = _impl_glVertexAttrib1sv;

static void  GL_APIENTRY _impl_glDisable (GLenum cap) {
  _glptr_glDisable = (PFN_glDisable)GalogenGetProcAddress("glDisable");
   _glptr_glDisable(cap);
}
PFN_glDisable _glptr_glDisable = _impl_glDisable;

static void  GL_APIENTRY _impl_glUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint * indices) {
  _glptr_glUniformSubroutinesuiv = (PFN_glUniformSubroutinesuiv)GalogenGetProcAddress("glUniformSubroutinesuiv");
   _glptr_glUniformSubroutinesuiv(shadertype, count, indices);
}
PFN_glUniformSubroutinesuiv _glptr_glUniformSubroutinesuiv = _impl_glUniformSubroutinesuiv;

static void  GL_APIENTRY _impl_glVertexAttribI4uiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttribI4uiv = (PFN_glVertexAttribI4uiv)GalogenGetProcAddress("glVertexAttribI4uiv");
   _glptr_glVertexAttribI4uiv(index, v);
}
PFN_glVertexAttribI4uiv _glptr_glVertexAttribI4uiv = _impl_glVertexAttribI4uiv;

static void  GL_APIENTRY _impl_glEndQuery (GLenum target) {
  _glptr_glEndQuery = (PFN_glEndQuery)GalogenGetProcAddress("glEndQuery");
   _glptr_glEndQuery(target);
}
PFN_glEndQuery _glptr_glEndQuery = _impl_glEndQuery;

static void  GL_APIENTRY _impl_glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
  _glptr_glColorMask = (PFN_glColorMask)GalogenGetProcAddress("glColorMask");
   _glptr_glColorMask(red, green, blue, alpha);
}
PFN_glColorMask _glptr_glColorMask = _impl_glColorMask;

static void  GL_APIENTRY _impl_glEnablei (GLenum target, GLuint index) {
  _glptr_glEnablei = (PFN_glEnablei)GalogenGetProcAddress("glEnablei");
   _glptr_glEnablei(target, index);
}
PFN_glEnablei _glptr_glEnablei = _impl_glEnablei;

static void  GL_APIENTRY _impl_glBindBuffer (GLenum target, GLuint buffer) {
  _glptr_glBindBuffer = (PFN_glBindBuffer)GalogenGetProcAddress("glBindBuffer");
   _glptr_glBindBuffer(target, buffer);
}
PFN_glBindBuffer _glptr_glBindBuffer = _impl_glBindBuffer;

static void  GL_APIENTRY _impl_glGetDoublev (GLenum pname, GLdouble * data) {
  _glptr_glGetDoublev = (PFN_glGetDoublev)GalogenGetProcAddress("glGetDoublev");
   _glptr_glGetDoublev(pname, data);
}
PFN_glGetDoublev _glptr_glGetDoublev = _impl_glGetDoublev;

static void  GL_APIENTRY _impl_glGetTexParameteriv (GLenum target, GLenum pname, GLint * params) {
  _glptr_glGetTexParameteriv = (PFN_glGetTexParameteriv)GalogenGetProcAddress("glGetTexParameteriv");
   _glptr_glGetTexParameteriv(target, pname, params);
}
PFN_glGetTexParameteriv _glptr_glGetTexParameteriv = _impl_glGetTexParameteriv;

static void  GL_APIENTRY _impl_glDeleteVertexArrays (GLsizei n, const GLuint * arrays) {
#ifdef LEAK_COUNTER
	leak_vertexarrays -= n;
	PFN_glDeleteVertexArrays
#endif

  _glptr_glDeleteVertexArrays = (PFN_glDeleteVertexArrays)GalogenGetProcAddress("glDeleteVertexArrays");
   _glptr_glDeleteVertexArrays(n, arrays);
}
PFN_glDeleteVertexArrays _glptr_glDeleteVertexArrays = _impl_glDeleteVertexArrays;

static void  GL_APIENTRY _impl_glVertexAttribI2uiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttribI2uiv = (PFN_glVertexAttribI2uiv)GalogenGetProcAddress("glVertexAttribI2uiv");
   _glptr_glVertexAttribI2uiv(index, v);
}
PFN_glVertexAttribI2uiv _glptr_glVertexAttribI2uiv = _impl_glVertexAttribI2uiv;

static void  GL_APIENTRY _impl_glDepthMask (GLboolean flag) {
  _glptr_glDepthMask = (PFN_glDepthMask)GalogenGetProcAddress("glDepthMask");
   _glptr_glDepthMask(flag);
}
PFN_glDepthMask _glptr_glDepthMask = _impl_glDepthMask;

static void  GL_APIENTRY _impl_glGetVertexAttribdv (GLuint index, GLenum pname, GLdouble * params) {
  _glptr_glGetVertexAttribdv = (PFN_glGetVertexAttribdv)GalogenGetProcAddress("glGetVertexAttribdv");
   _glptr_glGetVertexAttribdv(index, pname, params);
}
PFN_glGetVertexAttribdv _glptr_glGetVertexAttribdv = _impl_glGetVertexAttribdv;

static void  GL_APIENTRY _impl_glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices) {
  _glptr_glDrawRangeElements = (PFN_glDrawRangeElements)GalogenGetProcAddress("glDrawRangeElements");
   _glptr_glDrawRangeElements(mode, start, end, count, type, indices);
}
PFN_glDrawRangeElements _glptr_glDrawRangeElements = _impl_glDrawRangeElements;

static void  GL_APIENTRY _impl_glTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
  _glptr_glTexStorage3DMultisample = (PFN_glTexStorage3DMultisample)GalogenGetProcAddress("glTexStorage3DMultisample");
   _glptr_glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
PFN_glTexStorage3DMultisample _glptr_glTexStorage3DMultisample = _impl_glTexStorage3DMultisample;

static void  GL_APIENTRY _impl_glDrawElementsIndirect (GLenum mode, GLenum type, const void * indirect) {
  _glptr_glDrawElementsIndirect = (PFN_glDrawElementsIndirect)GalogenGetProcAddress("glDrawElementsIndirect");
   _glptr_glDrawElementsIndirect(mode, type, indirect);
}
PFN_glDrawElementsIndirect _glptr_glDrawElementsIndirect = _impl_glDrawElementsIndirect;

static void  GL_APIENTRY _impl_glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount) {
  _glptr_glDrawArraysInstanced = (PFN_glDrawArraysInstanced)GalogenGetProcAddress("glDrawArraysInstanced");
   _glptr_glDrawArraysInstanced(mode, first, count, instancecount);
}
PFN_glDrawArraysInstanced _glptr_glDrawArraysInstanced = _impl_glDrawArraysInstanced;

static void  GL_APIENTRY _impl_glGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint * params) {
  _glptr_glGetSamplerParameterIiv = (PFN_glGetSamplerParameterIiv)GalogenGetProcAddress("glGetSamplerParameterIiv");
   _glptr_glGetSamplerParameterIiv(sampler, pname, params);
}
PFN_glGetSamplerParameterIiv _glptr_glGetSamplerParameterIiv = _impl_glGetSamplerParameterIiv;

static void  GL_APIENTRY _impl_glClearStencil (GLint s) {
  _glptr_glClearStencil = (PFN_glClearStencil)GalogenGetProcAddress("glClearStencil");
   _glptr_glClearStencil(s);
}
PFN_glClearStencil _glptr_glClearStencil = _impl_glClearStencil;

static void  GL_APIENTRY _impl_glVertexAttribI3iv (GLuint index, const GLint * v) {
  _glptr_glVertexAttribI3iv = (PFN_glVertexAttribI3iv)GalogenGetProcAddress("glVertexAttribI3iv");
   _glptr_glVertexAttribI3iv(index, v);
}
PFN_glVertexAttribI3iv _glptr_glVertexAttribI3iv = _impl_glVertexAttribI3iv;

static void  GL_APIENTRY _impl_glViewportArrayv (GLuint first, GLsizei count, const GLfloat * v) {
  _glptr_glViewportArrayv = (PFN_glViewportArrayv)GalogenGetProcAddress("glViewportArrayv");
   _glptr_glViewportArrayv(first, count, v);
}
PFN_glViewportArrayv _glptr_glViewportArrayv = _impl_glViewportArrayv;

static void  GL_APIENTRY _impl_glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex) {
  _glptr_glDrawRangeElementsBaseVertex = (PFN_glDrawRangeElementsBaseVertex)GalogenGetProcAddress("glDrawRangeElementsBaseVertex");
   _glptr_glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}
PFN_glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex = _impl_glDrawRangeElementsBaseVertex;

static void  GL_APIENTRY _impl_glDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
  _glptr_glDrawElementsInstancedBaseVertexBaseInstance = (PFN_glDrawElementsInstancedBaseVertexBaseInstance)GalogenGetProcAddress("glDrawElementsInstancedBaseVertexBaseInstance");
   _glptr_glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
}
PFN_glDrawElementsInstancedBaseVertexBaseInstance _glptr_glDrawElementsInstancedBaseVertexBaseInstance = _impl_glDrawElementsInstancedBaseVertexBaseInstance;

static void  GL_APIENTRY _impl_glScissor (GLint x, GLint y, GLsizei width, GLsizei height) {
  _glptr_glScissor = (PFN_glScissor)GalogenGetProcAddress("glScissor");
   _glptr_glScissor(x, y, width, height);
}
PFN_glScissor _glptr_glScissor = _impl_glScissor;

static void  GL_APIENTRY _impl_glGenerateMipmap (GLenum target) {
  _glptr_glGenerateMipmap = (PFN_glGenerateMipmap)GalogenGetProcAddress("glGenerateMipmap");
   _glptr_glGenerateMipmap(target);
}
PFN_glGenerateMipmap _glptr_glGenerateMipmap = _impl_glGenerateMipmap;

static void  GL_APIENTRY _impl_glUniform3fv (GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glUniform3fv = (PFN_glUniform3fv)GalogenGetProcAddress("glUniform3fv");
   _glptr_glUniform3fv(location, count, value);
}
PFN_glUniform3fv _glptr_glUniform3fv = _impl_glUniform3fv;

static void  GL_APIENTRY _impl_glProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint * value) {
  _glptr_glProgramUniform2iv = (PFN_glProgramUniform2iv)GalogenGetProcAddress("glProgramUniform2iv");
   _glptr_glProgramUniform2iv(program, location, count, value);
}
PFN_glProgramUniform2iv _glptr_glProgramUniform2iv = _impl_glProgramUniform2iv;

static void  GL_APIENTRY _impl_glUniform3uiv (GLint location, GLsizei count, const GLuint * value) {
  _glptr_glUniform3uiv = (PFN_glUniform3uiv)GalogenGetProcAddress("glUniform3uiv");
   _glptr_glUniform3uiv(location, count, value);
}
PFN_glUniform3uiv _glptr_glUniform3uiv = _impl_glUniform3uiv;

static void  GL_APIENTRY _impl_glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint * value) {
  _glptr_glClearBufferiv = (PFN_glClearBufferiv)GalogenGetProcAddress("glClearBufferiv");
   _glptr_glClearBufferiv(buffer, drawbuffer, value);
}
PFN_glClearBufferiv _glptr_glClearBufferiv = _impl_glClearBufferiv;

static void  GL_APIENTRY _impl_glVertexAttribI4ubv (GLuint index, const GLubyte * v) {
  _glptr_glVertexAttribI4ubv = (PFN_glVertexAttribI4ubv)GalogenGetProcAddress("glVertexAttribI4ubv");
   _glptr_glVertexAttribI4ubv(index, v);
}
PFN_glVertexAttribI4ubv _glptr_glVertexAttribI4ubv = _impl_glVertexAttribI4ubv;

static void  GL_APIENTRY _impl_glVertexAttribL1dv (GLuint index, const GLdouble * v) {
  _glptr_glVertexAttribL1dv = (PFN_glVertexAttribL1dv)GalogenGetProcAddress("glVertexAttribL1dv");
   _glptr_glVertexAttribL1dv(index, v);
}
PFN_glVertexAttribL1dv _glptr_glVertexAttribL1dv = _impl_glVertexAttribL1dv;

static void  GL_APIENTRY _impl_glGetBooleanv (GLenum pname, GLboolean * data) {
  _glptr_glGetBooleanv = (PFN_glGetBooleanv)GalogenGetProcAddress("glGetBooleanv");
   _glptr_glGetBooleanv(pname, data);
}
PFN_glGetBooleanv _glptr_glGetBooleanv = _impl_glGetBooleanv;

static void  GL_APIENTRY _impl_glBindBuffersRange (GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes) {
  _glptr_glBindBuffersRange = (PFN_glBindBuffersRange)GalogenGetProcAddress("glBindBuffersRange");
   _glptr_glBindBuffersRange(target, first, count, buffers, offsets, sizes);
}
PFN_glBindBuffersRange _glptr_glBindBuffersRange = _impl_glBindBuffersRange;

static void  GL_APIENTRY _impl_glValidateProgram (GLuint program) {
  _glptr_glValidateProgram = (PFN_glValidateProgram)GalogenGetProcAddress("glValidateProgram");
   _glptr_glValidateProgram(program);
}
PFN_glValidateProgram _glptr_glValidateProgram = _impl_glValidateProgram;

static void  GL_APIENTRY _impl_glGenRenderbuffers (GLsizei n, GLuint * renderbuffers) {
#ifdef LEAK_COUNTER
	leak_renderbuffers += n;
	PFN_glCreateSamplers
#endif

  _glptr_glGenRenderbuffers = (PFN_glGenRenderbuffers)GalogenGetProcAddress("glGenRenderbuffers");
   _glptr_glGenRenderbuffers(n, renderbuffers);
}
PFN_glGenRenderbuffers _glptr_glGenRenderbuffers = _impl_glGenRenderbuffers;

static void  GL_APIENTRY _impl_glUniform2iv (GLint location, GLsizei count, const GLint * value) {
  _glptr_glUniform2iv = (PFN_glUniform2iv)GalogenGetProcAddress("glUniform2iv");
   _glptr_glUniform2iv(location, count, value);
}
PFN_glUniform2iv _glptr_glUniform2iv = _impl_glUniform2iv;

static void  GL_APIENTRY _impl_glBufferData (GLenum target, GLsizeiptr size, const void * data, GLenum usage) {
  _glptr_glBufferData = (PFN_glBufferData)GalogenGetProcAddress("glBufferData");
   _glptr_glBufferData(target, size, data, usage);
}
PFN_glBufferData _glptr_glBufferData = _impl_glBufferData;

static void  GL_APIENTRY _impl_glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
  _glptr_glBlendFuncSeparate = (PFN_glBlendFuncSeparate)GalogenGetProcAddress("glBlendFuncSeparate");
   _glptr_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
PFN_glBlendFuncSeparate _glptr_glBlendFuncSeparate = _impl_glBlendFuncSeparate;

static void  GL_APIENTRY _impl_glTexParameteri (GLenum target, GLenum pname, GLint param) {
  _glptr_glTexParameteri = (PFN_glTexParameteri)GalogenGetProcAddress("glTexParameteri");
   _glptr_glTexParameteri(target, pname, param);
}
PFN_glTexParameteri _glptr_glTexParameteri = _impl_glTexParameteri;

static void  GL_APIENTRY _impl_glHint (GLenum target, GLenum mode) {
  _glptr_glHint = (PFN_glHint)GalogenGetProcAddress("glHint");
   _glptr_glHint(target, mode);
}
PFN_glHint _glptr_glHint = _impl_glHint;

static void  GL_APIENTRY _impl_glVertexAttrib3fv (GLuint index, const GLfloat * v) {
  _glptr_glVertexAttrib3fv = (PFN_glVertexAttrib3fv)GalogenGetProcAddress("glVertexAttrib3fv");
   _glptr_glVertexAttrib3fv(index, v);
}
PFN_glVertexAttrib3fv _glptr_glVertexAttrib3fv = _impl_glVertexAttrib3fv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix2dv = (PFN_glProgramUniformMatrix2dv)GalogenGetProcAddress("glProgramUniformMatrix2dv");
   _glptr_glProgramUniformMatrix2dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix2dv _glptr_glProgramUniformMatrix2dv = _impl_glProgramUniformMatrix2dv;

static void  GL_APIENTRY _impl_glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint * params) {
  _glptr_glGetSamplerParameteriv = (PFN_glGetSamplerParameteriv)GalogenGetProcAddress("glGetSamplerParameteriv");
   _glptr_glGetSamplerParameteriv(sampler, pname, params);
}
PFN_glGetSamplerParameteriv _glptr_glGetSamplerParameteriv = _impl_glGetSamplerParameteriv;

static void  GL_APIENTRY _impl_glDrawBuffer (GLenum buf) {
  _glptr_glDrawBuffer = (PFN_glDrawBuffer)GalogenGetProcAddress("glDrawBuffer");
   _glptr_glDrawBuffer(buf);
}
PFN_glDrawBuffer _glptr_glDrawBuffer = _impl_glDrawBuffer;

static GLboolean GL_APIENTRY _impl_glIsProgram (GLuint program) {
  _glptr_glIsProgram = (PFN_glIsProgram)GalogenGetProcAddress("glIsProgram");
  return _glptr_glIsProgram(program);
}
PFN_glIsProgram _glptr_glIsProgram = _impl_glIsProgram;

static void  GL_APIENTRY _impl_glClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data) {
  _glptr_glClearBufferData = (PFN_glClearBufferData)GalogenGetProcAddress("glClearBufferData");
   _glptr_glClearBufferData(target, internalformat, format, type, data);
}
PFN_glClearBufferData _glptr_glClearBufferData = _impl_glClearBufferData;

static void  GL_APIENTRY _impl_glGetIntegerv (GLenum pname, GLint * data) {
  _glptr_glGetIntegerv = (PFN_glGetIntegerv)GalogenGetProcAddress("glGetIntegerv");
   _glptr_glGetIntegerv(pname, data);
}
PFN_glGetIntegerv _glptr_glGetIntegerv = _impl_glGetIntegerv;

static void  GL_APIENTRY _impl_glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex) {
  _glptr_glDrawElementsBaseVertex = (PFN_glDrawElementsBaseVertex)GalogenGetProcAddress("glDrawElementsBaseVertex");
   _glptr_glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
}
PFN_glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex = _impl_glDrawElementsBaseVertex;

static void  GL_APIENTRY _impl_glEnable (GLenum cap) {
  _glptr_glEnable = (PFN_glEnable)GalogenGetProcAddress("glEnable");
   _glptr_glEnable(cap);
}
PFN_glEnable _glptr_glEnable = _impl_glEnable;

static void  GL_APIENTRY _impl_glCreateProgramPipelines (GLsizei n, GLuint * pipelines) {
#ifdef LEAK_COUNTER
	leak_programpipelines += n;
	PFN_glCreateProgramPipelines
#endif
  _glptr_glCreateProgramPipelines = (PFN_glCreateProgramPipelines)GalogenGetProcAddress("glCreateProgramPipelines");
   _glptr_glCreateProgramPipelines(n, pipelines);
}
PFN_glCreateProgramPipelines _glptr_glCreateProgramPipelines = _impl_glCreateProgramPipelines;

static void  GL_APIENTRY _impl_glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
  _glptr_glBlitFramebuffer = (PFN_glBlitFramebuffer)GalogenGetProcAddress("glBlitFramebuffer");
   _glptr_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
PFN_glBlitFramebuffer _glptr_glBlitFramebuffer = _impl_glBlitFramebuffer;

static void  GL_APIENTRY _impl_glBeginQuery (GLenum target, GLuint id) {
  _glptr_glBeginQuery = (PFN_glBeginQuery)GalogenGetProcAddress("glBeginQuery");
   _glptr_glBeginQuery(target, id);
}
PFN_glBeginQuery _glptr_glBeginQuery = _impl_glBeginQuery;

static void  GL_APIENTRY _impl_glStencilMask (GLuint mask) {
  _glptr_glStencilMask = (PFN_glStencilMask)GalogenGetProcAddress("glStencilMask");
   _glptr_glStencilMask(mask);
}
PFN_glStencilMask _glptr_glStencilMask = _impl_glStencilMask;

static void  GL_APIENTRY _impl_glAttachShader (GLuint program, GLuint shader) {
  _glptr_glAttachShader = (PFN_glAttachShader)GalogenGetProcAddress("glAttachShader");
   _glptr_glAttachShader(program, shader);
}
PFN_glAttachShader _glptr_glAttachShader = _impl_glAttachShader;

static void  GL_APIENTRY _impl_glPointSize (GLfloat size) {
  _glptr_glPointSize = (PFN_glPointSize)GalogenGetProcAddress("glPointSize");
   _glptr_glPointSize(size);
}
PFN_glPointSize _glptr_glPointSize = _impl_glPointSize;

static void  GL_APIENTRY _impl_glMultiDrawArraysIndirect (GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride) {
  _glptr_glMultiDrawArraysIndirect = (PFN_glMultiDrawArraysIndirect)GalogenGetProcAddress("glMultiDrawArraysIndirect");
   _glptr_glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
PFN_glMultiDrawArraysIndirect _glptr_glMultiDrawArraysIndirect = _impl_glMultiDrawArraysIndirect;

static void  GL_APIENTRY _impl_glMultiDrawElements (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount) {
  _glptr_glMultiDrawElements = (PFN_glMultiDrawElements)GalogenGetProcAddress("glMultiDrawElements");
   _glptr_glMultiDrawElements(mode, count, type, indices, drawcount);
}
PFN_glMultiDrawElements _glptr_glMultiDrawElements = _impl_glMultiDrawElements;

static void  GL_APIENTRY _impl_glGetTexParameterfv (GLenum target, GLenum pname, GLfloat * params) {
  _glptr_glGetTexParameterfv = (PFN_glGetTexParameterfv)GalogenGetProcAddress("glGetTexParameterfv");
   _glptr_glGetTexParameterfv(target, pname, params);
}
PFN_glGetTexParameterfv _glptr_glGetTexParameterfv = _impl_glGetTexParameterfv;

static GLboolean GL_APIENTRY _impl_glIsEnabled (GLenum cap) {
  _glptr_glIsEnabled = (PFN_glIsEnabled)GalogenGetProcAddress("glIsEnabled");
  return _glptr_glIsEnabled(cap);
}
PFN_glIsEnabled _glptr_glIsEnabled = _impl_glIsEnabled;

static void  GL_APIENTRY _impl_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint * params) {
  _glptr_glGetTexLevelParameteriv = (PFN_glGetTexLevelParameteriv)GalogenGetProcAddress("glGetTexLevelParameteriv");
   _glptr_glGetTexLevelParameteriv(target, level, pname, params);
}
PFN_glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv = _impl_glGetTexLevelParameteriv;

static GLenum GL_APIENTRY _impl_glGetError () {
  _glptr_glGetError = (PFN_glGetError)GalogenGetProcAddress("glGetError");
  return _glptr_glGetError();
}
PFN_glGetError _glptr_glGetError = _impl_glGetError;

static void  GL_APIENTRY _impl_glEndTransformFeedback () {
  _glptr_glEndTransformFeedback = (PFN_glEndTransformFeedback)GalogenGetProcAddress("glEndTransformFeedback");
   _glptr_glEndTransformFeedback();
}
PFN_glEndTransformFeedback _glptr_glEndTransformFeedback = _impl_glEndTransformFeedback;

static void  GL_APIENTRY _impl_glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
  _glptr_glClearColor = (PFN_glClearColor)GalogenGetProcAddress("glClearColor");
   _glptr_glClearColor(red, green, blue, alpha);
}
PFN_glClearColor _glptr_glClearColor = _impl_glClearColor;

static void  GL_APIENTRY _impl_glBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
  _glptr_glBlendColor = (PFN_glBlendColor)GalogenGetProcAddress("glBlendColor");
   _glptr_glBlendColor(red, green, blue, alpha);
}
PFN_glBlendColor _glptr_glBlendColor = _impl_glBlendColor;

static void  GL_APIENTRY _impl_glProgramParameteri (GLuint program, GLenum pname, GLint value) {
  _glptr_glProgramParameteri = (PFN_glProgramParameteri)GalogenGetProcAddress("glProgramParameteri");
   _glptr_glProgramParameteri(program, pname, value);
}
PFN_glProgramParameteri _glptr_glProgramParameteri = _impl_glProgramParameteri;

static void  GL_APIENTRY _impl_glVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z) {
  _glptr_glVertexAttribI3i = (PFN_glVertexAttribI3i)GalogenGetProcAddress("glVertexAttribI3i");
   _glptr_glVertexAttribI3i(index, x, y, z);
}
PFN_glVertexAttribI3i _glptr_glVertexAttribI3i = _impl_glVertexAttribI3i;

static void  GL_APIENTRY _impl_glGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name) {
  _glptr_glGetActiveSubroutineName = (PFN_glGetActiveSubroutineName)GalogenGetProcAddress("glGetActiveSubroutineName");
   _glptr_glGetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}
PFN_glGetActiveSubroutineName _glptr_glGetActiveSubroutineName = _impl_glGetActiveSubroutineName;

static void  GL_APIENTRY _impl_glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexSubImage3D = (PFN_glCompressedTexSubImage3D)GalogenGetProcAddress("glCompressedTexSubImage3D");
   _glptr_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
PFN_glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D = _impl_glCompressedTexSubImage3D;

static void  GL_APIENTRY _impl_glGetDoublei_v (GLenum target, GLuint index, GLdouble * data) {
  _glptr_glGetDoublei_v = (PFN_glGetDoublei_v)GalogenGetProcAddress("glGetDoublei_v");
   _glptr_glGetDoublei_v(target, index, data);
}
PFN_glGetDoublei_v _glptr_glGetDoublei_v = _impl_glGetDoublei_v;

static void  GL_APIENTRY _impl_glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels) {
  _glptr_glReadPixels = (PFN_glReadPixels)GalogenGetProcAddress("glReadPixels");
   _glptr_glReadPixels(x, y, width, height, format, type, pixels);
}
PFN_glReadPixels _glptr_glReadPixels = _impl_glReadPixels;

static void  GL_APIENTRY _impl_glTexParameterf (GLenum target, GLenum pname, GLfloat param) {
  _glptr_glTexParameterf = (PFN_glTexParameterf)GalogenGetProcAddress("glTexParameterf");
   _glptr_glTexParameterf(target, pname, param);
}
PFN_glTexParameterf _glptr_glTexParameterf = _impl_glTexParameterf;

static void  GL_APIENTRY _impl_glViewportIndexedfv (GLuint index, const GLfloat * v) {
  _glptr_glViewportIndexedfv = (PFN_glViewportIndexedfv)GalogenGetProcAddress("glViewportIndexedfv");
   _glptr_glViewportIndexedfv(index, v);
}
PFN_glViewportIndexedfv _glptr_glViewportIndexedfv = _impl_glViewportIndexedfv;

static void  GL_APIENTRY _impl_glSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint * param) {
  _glptr_glSamplerParameterIiv = (PFN_glSamplerParameterIiv)GalogenGetProcAddress("glSamplerParameterIiv");
   _glptr_glSamplerParameterIiv(sampler, pname, param);
}
PFN_glSamplerParameterIiv _glptr_glSamplerParameterIiv = _impl_glSamplerParameterIiv;

static void  GL_APIENTRY _impl_glPointParameterfv (GLenum pname, const GLfloat * params) {
  _glptr_glPointParameterfv = (PFN_glPointParameterfv)GalogenGetProcAddress("glPointParameterfv");
   _glptr_glPointParameterfv(pname, params);
}
PFN_glPointParameterfv _glptr_glPointParameterfv = _impl_glPointParameterfv;

static void  GL_APIENTRY _impl_glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {
  _glptr_glGetShaderInfoLog = (PFN_glGetShaderInfoLog)GalogenGetProcAddress("glGetShaderInfoLog");
   _glptr_glGetShaderInfoLog(shader, bufSize, length, infoLog);
}
PFN_glGetShaderInfoLog _glptr_glGetShaderInfoLog = _impl_glGetShaderInfoLog;

static void  GL_APIENTRY _impl_glProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {
  _glptr_glProgramUniformMatrix4x3fv = (PFN_glProgramUniformMatrix4x3fv)GalogenGetProcAddress("glProgramUniformMatrix4x3fv");
   _glptr_glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix4x3fv _glptr_glProgramUniformMatrix4x3fv = _impl_glProgramUniformMatrix4x3fv;

static void  GL_APIENTRY _impl_glDepthFunc (GLenum func) {
  _glptr_glDepthFunc = (PFN_glDepthFunc)GalogenGetProcAddress("glDepthFunc");
   _glptr_glDepthFunc(func);
}
PFN_glDepthFunc _glptr_glDepthFunc = _impl_glDepthFunc;

static void  GL_APIENTRY _impl_glVertexAttribI3uiv (GLuint index, const GLuint * v) {
  _glptr_glVertexAttribI3uiv = (PFN_glVertexAttribI3uiv)GalogenGetProcAddress("glVertexAttribI3uiv");
   _glptr_glVertexAttribI3uiv(index, v);
}
PFN_glVertexAttribI3uiv _glptr_glVertexAttribI3uiv = _impl_glVertexAttribI3uiv;

static void  GL_APIENTRY _impl_glStencilOp (GLenum fail, GLenum zfail, GLenum zpass) {
  _glptr_glStencilOp = (PFN_glStencilOp)GalogenGetProcAddress("glStencilOp");
   _glptr_glStencilOp(fail, zfail, zpass);
}
PFN_glStencilOp _glptr_glStencilOp = _impl_glStencilOp;

static void  GL_APIENTRY _impl_glStencilFunc (GLenum func, GLint ref, GLuint mask) {
  _glptr_glStencilFunc = (PFN_glStencilFunc)GalogenGetProcAddress("glStencilFunc");
   _glptr_glStencilFunc(func, ref, mask);
}
PFN_glStencilFunc _glptr_glStencilFunc = _impl_glStencilFunc;

static void  GL_APIENTRY _impl_glEnableVertexAttribArray (GLuint index) {
  _glptr_glEnableVertexAttribArray = (PFN_glEnableVertexAttribArray)GalogenGetProcAddress("glEnableVertexAttribArray");
   _glptr_glEnableVertexAttribArray(index);
}
PFN_glEnableVertexAttribArray _glptr_glEnableVertexAttribArray = _impl_glEnableVertexAttribArray;

static void  GL_APIENTRY _impl_glBlendFunc (GLenum sfactor, GLenum dfactor) {
  _glptr_glBlendFunc = (PFN_glBlendFunc)GalogenGetProcAddress("glBlendFunc");
   _glptr_glBlendFunc(sfactor, dfactor);
}
PFN_glBlendFunc _glptr_glBlendFunc = _impl_glBlendFunc;

static void  GL_APIENTRY _impl_glVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
  _glptr_glVertexAttrib4Nub = (PFN_glVertexAttrib4Nub)GalogenGetProcAddress("glVertexAttrib4Nub");
   _glptr_glVertexAttrib4Nub(index, x, y, z, w);
}
PFN_glVertexAttrib4Nub _glptr_glVertexAttrib4Nub = _impl_glVertexAttrib4Nub;

static void  GL_APIENTRY _impl_glUniform1fv (GLint location, GLsizei count, const GLfloat * value) {
  _glptr_glUniform1fv = (PFN_glUniform1fv)GalogenGetProcAddress("glUniform1fv");
   _glptr_glUniform1fv(location, count, value);
}
PFN_glUniform1fv _glptr_glUniform1fv = _impl_glUniform1fv;

static void  GL_APIENTRY _impl_glPixelStorei (GLenum pname, GLint param) {
  _glptr_glPixelStorei = (PFN_glPixelStorei)GalogenGetProcAddress("glPixelStorei");
   _glptr_glPixelStorei(pname, param);
}
PFN_glPixelStorei _glptr_glPixelStorei = _impl_glPixelStorei;

static void  GL_APIENTRY _impl_glLineWidth (GLfloat width) {
  _glptr_glLineWidth = (PFN_glLineWidth)GalogenGetProcAddress("glLineWidth");
   _glptr_glLineWidth(width);
}
PFN_glLineWidth _glptr_glLineWidth = _impl_glLineWidth;

static void  GL_APIENTRY _impl_glVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) {
  _glptr_glVertexAttribP1ui = (PFN_glVertexAttribP1ui)GalogenGetProcAddress("glVertexAttribP1ui");
   _glptr_glVertexAttribP1ui(index, type, normalized, value);
}
PFN_glVertexAttribP1ui _glptr_glVertexAttribP1ui = _impl_glVertexAttribP1ui;

static void  GL_APIENTRY _impl_glGetUniformiv (GLuint program, GLint location, GLint * params) {
  _glptr_glGetUniformiv = (PFN_glGetUniformiv)GalogenGetProcAddress("glGetUniformiv");
   _glptr_glGetUniformiv(program, location, params);
}
PFN_glGetUniformiv _glptr_glGetUniformiv = _impl_glGetUniformiv;

static void  GL_APIENTRY _impl_glReadBuffer (GLenum src) {
  _glptr_glReadBuffer = (PFN_glReadBuffer)GalogenGetProcAddress("glReadBuffer");
   _glptr_glReadBuffer(src);
}
PFN_glReadBuffer _glptr_glReadBuffer = _impl_glReadBuffer;

static void  GL_APIENTRY _impl_glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexImage1D = (PFN_glTexImage1D)GalogenGetProcAddress("glTexImage1D");
   _glptr_glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
}
PFN_glTexImage1D _glptr_glTexImage1D = _impl_glTexImage1D;

static void  GL_APIENTRY _impl_glClipControl (GLenum origin, GLenum depth) {
  _glptr_glClipControl = (PFN_glClipControl)GalogenGetProcAddress("glClipControl");
   _glptr_glClipControl(origin, depth);
}
PFN_glClipControl _glptr_glClipControl = _impl_glClipControl;

static void  GL_APIENTRY _impl_glInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum * attachments) {
  _glptr_glInvalidateFramebuffer = (PFN_glInvalidateFramebuffer)GalogenGetProcAddress("glInvalidateFramebuffer");
   _glptr_glInvalidateFramebuffer(target, numAttachments, attachments);
}
PFN_glInvalidateFramebuffer _glptr_glInvalidateFramebuffer = _impl_glInvalidateFramebuffer;

static void  GL_APIENTRY _impl_glDeleteProgramPipelines (GLsizei n, const GLuint * pipelines) {
#ifdef LEAK_COUNTER
	leak_programpipelines -= n;
	PFN_glDeleteProgramPipelines
#endif

  _glptr_glDeleteProgramPipelines = (PFN_glDeleteProgramPipelines)GalogenGetProcAddress("glDeleteProgramPipelines");
   _glptr_glDeleteProgramPipelines(n, pipelines);
}
PFN_glDeleteProgramPipelines _glptr_glDeleteProgramPipelines = _impl_glDeleteProgramPipelines;

static void  GL_APIENTRY _impl_glTexParameterfv (GLenum target, GLenum pname, const GLfloat * params) {
  _glptr_glTexParameterfv = (PFN_glTexParameterfv)GalogenGetProcAddress("glTexParameterfv");
   _glptr_glTexParameterfv(target, pname, params);
}
PFN_glTexParameterfv _glptr_glTexParameterfv = _impl_glTexParameterfv;

static void  GL_APIENTRY _impl_glVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z) {
  _glptr_glVertexAttrib3s = (PFN_glVertexAttrib3s)GalogenGetProcAddress("glVertexAttrib3s");
   _glptr_glVertexAttrib3s(index, x, y, z);
}
PFN_glVertexAttrib3s _glptr_glVertexAttrib3s = _impl_glVertexAttrib3s;

static void  GL_APIENTRY _impl_glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) {
  _glptr_glCompressedTexSubImage1D = (PFN_glCompressedTexSubImage1D)GalogenGetProcAddress("glCompressedTexSubImage1D");
   _glptr_glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}
PFN_glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D = _impl_glCompressedTexSubImage1D;

static void  GL_APIENTRY _impl_glClear (GLbitfield mask) {
  _glptr_glClear = (PFN_glClear)GalogenGetProcAddress("glClear");
   _glptr_glClear(mask);
}
PFN_glClear _glptr_glClear = _impl_glClear;

static void  GL_APIENTRY _impl_glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) {
  _glptr_glTexImage2D = (PFN_glTexImage2D)GalogenGetProcAddress("glTexImage2D");
   _glptr_glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
}
PFN_glTexImage2D _glptr_glTexImage2D = _impl_glTexImage2D;

static void  GL_APIENTRY _impl_glVertexAttrib4Niv (GLuint index, const GLint * v) {
  _glptr_glVertexAttrib4Niv = (PFN_glVertexAttrib4Niv)GalogenGetProcAddress("glVertexAttrib4Niv");
   _glptr_glVertexAttrib4Niv(index, v);
}
PFN_glVertexAttrib4Niv _glptr_glVertexAttrib4Niv = _impl_glVertexAttrib4Niv;

static void  GL_APIENTRY _impl_glProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) {
  _glptr_glProgramUniformMatrix3x2dv = (PFN_glProgramUniformMatrix3x2dv)GalogenGetProcAddress("glProgramUniformMatrix3x2dv");
   _glptr_glProgramUniformMatrix3x2dv(program, location, count, transpose, value);
}
PFN_glProgramUniformMatrix3x2dv _glptr_glProgramUniformMatrix3x2dv = _impl_glProgramUniformMatrix3x2dv;

static void  GL_APIENTRY _impl_glGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint * params) {
  _glptr_glGetVertexAttribIuiv = (PFN_glGetVertexAttribIuiv)GalogenGetProcAddress("glGetVertexAttribIuiv");
   _glptr_glGetVertexAttribIuiv(index, pname, params);
}
PFN_glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv = _impl_glGetVertexAttribIuiv;

static void  GL_APIENTRY _impl_glStencilMaskSeparate (GLenum face, GLuint mask) {
  _glptr_glStencilMaskSeparate = (PFN_glStencilMaskSeparate)GalogenGetProcAddress("glStencilMaskSeparate");
   _glptr_glStencilMaskSeparate(face, mask);
}
PFN_glStencilMaskSeparate _glptr_glStencilMaskSeparate = _impl_glStencilMaskSeparate;

static void  GL_APIENTRY _impl_glGenVertexArrays (GLsizei n, GLuint * arrays) {
#ifdef LEAK_COUNTER
	leak_vertexarrays += n;
	PFN_glCreateSamplers
#endif

  _glptr_glGenVertexArrays = (PFN_glGenVertexArrays)GalogenGetProcAddress("glGenVertexArrays");
   _glptr_glGenVertexArrays(n, arrays);
}
PFN_glGenVertexArrays _glptr_glGenVertexArrays = _impl_glGenVertexArrays;

static void  GL_APIENTRY _impl_glFrontFace (GLenum mode) {
  _glptr_glFrontFace = (PFN_glFrontFace)GalogenGetProcAddress("glFrontFace");
   _glptr_glFrontFace(mode);
}
PFN_glFrontFace _glptr_glFrontFace = _impl_glFrontFace;

static void  GL_APIENTRY _impl_glDepthRange (GLdouble n, GLdouble f) {
  _glptr_glDepthRange = (PFN_glDepthRange)GalogenGetProcAddress("glDepthRange");
   _glptr_glDepthRange(n, f);
}
PFN_glDepthRange _glptr_glDepthRange = _impl_glDepthRange;

static void  GL_APIENTRY _impl_glVertexArrayAttribBinding (GLuint vaobj, GLuint attribindex, GLuint bindingindex) {
  _glptr_glVertexArrayAttribBinding = (PFN_glVertexArrayAttribBinding)GalogenGetProcAddress("glVertexArrayAttribBinding");
   _glptr_glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}
PFN_glVertexArrayAttribBinding _glptr_glVertexArrayAttribBinding = _impl_glVertexArrayAttribBinding;

static void  GL_APIENTRY _impl_glVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
  _glptr_glVertexAttrib4s = (PFN_glVertexAttrib4s)GalogenGetProcAddress("glVertexAttrib4s");
   _glptr_glVertexAttrib4s(index, x, y, z, w);
}
PFN_glVertexAttrib4s _glptr_glVertexAttrib4s = _impl_glVertexAttrib4s;

static void  GL_APIENTRY _impl_glDetachShader (GLuint program, GLuint shader) {
  _glptr_glDetachShader = (PFN_glDetachShader)GalogenGetProcAddress("glDetachShader");
   _glptr_glDetachShader(program, shader);
}
PFN_glDetachShader _glptr_glDetachShader = _impl_glDetachShader;

static void  GL_APIENTRY _impl_glCullFace (GLenum mode) {
  _glptr_glCullFace = (PFN_glCullFace)GalogenGetProcAddress("glCullFace");
   _glptr_glCullFace(mode);
}
PFN_glCullFace _glptr_glCullFace = _impl_glCullFace;