shithub: cstory

--- a/external/glad/include/glad/glad.h

+++ b/external/glad/include/glad/glad.h

@@ -1,8 +1,8 @@

/*

-    OpenGL loader generated by glad 0.1.33 on Wed Jan 15 07:22:49 2020.

+    OpenGL loader generated by glad 0.1.33 on Sat Apr 11 21:37:37 2020.

-    Language/Generator: C/C++

+    Language/Generator: C/C++ Debug

     Specification: gl

     APIs: gl=3.2

     Profile: core

@@ -14,9 +14,9 @@

     Reproducible: False

     Commandline:

-        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --extensions=""

+        --profile="core" --api="gl=3.2" --generator="c-debug" --spec="gl" --extensions=""

     Online:

-        https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.2

+        https://glad.dav1d.de/#profile=core&language=c-debug&specification=gl&loader=on&api=gl%3D3.2

*/

@@ -86,6 +86,12 @@

 GLAPI int gladLoadGLLoader(GLADloadproc);

+#define GLAD_DEBUG

+typedef void (* GLADcallback)(const char *name, void *funcptr, int len_args, ...);

+GLAPI void glad_set_pre_callback(GLADcallback cb);

+GLAPI void glad_set_post_callback(GLADcallback cb);

 #include <KHR/khrplatform.h>

 typedef unsigned int GLenum;

 typedef unsigned char GLboolean;

@@ -940,148 +946,196 @@

 GLAPI int GLAD_GL_VERSION_1_0;

 typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode);

 GLAPI PFNGLCULLFACEPROC glad_glCullFace;

-#define glCullFace glad_glCullFace

+GLAPI PFNGLCULLFACEPROC glad_debug_glCullFace;

+#define glCullFace glad_debug_glCullFace

 typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode);

 GLAPI PFNGLFRONTFACEPROC glad_glFrontFace;

-#define glFrontFace glad_glFrontFace

+GLAPI PFNGLFRONTFACEPROC glad_debug_glFrontFace;

+#define glFrontFace glad_debug_glFrontFace

 typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode);

 GLAPI PFNGLHINTPROC glad_glHint;

-#define glHint glad_glHint

+GLAPI PFNGLHINTPROC glad_debug_glHint;

+#define glHint glad_debug_glHint

 typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width);

 GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth;

-#define glLineWidth glad_glLineWidth

+GLAPI PFNGLLINEWIDTHPROC glad_debug_glLineWidth;

+#define glLineWidth glad_debug_glLineWidth

 typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size);

 GLAPI PFNGLPOINTSIZEPROC glad_glPointSize;

-#define glPointSize glad_glPointSize

+GLAPI PFNGLPOINTSIZEPROC glad_debug_glPointSize;

+#define glPointSize glad_debug_glPointSize

 typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);

 GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode;

-#define glPolygonMode glad_glPolygonMode

+GLAPI PFNGLPOLYGONMODEPROC glad_debug_glPolygonMode;

+#define glPolygonMode glad_debug_glPolygonMode

 typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);

 GLAPI PFNGLSCISSORPROC glad_glScissor;

-#define glScissor glad_glScissor

+GLAPI PFNGLSCISSORPROC glad_debug_glScissor;

+#define glScissor glad_debug_glScissor

 typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);

 GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf;

-#define glTexParameterf glad_glTexParameterf

+GLAPI PFNGLTEXPARAMETERFPROC glad_debug_glTexParameterf;

+#define glTexParameterf glad_debug_glTexParameterf

 typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params);

 GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;

-#define glTexParameterfv glad_glTexParameterfv

+GLAPI PFNGLTEXPARAMETERFVPROC glad_debug_glTexParameterfv;

+#define glTexParameterfv glad_debug_glTexParameterfv

 typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);

 GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri;

-#define glTexParameteri glad_glTexParameteri

+GLAPI PFNGLTEXPARAMETERIPROC glad_debug_glTexParameteri;

+#define glTexParameteri glad_debug_glTexParameteri

 typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params);

 GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;

-#define glTexParameteriv glad_glTexParameteriv

+GLAPI PFNGLTEXPARAMETERIVPROC glad_debug_glTexParameteriv;

+#define glTexParameteriv glad_debug_glTexParameteriv

 typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D;

-#define glTexImage1D glad_glTexImage1D

+GLAPI PFNGLTEXIMAGE1DPROC glad_debug_glTexImage1D;

+#define glTexImage1D glad_debug_glTexImage1D

 typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D;

-#define glTexImage2D glad_glTexImage2D

+GLAPI PFNGLTEXIMAGE2DPROC glad_debug_glTexImage2D;

+#define glTexImage2D glad_debug_glTexImage2D

 typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf);

 GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer;

-#define glDrawBuffer glad_glDrawBuffer

+GLAPI PFNGLDRAWBUFFERPROC glad_debug_glDrawBuffer;

+#define glDrawBuffer glad_debug_glDrawBuffer

 typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask);

 GLAPI PFNGLCLEARPROC glad_glClear;

-#define glClear glad_glClear

+GLAPI PFNGLCLEARPROC glad_debug_glClear;

+#define glClear glad_debug_glClear

 typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

 GLAPI PFNGLCLEARCOLORPROC glad_glClearColor;

-#define glClearColor glad_glClearColor

+GLAPI PFNGLCLEARCOLORPROC glad_debug_glClearColor;

+#define glClearColor glad_debug_glClearColor

 typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s);

 GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil;

-#define glClearStencil glad_glClearStencil

+GLAPI PFNGLCLEARSTENCILPROC glad_debug_glClearStencil;

+#define glClearStencil glad_debug_glClearStencil

 typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth);

 GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth;

-#define glClearDepth glad_glClearDepth

+GLAPI PFNGLCLEARDEPTHPROC glad_debug_glClearDepth;

+#define glClearDepth glad_debug_glClearDepth

 typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask);

 GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask;

-#define glStencilMask glad_glStencilMask

+GLAPI PFNGLSTENCILMASKPROC glad_debug_glStencilMask;

+#define glStencilMask glad_debug_glStencilMask

 typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

 GLAPI PFNGLCOLORMASKPROC glad_glColorMask;

-#define glColorMask glad_glColorMask

+GLAPI PFNGLCOLORMASKPROC glad_debug_glColorMask;

+#define glColorMask glad_debug_glColorMask

 typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag);

 GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask;

-#define glDepthMask glad_glDepthMask

+GLAPI PFNGLDEPTHMASKPROC glad_debug_glDepthMask;

+#define glDepthMask glad_debug_glDepthMask

 typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap);

 GLAPI PFNGLDISABLEPROC glad_glDisable;

-#define glDisable glad_glDisable

+GLAPI PFNGLDISABLEPROC glad_debug_glDisable;

+#define glDisable glad_debug_glDisable

 typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap);

 GLAPI PFNGLENABLEPROC glad_glEnable;

-#define glEnable glad_glEnable

+GLAPI PFNGLENABLEPROC glad_debug_glEnable;

+#define glEnable glad_debug_glEnable

 typedef void (APIENTRYP PFNGLFINISHPROC)(void);

 GLAPI PFNGLFINISHPROC glad_glFinish;

-#define glFinish glad_glFinish

+GLAPI PFNGLFINISHPROC glad_debug_glFinish;

+#define glFinish glad_debug_glFinish

 typedef void (APIENTRYP PFNGLFLUSHPROC)(void);

 GLAPI PFNGLFLUSHPROC glad_glFlush;

-#define glFlush glad_glFlush

+GLAPI PFNGLFLUSHPROC glad_debug_glFlush;

+#define glFlush glad_debug_glFlush

 typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);

 GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc;

-#define glBlendFunc glad_glBlendFunc

+GLAPI PFNGLBLENDFUNCPROC glad_debug_glBlendFunc;

+#define glBlendFunc glad_debug_glBlendFunc

 typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode);

 GLAPI PFNGLLOGICOPPROC glad_glLogicOp;

-#define glLogicOp glad_glLogicOp

+GLAPI PFNGLLOGICOPPROC glad_debug_glLogicOp;

+#define glLogicOp glad_debug_glLogicOp

 typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);

 GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc;

-#define glStencilFunc glad_glStencilFunc

+GLAPI PFNGLSTENCILFUNCPROC glad_debug_glStencilFunc;

+#define glStencilFunc glad_debug_glStencilFunc

 typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);

 GLAPI PFNGLSTENCILOPPROC glad_glStencilOp;

-#define glStencilOp glad_glStencilOp

+GLAPI PFNGLSTENCILOPPROC glad_debug_glStencilOp;

+#define glStencilOp glad_debug_glStencilOp

 typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func);

 GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc;

-#define glDepthFunc glad_glDepthFunc

+GLAPI PFNGLDEPTHFUNCPROC glad_debug_glDepthFunc;

+#define glDepthFunc glad_debug_glDepthFunc

 typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);

 GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref;

-#define glPixelStoref glad_glPixelStoref

+GLAPI PFNGLPIXELSTOREFPROC glad_debug_glPixelStoref;

+#define glPixelStoref glad_debug_glPixelStoref

 typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);

 GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei;

-#define glPixelStorei glad_glPixelStorei

+GLAPI PFNGLPIXELSTOREIPROC glad_debug_glPixelStorei;

+#define glPixelStorei glad_debug_glPixelStorei

 typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src);

 GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer;

-#define glReadBuffer glad_glReadBuffer

+GLAPI PFNGLREADBUFFERPROC glad_debug_glReadBuffer;

+#define glReadBuffer glad_debug_glReadBuffer

 typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);

 GLAPI PFNGLREADPIXELSPROC glad_glReadPixels;

-#define glReadPixels glad_glReadPixels

+GLAPI PFNGLREADPIXELSPROC glad_debug_glReadPixels;

+#define glReadPixels glad_debug_glReadPixels

 typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data);

 GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv;

-#define glGetBooleanv glad_glGetBooleanv

+GLAPI PFNGLGETBOOLEANVPROC glad_debug_glGetBooleanv;

+#define glGetBooleanv glad_debug_glGetBooleanv

 typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data);

 GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev;

-#define glGetDoublev glad_glGetDoublev

+GLAPI PFNGLGETDOUBLEVPROC glad_debug_glGetDoublev;

+#define glGetDoublev glad_debug_glGetDoublev

 typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void);

 GLAPI PFNGLGETERRORPROC glad_glGetError;

-#define glGetError glad_glGetError

+GLAPI PFNGLGETERRORPROC glad_debug_glGetError;

+#define glGetError glad_debug_glGetError

 typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data);

 GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv;

-#define glGetFloatv glad_glGetFloatv

+GLAPI PFNGLGETFLOATVPROC glad_debug_glGetFloatv;

+#define glGetFloatv glad_debug_glGetFloatv

 typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data);

 GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv;

-#define glGetIntegerv glad_glGetIntegerv

+GLAPI PFNGLGETINTEGERVPROC glad_debug_glGetIntegerv;

+#define glGetIntegerv glad_debug_glGetIntegerv

 typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name);

 GLAPI PFNGLGETSTRINGPROC glad_glGetString;

-#define glGetString glad_glGetString

+GLAPI PFNGLGETSTRINGPROC glad_debug_glGetString;

+#define glGetString glad_debug_glGetString

 typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels);

 GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage;

-#define glGetTexImage glad_glGetTexImage

+GLAPI PFNGLGETTEXIMAGEPROC glad_debug_glGetTexImage;

+#define glGetTexImage glad_debug_glGetTexImage

 typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params);

 GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;

-#define glGetTexParameterfv glad_glGetTexParameterfv

+GLAPI PFNGLGETTEXPARAMETERFVPROC glad_debug_glGetTexParameterfv;

+#define glGetTexParameterfv glad_debug_glGetTexParameterfv

 typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);

 GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;

-#define glGetTexParameteriv glad_glGetTexParameteriv

+GLAPI PFNGLGETTEXPARAMETERIVPROC glad_debug_glGetTexParameteriv;

+#define glGetTexParameteriv glad_debug_glGetTexParameteriv

 typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params);

 GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;

-#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv

+GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_debug_glGetTexLevelParameterfv;

+#define glGetTexLevelParameterfv glad_debug_glGetTexLevelParameterfv

 typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params);

 GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;

-#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv

+GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_debug_glGetTexLevelParameteriv;

+#define glGetTexLevelParameteriv glad_debug_glGetTexLevelParameteriv

 typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap);

 GLAPI PFNGLISENABLEDPROC glad_glIsEnabled;

-#define glIsEnabled glad_glIsEnabled

+GLAPI PFNGLISENABLEDPROC glad_debug_glIsEnabled;

+#define glIsEnabled glad_debug_glIsEnabled

 typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);

 GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange;

-#define glDepthRange glad_glDepthRange

+GLAPI PFNGLDEPTHRANGEPROC glad_debug_glDepthRange;

+#define glDepthRange glad_debug_glDepthRange

 typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);

 GLAPI PFNGLVIEWPORTPROC glad_glViewport;

-#define glViewport glad_glViewport

+GLAPI PFNGLVIEWPORTPROC glad_debug_glViewport;

+#define glViewport glad_debug_glViewport

 #endif

 #ifndef GL_VERSION_1_1

 #define GL_VERSION_1_1 1

@@ -1088,43 +1142,56 @@

 GLAPI int GLAD_GL_VERSION_1_1;

 typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);

 GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays;

-#define glDrawArrays glad_glDrawArrays

+GLAPI PFNGLDRAWARRAYSPROC glad_debug_glDrawArrays;

+#define glDrawArrays glad_debug_glDrawArrays

 typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices);

 GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements;

-#define glDrawElements glad_glDrawElements

+GLAPI PFNGLDRAWELEMENTSPROC glad_debug_glDrawElements;

+#define glDrawElements glad_debug_glDrawElements

 typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);

 GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;

-#define glPolygonOffset glad_glPolygonOffset

+GLAPI PFNGLPOLYGONOFFSETPROC glad_debug_glPolygonOffset;

+#define glPolygonOffset glad_debug_glPolygonOffset

 typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);

 GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;

-#define glCopyTexImage1D glad_glCopyTexImage1D

+GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_debug_glCopyTexImage1D;

+#define glCopyTexImage1D glad_debug_glCopyTexImage1D

 typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

 GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;

-#define glCopyTexImage2D glad_glCopyTexImage2D

+GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_debug_glCopyTexImage2D;

+#define glCopyTexImage2D glad_debug_glCopyTexImage2D

 typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

 GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;

-#define glCopyTexSubImage1D glad_glCopyTexSubImage1D

+GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_debug_glCopyTexSubImage1D;

+#define glCopyTexSubImage1D glad_debug_glCopyTexSubImage1D

 typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

 GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;

-#define glCopyTexSubImage2D glad_glCopyTexSubImage2D

+GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_debug_glCopyTexSubImage2D;

+#define glCopyTexSubImage2D glad_debug_glCopyTexSubImage2D

 typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;

-#define glTexSubImage1D glad_glTexSubImage1D

+GLAPI PFNGLTEXSUBIMAGE1DPROC glad_debug_glTexSubImage1D;

+#define glTexSubImage1D glad_debug_glTexSubImage1D

 typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;

-#define glTexSubImage2D glad_glTexSubImage2D

+GLAPI PFNGLTEXSUBIMAGE2DPROC glad_debug_glTexSubImage2D;

+#define glTexSubImage2D glad_debug_glTexSubImage2D

 typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);

 GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture;

-#define glBindTexture glad_glBindTexture

+GLAPI PFNGLBINDTEXTUREPROC glad_debug_glBindTexture;

+#define glBindTexture glad_debug_glBindTexture

 typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures);

 GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures;

-#define glDeleteTextures glad_glDeleteTextures

+GLAPI PFNGLDELETETEXTURESPROC glad_debug_glDeleteTextures;

+#define glDeleteTextures glad_debug_glDeleteTextures

 typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures);

 GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures;

-#define glGenTextures glad_glGenTextures

+GLAPI PFNGLGENTEXTURESPROC glad_debug_glGenTextures;

+#define glGenTextures glad_debug_glGenTextures

 typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture);

 GLAPI PFNGLISTEXTUREPROC glad_glIsTexture;

-#define glIsTexture glad_glIsTexture

+GLAPI PFNGLISTEXTUREPROC glad_debug_glIsTexture;

+#define glIsTexture glad_debug_glIsTexture

 #endif

 #ifndef GL_VERSION_1_2

 #define GL_VERSION_1_2 1

@@ -1131,16 +1198,20 @@

 GLAPI int GLAD_GL_VERSION_1_2;

 typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);

 GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;

-#define glDrawRangeElements glad_glDrawRangeElements

+GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_debug_glDrawRangeElements;

+#define glDrawRangeElements glad_debug_glDrawRangeElements

 typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D;

-#define glTexImage3D glad_glTexImage3D

+GLAPI PFNGLTEXIMAGE3DPROC glad_debug_glTexImage3D;

+#define glTexImage3D glad_debug_glTexImage3D

 typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);

 GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;

-#define glTexSubImage3D glad_glTexSubImage3D

+GLAPI PFNGLTEXSUBIMAGE3DPROC glad_debug_glTexSubImage3D;

+#define glTexSubImage3D glad_debug_glTexSubImage3D

 typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

 GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;

-#define glCopyTexSubImage3D glad_glCopyTexSubImage3D

+GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_debug_glCopyTexSubImage3D;

+#define glCopyTexSubImage3D glad_debug_glCopyTexSubImage3D

 #endif

 #ifndef GL_VERSION_1_3

 #define GL_VERSION_1_3 1

@@ -1147,31 +1218,40 @@

 GLAPI int GLAD_GL_VERSION_1_3;

 typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture);

 GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture;

-#define glActiveTexture glad_glActiveTexture

+GLAPI PFNGLACTIVETEXTUREPROC glad_debug_glActiveTexture;

+#define glActiveTexture glad_debug_glActiveTexture

 typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);

 GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;

-#define glSampleCoverage glad_glSampleCoverage

+GLAPI PFNGLSAMPLECOVERAGEPROC glad_debug_glSampleCoverage;

+#define glSampleCoverage glad_debug_glSampleCoverage

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;

-#define glCompressedTexImage3D glad_glCompressedTexImage3D

+GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_debug_glCompressedTexImage3D;

+#define glCompressedTexImage3D glad_debug_glCompressedTexImage3D

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;

-#define glCompressedTexImage2D glad_glCompressedTexImage2D

+GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_debug_glCompressedTexImage2D;

+#define glCompressedTexImage2D glad_debug_glCompressedTexImage2D

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;

-#define glCompressedTexImage1D glad_glCompressedTexImage1D

+GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_debug_glCompressedTexImage1D;

+#define glCompressedTexImage1D glad_debug_glCompressedTexImage1D

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;

-#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D

+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_debug_glCompressedTexSubImage3D;

+#define glCompressedTexSubImage3D glad_debug_glCompressedTexSubImage3D

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;

-#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D

+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_debug_glCompressedTexSubImage2D;

+#define glCompressedTexSubImage2D glad_debug_glCompressedTexSubImage2D

 typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);

 GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;

-#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D

+GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_debug_glCompressedTexSubImage1D;

+#define glCompressedTexSubImage1D glad_debug_glCompressedTexSubImage1D

 typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img);

 GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;

-#define glGetCompressedTexImage glad_glGetCompressedTexImage

+GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_debug_glGetCompressedTexImage;

+#define glGetCompressedTexImage glad_debug_glGetCompressedTexImage

 #endif

 #ifndef GL_VERSION_1_4

 #define GL_VERSION_1_4 1

@@ -1178,31 +1258,40 @@

 GLAPI int GLAD_GL_VERSION_1_4;

 typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);

 GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;

-#define glBlendFuncSeparate glad_glBlendFuncSeparate

+GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_debug_glBlendFuncSeparate;

+#define glBlendFuncSeparate glad_debug_glBlendFuncSeparate

 typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);

 GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;

-#define glMultiDrawArrays glad_glMultiDrawArrays

+GLAPI PFNGLMULTIDRAWARRAYSPROC glad_debug_glMultiDrawArrays;

+#define glMultiDrawArrays glad_debug_glMultiDrawArrays

 typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount);

 GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;

-#define glMultiDrawElements glad_glMultiDrawElements

+GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_debug_glMultiDrawElements;

+#define glMultiDrawElements glad_debug_glMultiDrawElements

 typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);

 GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;

-#define glPointParameterf glad_glPointParameterf

+GLAPI PFNGLPOINTPARAMETERFPROC glad_debug_glPointParameterf;

+#define glPointParameterf glad_debug_glPointParameterf

 typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params);

 GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;

-#define glPointParameterfv glad_glPointParameterfv

+GLAPI PFNGLPOINTPARAMETERFVPROC glad_debug_glPointParameterfv;

+#define glPointParameterfv glad_debug_glPointParameterfv

 typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);

 GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;

-#define glPointParameteri glad_glPointParameteri

+GLAPI PFNGLPOINTPARAMETERIPROC glad_debug_glPointParameteri;

+#define glPointParameteri glad_debug_glPointParameteri

 typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params);

 GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;

-#define glPointParameteriv glad_glPointParameteriv

+GLAPI PFNGLPOINTPARAMETERIVPROC glad_debug_glPointParameteriv;

+#define glPointParameteriv glad_debug_glPointParameteriv

 typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

 GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor;

-#define glBlendColor glad_glBlendColor

+GLAPI PFNGLBLENDCOLORPROC glad_debug_glBlendColor;

+#define glBlendColor glad_debug_glBlendColor

 typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode);

 GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation;

-#define glBlendEquation glad_glBlendEquation

+GLAPI PFNGLBLENDEQUATIONPROC glad_debug_glBlendEquation;

+#define glBlendEquation glad_debug_glBlendEquation

 #endif

 #ifndef GL_VERSION_1_5

 #define GL_VERSION_1_5 1

@@ -1209,61 +1298,80 @@

 GLAPI int GLAD_GL_VERSION_1_5;

 typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids);

 GLAPI PFNGLGENQUERIESPROC glad_glGenQueries;

-#define glGenQueries glad_glGenQueries

+GLAPI PFNGLGENQUERIESPROC glad_debug_glGenQueries;

+#define glGenQueries glad_debug_glGenQueries

 typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids);

 GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries;

-#define glDeleteQueries glad_glDeleteQueries

+GLAPI PFNGLDELETEQUERIESPROC glad_debug_glDeleteQueries;

+#define glDeleteQueries glad_debug_glDeleteQueries

 typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id);

 GLAPI PFNGLISQUERYPROC glad_glIsQuery;

-#define glIsQuery glad_glIsQuery

+GLAPI PFNGLISQUERYPROC glad_debug_glIsQuery;

+#define glIsQuery glad_debug_glIsQuery

 typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);

 GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery;

-#define glBeginQuery glad_glBeginQuery

+GLAPI PFNGLBEGINQUERYPROC glad_debug_glBeginQuery;

+#define glBeginQuery glad_debug_glBeginQuery

 typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target);

 GLAPI PFNGLENDQUERYPROC glad_glEndQuery;

-#define glEndQuery glad_glEndQuery

+GLAPI PFNGLENDQUERYPROC glad_debug_glEndQuery;

+#define glEndQuery glad_debug_glEndQuery

 typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params);

 GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv;

-#define glGetQueryiv glad_glGetQueryiv

+GLAPI PFNGLGETQUERYIVPROC glad_debug_glGetQueryiv;

+#define glGetQueryiv glad_debug_glGetQueryiv

 typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params);

 GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;

-#define glGetQueryObjectiv glad_glGetQueryObjectiv

+GLAPI PFNGLGETQUERYOBJECTIVPROC glad_debug_glGetQueryObjectiv;

+#define glGetQueryObjectiv glad_debug_glGetQueryObjectiv

 typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params);

 GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;

-#define glGetQueryObjectuiv glad_glGetQueryObjectuiv

+GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_debug_glGetQueryObjectuiv;

+#define glGetQueryObjectuiv glad_debug_glGetQueryObjectuiv

 typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);

 GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer;

-#define glBindBuffer glad_glBindBuffer

+GLAPI PFNGLBINDBUFFERPROC glad_debug_glBindBuffer;

+#define glBindBuffer glad_debug_glBindBuffer

 typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers);

 GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;

-#define glDeleteBuffers glad_glDeleteBuffers

+GLAPI PFNGLDELETEBUFFERSPROC glad_debug_glDeleteBuffers;

+#define glDeleteBuffers glad_debug_glDeleteBuffers

 typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers);

 GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers;

-#define glGenBuffers glad_glGenBuffers

+GLAPI PFNGLGENBUFFERSPROC glad_debug_glGenBuffers;

+#define glGenBuffers glad_debug_glGenBuffers

 typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer);

 GLAPI PFNGLISBUFFERPROC glad_glIsBuffer;

-#define glIsBuffer glad_glIsBuffer

+GLAPI PFNGLISBUFFERPROC glad_debug_glIsBuffer;

+#define glIsBuffer glad_debug_glIsBuffer

 typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage);

 GLAPI PFNGLBUFFERDATAPROC glad_glBufferData;

-#define glBufferData glad_glBufferData

+GLAPI PFNGLBUFFERDATAPROC glad_debug_glBufferData;

+#define glBufferData glad_debug_glBufferData

 typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data);

 GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;

-#define glBufferSubData glad_glBufferSubData

+GLAPI PFNGLBUFFERSUBDATAPROC glad_debug_glBufferSubData;

+#define glBufferSubData glad_debug_glBufferSubData

 typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data);

 GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;

-#define glGetBufferSubData glad_glGetBufferSubData

+GLAPI PFNGLGETBUFFERSUBDATAPROC glad_debug_glGetBufferSubData;

+#define glGetBufferSubData glad_debug_glGetBufferSubData

 typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);

 GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer;

-#define glMapBuffer glad_glMapBuffer

+GLAPI PFNGLMAPBUFFERPROC glad_debug_glMapBuffer;

+#define glMapBuffer glad_debug_glMapBuffer

 typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target);

 GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;

-#define glUnmapBuffer glad_glUnmapBuffer

+GLAPI PFNGLUNMAPBUFFERPROC glad_debug_glUnmapBuffer;

+#define glUnmapBuffer glad_debug_glUnmapBuffer

 typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);

 GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;

-#define glGetBufferParameteriv glad_glGetBufferParameteriv

+GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_debug_glGetBufferParameteriv;

+#define glGetBufferParameteriv glad_debug_glGetBufferParameteriv

 typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params);

 GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;

-#define glGetBufferPointerv glad_glGetBufferPointerv

+GLAPI PFNGLGETBUFFERPOINTERVPROC glad_debug_glGetBufferPointerv;

+#define glGetBufferPointerv glad_debug_glGetBufferPointerv

 #endif

 #ifndef GL_VERSION_2_0

 #define GL_VERSION_2_0 1

@@ -1270,283 +1378,376 @@

 GLAPI int GLAD_GL_VERSION_2_0;

 typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);

 GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;

-#define glBlendEquationSeparate glad_glBlendEquationSeparate

+GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_debug_glBlendEquationSeparate;

+#define glBlendEquationSeparate glad_debug_glBlendEquationSeparate

 typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs);

 GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;

-#define glDrawBuffers glad_glDrawBuffers

+GLAPI PFNGLDRAWBUFFERSPROC glad_debug_glDrawBuffers;

+#define glDrawBuffers glad_debug_glDrawBuffers

 typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);

 GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;

-#define glStencilOpSeparate glad_glStencilOpSeparate

+GLAPI PFNGLSTENCILOPSEPARATEPROC glad_debug_glStencilOpSeparate;

+#define glStencilOpSeparate glad_debug_glStencilOpSeparate

 typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);

 GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;

-#define glStencilFuncSeparate glad_glStencilFuncSeparate

+GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_debug_glStencilFuncSeparate;

+#define glStencilFuncSeparate glad_debug_glStencilFuncSeparate

 typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);

 GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;

-#define glStencilMaskSeparate glad_glStencilMaskSeparate

+GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_debug_glStencilMaskSeparate;

+#define glStencilMaskSeparate glad_debug_glStencilMaskSeparate

 typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);

 GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader;

-#define glAttachShader glad_glAttachShader

+GLAPI PFNGLATTACHSHADERPROC glad_debug_glAttachShader;

+#define glAttachShader glad_debug_glAttachShader

 typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name);

 GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;

-#define glBindAttribLocation glad_glBindAttribLocation

+GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_debug_glBindAttribLocation;

+#define glBindAttribLocation glad_debug_glBindAttribLocation

 typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader);

 GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader;

-#define glCompileShader glad_glCompileShader

+GLAPI PFNGLCOMPILESHADERPROC glad_debug_glCompileShader;

+#define glCompileShader glad_debug_glCompileShader

 typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void);

 GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram;

-#define glCreateProgram glad_glCreateProgram

+GLAPI PFNGLCREATEPROGRAMPROC glad_debug_glCreateProgram;

+#define glCreateProgram glad_debug_glCreateProgram

 typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type);

 GLAPI PFNGLCREATESHADERPROC glad_glCreateShader;

-#define glCreateShader glad_glCreateShader

+GLAPI PFNGLCREATESHADERPROC glad_debug_glCreateShader;

+#define glCreateShader glad_debug_glCreateShader

 typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program);

 GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;

-#define glDeleteProgram glad_glDeleteProgram

+GLAPI PFNGLDELETEPROGRAMPROC glad_debug_glDeleteProgram;

+#define glDeleteProgram glad_debug_glDeleteProgram

 typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader);

 GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader;

-#define glDeleteShader glad_glDeleteShader

+GLAPI PFNGLDELETESHADERPROC glad_debug_glDeleteShader;

+#define glDeleteShader glad_debug_glDeleteShader

 typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);

 GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader;

-#define glDetachShader glad_glDetachShader

+GLAPI PFNGLDETACHSHADERPROC glad_debug_glDetachShader;

+#define glDetachShader glad_debug_glDetachShader

 typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);

 GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;

-#define glDisableVertexAttribArray glad_glDisableVertexAttribArray

+GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_debug_glDisableVertexAttribArray;

+#define glDisableVertexAttribArray glad_debug_glDisableVertexAttribArray

 typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);

 GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;

-#define glEnableVertexAttribArray glad_glEnableVertexAttribArray

+GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_debug_glEnableVertexAttribArray;

+#define glEnableVertexAttribArray glad_debug_glEnableVertexAttribArray

 typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

 GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;

-#define glGetActiveAttrib glad_glGetActiveAttrib

+GLAPI PFNGLGETACTIVEATTRIBPROC glad_debug_glGetActiveAttrib;

+#define glGetActiveAttrib glad_debug_glGetActiveAttrib

 typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);

 GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;

-#define glGetActiveUniform glad_glGetActiveUniform

+GLAPI PFNGLGETACTIVEUNIFORMPROC glad_debug_glGetActiveUniform;

+#define glGetActiveUniform glad_debug_glGetActiveUniform

 typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);

 GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;

-#define glGetAttachedShaders glad_glGetAttachedShaders

+GLAPI PFNGLGETATTACHEDSHADERSPROC glad_debug_glGetAttachedShaders;

+#define glGetAttachedShaders glad_debug_glGetAttachedShaders

 typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name);

 GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;

-#define glGetAttribLocation glad_glGetAttribLocation

+GLAPI PFNGLGETATTRIBLOCATIONPROC glad_debug_glGetAttribLocation;

+#define glGetAttribLocation glad_debug_glGetAttribLocation

 typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params);

 GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;

-#define glGetProgramiv glad_glGetProgramiv

+GLAPI PFNGLGETPROGRAMIVPROC glad_debug_glGetProgramiv;

+#define glGetProgramiv glad_debug_glGetProgramiv

 typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

 GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;

-#define glGetProgramInfoLog glad_glGetProgramInfoLog

+GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_debug_glGetProgramInfoLog;

+#define glGetProgramInfoLog glad_debug_glGetProgramInfoLog

 typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params);

 GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv;

-#define glGetShaderiv glad_glGetShaderiv

+GLAPI PFNGLGETSHADERIVPROC glad_debug_glGetShaderiv;

+#define glGetShaderiv glad_debug_glGetShaderiv

 typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);

 GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;

-#define glGetShaderInfoLog glad_glGetShaderInfoLog

+GLAPI PFNGLGETSHADERINFOLOGPROC glad_debug_glGetShaderInfoLog;

+#define glGetShaderInfoLog glad_debug_glGetShaderInfoLog

 typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);

 GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;

-#define glGetShaderSource glad_glGetShaderSource

+GLAPI PFNGLGETSHADERSOURCEPROC glad_debug_glGetShaderSource;

+#define glGetShaderSource glad_debug_glGetShaderSource

 typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name);

 GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;

-#define glGetUniformLocation glad_glGetUniformLocation

+GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_debug_glGetUniformLocation;

+#define glGetUniformLocation glad_debug_glGetUniformLocation

 typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params);

 GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;

-#define glGetUniformfv glad_glGetUniformfv

+GLAPI PFNGLGETUNIFORMFVPROC glad_debug_glGetUniformfv;

+#define glGetUniformfv glad_debug_glGetUniformfv

 typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params);

 GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;

-#define glGetUniformiv glad_glGetUniformiv

+GLAPI PFNGLGETUNIFORMIVPROC glad_debug_glGetUniformiv;

+#define glGetUniformiv glad_debug_glGetUniformiv

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params);

 GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;

-#define glGetVertexAttribdv glad_glGetVertexAttribdv

+GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_debug_glGetVertexAttribdv;

+#define glGetVertexAttribdv glad_debug_glGetVertexAttribdv

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params);

 GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;

-#define glGetVertexAttribfv glad_glGetVertexAttribfv

+GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_debug_glGetVertexAttribfv;

+#define glGetVertexAttribfv glad_debug_glGetVertexAttribfv

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params);

 GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;

-#define glGetVertexAttribiv glad_glGetVertexAttribiv

+GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_debug_glGetVertexAttribiv;

+#define glGetVertexAttribiv glad_debug_glGetVertexAttribiv

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer);

 GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;

-#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv

+GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_debug_glGetVertexAttribPointerv;

+#define glGetVertexAttribPointerv glad_debug_glGetVertexAttribPointerv

 typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program);

 GLAPI PFNGLISPROGRAMPROC glad_glIsProgram;

-#define glIsProgram glad_glIsProgram

+GLAPI PFNGLISPROGRAMPROC glad_debug_glIsProgram;

+#define glIsProgram glad_debug_glIsProgram

 typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader);

 GLAPI PFNGLISSHADERPROC glad_glIsShader;

-#define glIsShader glad_glIsShader

+GLAPI PFNGLISSHADERPROC glad_debug_glIsShader;

+#define glIsShader glad_debug_glIsShader

 typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program);

 GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram;

-#define glLinkProgram glad_glLinkProgram

+GLAPI PFNGLLINKPROGRAMPROC glad_debug_glLinkProgram;

+#define glLinkProgram glad_debug_glLinkProgram

 typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);

 GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource;

-#define glShaderSource glad_glShaderSource

+GLAPI PFNGLSHADERSOURCEPROC glad_debug_glShaderSource;

+#define glShaderSource glad_debug_glShaderSource

 typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program);

 GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram;

-#define glUseProgram glad_glUseProgram

+GLAPI PFNGLUSEPROGRAMPROC glad_debug_glUseProgram;

+#define glUseProgram glad_debug_glUseProgram

 typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);

 GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f;

-#define glUniform1f glad_glUniform1f

+GLAPI PFNGLUNIFORM1FPROC glad_debug_glUniform1f;

+#define glUniform1f glad_debug_glUniform1f

 typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);

 GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f;

-#define glUniform2f glad_glUniform2f

+GLAPI PFNGLUNIFORM2FPROC glad_debug_glUniform2f;

+#define glUniform2f glad_debug_glUniform2f

 typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

 GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f;

-#define glUniform3f glad_glUniform3f

+GLAPI PFNGLUNIFORM3FPROC glad_debug_glUniform3f;

+#define glUniform3f glad_debug_glUniform3f

 typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

 GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f;

-#define glUniform4f glad_glUniform4f

+GLAPI PFNGLUNIFORM4FPROC glad_debug_glUniform4f;

+#define glUniform4f glad_debug_glUniform4f

 typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0);

 GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i;

-#define glUniform1i glad_glUniform1i

+GLAPI PFNGLUNIFORM1IPROC glad_debug_glUniform1i;

+#define glUniform1i glad_debug_glUniform1i

 typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);

 GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i;

-#define glUniform2i glad_glUniform2i

+GLAPI PFNGLUNIFORM2IPROC glad_debug_glUniform2i;

+#define glUniform2i glad_debug_glUniform2i

 typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);

 GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i;

-#define glUniform3i glad_glUniform3i

+GLAPI PFNGLUNIFORM3IPROC glad_debug_glUniform3i;

+#define glUniform3i glad_debug_glUniform3i

 typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

 GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i;

-#define glUniform4i glad_glUniform4i

+GLAPI PFNGLUNIFORM4IPROC glad_debug_glUniform4i;

+#define glUniform4i glad_debug_glUniform4i

 typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value);

 GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv;

-#define glUniform1fv glad_glUniform1fv

+GLAPI PFNGLUNIFORM1FVPROC glad_debug_glUniform1fv;

+#define glUniform1fv glad_debug_glUniform1fv

 typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value);

 GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv;

-#define glUniform2fv glad_glUniform2fv

+GLAPI PFNGLUNIFORM2FVPROC glad_debug_glUniform2fv;

+#define glUniform2fv glad_debug_glUniform2fv

 typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value);

 GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv;

-#define glUniform3fv glad_glUniform3fv

+GLAPI PFNGLUNIFORM3FVPROC glad_debug_glUniform3fv;

+#define glUniform3fv glad_debug_glUniform3fv

 typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value);

 GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv;

-#define glUniform4fv glad_glUniform4fv

+GLAPI PFNGLUNIFORM4FVPROC glad_debug_glUniform4fv;

+#define glUniform4fv glad_debug_glUniform4fv

 typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value);

 GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv;

-#define glUniform1iv glad_glUniform1iv

+GLAPI PFNGLUNIFORM1IVPROC glad_debug_glUniform1iv;

+#define glUniform1iv glad_debug_glUniform1iv

 typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value);

 GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv;

-#define glUniform2iv glad_glUniform2iv

+GLAPI PFNGLUNIFORM2IVPROC glad_debug_glUniform2iv;

+#define glUniform2iv glad_debug_glUniform2iv

 typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value);

 GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv;

-#define glUniform3iv glad_glUniform3iv

+GLAPI PFNGLUNIFORM3IVPROC glad_debug_glUniform3iv;

+#define glUniform3iv glad_debug_glUniform3iv

 typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value);

 GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv;

-#define glUniform4iv glad_glUniform4iv

+GLAPI PFNGLUNIFORM4IVPROC glad_debug_glUniform4iv;

+#define glUniform4iv glad_debug_glUniform4iv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;

-#define glUniformMatrix2fv glad_glUniformMatrix2fv

+GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_debug_glUniformMatrix2fv;

+#define glUniformMatrix2fv glad_debug_glUniformMatrix2fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;

-#define glUniformMatrix3fv glad_glUniformMatrix3fv

+GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_debug_glUniformMatrix3fv;

+#define glUniformMatrix3fv glad_debug_glUniformMatrix3fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;

-#define glUniformMatrix4fv glad_glUniformMatrix4fv

+GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_debug_glUniformMatrix4fv;

+#define glUniformMatrix4fv glad_debug_glUniformMatrix4fv

 typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program);

 GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;

-#define glValidateProgram glad_glValidateProgram

+GLAPI PFNGLVALIDATEPROGRAMPROC glad_debug_glValidateProgram;

+#define glValidateProgram glad_debug_glValidateProgram

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);

 GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;

-#define glVertexAttrib1d glad_glVertexAttrib1d

+GLAPI PFNGLVERTEXATTRIB1DPROC glad_debug_glVertexAttrib1d;

+#define glVertexAttrib1d glad_debug_glVertexAttrib1d

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v);

 GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;

-#define glVertexAttrib1dv glad_glVertexAttrib1dv

+GLAPI PFNGLVERTEXATTRIB1DVPROC glad_debug_glVertexAttrib1dv;

+#define glVertexAttrib1dv glad_debug_glVertexAttrib1dv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);

 GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;

-#define glVertexAttrib1f glad_glVertexAttrib1f

+GLAPI PFNGLVERTEXATTRIB1FPROC glad_debug_glVertexAttrib1f;

+#define glVertexAttrib1f glad_debug_glVertexAttrib1f

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v);

 GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;

-#define glVertexAttrib1fv glad_glVertexAttrib1fv

+GLAPI PFNGLVERTEXATTRIB1FVPROC glad_debug_glVertexAttrib1fv;

+#define glVertexAttrib1fv glad_debug_glVertexAttrib1fv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);

 GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;

-#define glVertexAttrib1s glad_glVertexAttrib1s

+GLAPI PFNGLVERTEXATTRIB1SPROC glad_debug_glVertexAttrib1s;

+#define glVertexAttrib1s glad_debug_glVertexAttrib1s

 typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;

-#define glVertexAttrib1sv glad_glVertexAttrib1sv

+GLAPI PFNGLVERTEXATTRIB1SVPROC glad_debug_glVertexAttrib1sv;

+#define glVertexAttrib1sv glad_debug_glVertexAttrib1sv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);

 GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;

-#define glVertexAttrib2d glad_glVertexAttrib2d

+GLAPI PFNGLVERTEXATTRIB2DPROC glad_debug_glVertexAttrib2d;

+#define glVertexAttrib2d glad_debug_glVertexAttrib2d

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v);

 GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;

-#define glVertexAttrib2dv glad_glVertexAttrib2dv

+GLAPI PFNGLVERTEXATTRIB2DVPROC glad_debug_glVertexAttrib2dv;

+#define glVertexAttrib2dv glad_debug_glVertexAttrib2dv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);

 GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;

-#define glVertexAttrib2f glad_glVertexAttrib2f

+GLAPI PFNGLVERTEXATTRIB2FPROC glad_debug_glVertexAttrib2f;

+#define glVertexAttrib2f glad_debug_glVertexAttrib2f

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v);

 GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;

-#define glVertexAttrib2fv glad_glVertexAttrib2fv

+GLAPI PFNGLVERTEXATTRIB2FVPROC glad_debug_glVertexAttrib2fv;

+#define glVertexAttrib2fv glad_debug_glVertexAttrib2fv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);

 GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;

-#define glVertexAttrib2s glad_glVertexAttrib2s

+GLAPI PFNGLVERTEXATTRIB2SPROC glad_debug_glVertexAttrib2s;

+#define glVertexAttrib2s glad_debug_glVertexAttrib2s

 typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;

-#define glVertexAttrib2sv glad_glVertexAttrib2sv

+GLAPI PFNGLVERTEXATTRIB2SVPROC glad_debug_glVertexAttrib2sv;

+#define glVertexAttrib2sv glad_debug_glVertexAttrib2sv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);

 GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;

-#define glVertexAttrib3d glad_glVertexAttrib3d

+GLAPI PFNGLVERTEXATTRIB3DPROC glad_debug_glVertexAttrib3d;

+#define glVertexAttrib3d glad_debug_glVertexAttrib3d

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v);

 GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;

-#define glVertexAttrib3dv glad_glVertexAttrib3dv

+GLAPI PFNGLVERTEXATTRIB3DVPROC glad_debug_glVertexAttrib3dv;

+#define glVertexAttrib3dv glad_debug_glVertexAttrib3dv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);

 GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;

-#define glVertexAttrib3f glad_glVertexAttrib3f

+GLAPI PFNGLVERTEXATTRIB3FPROC glad_debug_glVertexAttrib3f;

+#define glVertexAttrib3f glad_debug_glVertexAttrib3f

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v);

 GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;

-#define glVertexAttrib3fv glad_glVertexAttrib3fv

+GLAPI PFNGLVERTEXATTRIB3FVPROC glad_debug_glVertexAttrib3fv;

+#define glVertexAttrib3fv glad_debug_glVertexAttrib3fv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);

 GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;

-#define glVertexAttrib3s glad_glVertexAttrib3s

+GLAPI PFNGLVERTEXATTRIB3SPROC glad_debug_glVertexAttrib3s;

+#define glVertexAttrib3s glad_debug_glVertexAttrib3s

 typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;

-#define glVertexAttrib3sv glad_glVertexAttrib3sv

+GLAPI PFNGLVERTEXATTRIB3SVPROC glad_debug_glVertexAttrib3sv;

+#define glVertexAttrib3sv glad_debug_glVertexAttrib3sv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v);

 GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;

-#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv

+GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_debug_glVertexAttrib4Nbv;

+#define glVertexAttrib4Nbv glad_debug_glVertexAttrib4Nbv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;

-#define glVertexAttrib4Niv glad_glVertexAttrib4Niv

+GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_debug_glVertexAttrib4Niv;

+#define glVertexAttrib4Niv glad_debug_glVertexAttrib4Niv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;

-#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv

+GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_debug_glVertexAttrib4Nsv;

+#define glVertexAttrib4Nsv glad_debug_glVertexAttrib4Nsv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);

 GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;

-#define glVertexAttrib4Nub glad_glVertexAttrib4Nub

+GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_debug_glVertexAttrib4Nub;

+#define glVertexAttrib4Nub glad_debug_glVertexAttrib4Nub

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v);

 GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;

-#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv

+GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_debug_glVertexAttrib4Nubv;

+#define glVertexAttrib4Nubv glad_debug_glVertexAttrib4Nubv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;

-#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv

+GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_debug_glVertexAttrib4Nuiv;

+#define glVertexAttrib4Nuiv glad_debug_glVertexAttrib4Nuiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v);

 GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;

-#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv

+GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_debug_glVertexAttrib4Nusv;

+#define glVertexAttrib4Nusv glad_debug_glVertexAttrib4Nusv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v);

 GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;

-#define glVertexAttrib4bv glad_glVertexAttrib4bv

+GLAPI PFNGLVERTEXATTRIB4BVPROC glad_debug_glVertexAttrib4bv;

+#define glVertexAttrib4bv glad_debug_glVertexAttrib4bv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);

 GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;

-#define glVertexAttrib4d glad_glVertexAttrib4d

+GLAPI PFNGLVERTEXATTRIB4DPROC glad_debug_glVertexAttrib4d;

+#define glVertexAttrib4d glad_debug_glVertexAttrib4d

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v);

 GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;

-#define glVertexAttrib4dv glad_glVertexAttrib4dv

+GLAPI PFNGLVERTEXATTRIB4DVPROC glad_debug_glVertexAttrib4dv;

+#define glVertexAttrib4dv glad_debug_glVertexAttrib4dv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

 GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;

-#define glVertexAttrib4f glad_glVertexAttrib4f

+GLAPI PFNGLVERTEXATTRIB4FPROC glad_debug_glVertexAttrib4f;

+#define glVertexAttrib4f glad_debug_glVertexAttrib4f

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v);

 GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;

-#define glVertexAttrib4fv glad_glVertexAttrib4fv

+GLAPI PFNGLVERTEXATTRIB4FVPROC glad_debug_glVertexAttrib4fv;

+#define glVertexAttrib4fv glad_debug_glVertexAttrib4fv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;

-#define glVertexAttrib4iv glad_glVertexAttrib4iv

+GLAPI PFNGLVERTEXATTRIB4IVPROC glad_debug_glVertexAttrib4iv;

+#define glVertexAttrib4iv glad_debug_glVertexAttrib4iv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);

 GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;

-#define glVertexAttrib4s glad_glVertexAttrib4s

+GLAPI PFNGLVERTEXATTRIB4SPROC glad_debug_glVertexAttrib4s;

+#define glVertexAttrib4s glad_debug_glVertexAttrib4s

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;

-#define glVertexAttrib4sv glad_glVertexAttrib4sv

+GLAPI PFNGLVERTEXATTRIB4SVPROC glad_debug_glVertexAttrib4sv;

+#define glVertexAttrib4sv glad_debug_glVertexAttrib4sv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v);

 GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;

-#define glVertexAttrib4ubv glad_glVertexAttrib4ubv

+GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_debug_glVertexAttrib4ubv;

+#define glVertexAttrib4ubv glad_debug_glVertexAttrib4ubv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;

-#define glVertexAttrib4uiv glad_glVertexAttrib4uiv

+GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_debug_glVertexAttrib4uiv;

+#define glVertexAttrib4uiv glad_debug_glVertexAttrib4uiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v);

 GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;

-#define glVertexAttrib4usv glad_glVertexAttrib4usv

+GLAPI PFNGLVERTEXATTRIB4USVPROC glad_debug_glVertexAttrib4usv;

+#define glVertexAttrib4usv glad_debug_glVertexAttrib4usv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);

 GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;

-#define glVertexAttribPointer glad_glVertexAttribPointer

+GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_debug_glVertexAttribPointer;

+#define glVertexAttribPointer glad_debug_glVertexAttribPointer

 #endif

 #ifndef GL_VERSION_2_1

 #define GL_VERSION_2_1 1

@@ -1553,22 +1754,28 @@

 GLAPI int GLAD_GL_VERSION_2_1;

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;

-#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv

+GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_debug_glUniformMatrix2x3fv;

+#define glUniformMatrix2x3fv glad_debug_glUniformMatrix2x3fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;

-#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv

+GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_debug_glUniformMatrix3x2fv;

+#define glUniformMatrix3x2fv glad_debug_glUniformMatrix3x2fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;

-#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv

+GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_debug_glUniformMatrix2x4fv;

+#define glUniformMatrix2x4fv glad_debug_glUniformMatrix2x4fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;

-#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv

+GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_debug_glUniformMatrix4x2fv;

+#define glUniformMatrix4x2fv glad_debug_glUniformMatrix4x2fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;

-#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv

+GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_debug_glUniformMatrix3x4fv;

+#define glUniformMatrix3x4fv glad_debug_glUniformMatrix3x4fv

 typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);

 GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;

-#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv

+GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_debug_glUniformMatrix4x3fv;

+#define glUniformMatrix4x3fv glad_debug_glUniformMatrix4x3fv

 #endif

 #ifndef GL_VERSION_3_0

 #define GL_VERSION_3_0 1

@@ -1575,256 +1782,340 @@

 GLAPI int GLAD_GL_VERSION_3_0;

 typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);

 GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski;

-#define glColorMaski glad_glColorMaski

+GLAPI PFNGLCOLORMASKIPROC glad_debug_glColorMaski;

+#define glColorMaski glad_debug_glColorMaski

 typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data);

 GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;

-#define glGetBooleani_v glad_glGetBooleani_v

+GLAPI PFNGLGETBOOLEANI_VPROC glad_debug_glGetBooleani_v;

+#define glGetBooleani_v glad_debug_glGetBooleani_v

 typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data);

 GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;

-#define glGetIntegeri_v glad_glGetIntegeri_v

+GLAPI PFNGLGETINTEGERI_VPROC glad_debug_glGetIntegeri_v;

+#define glGetIntegeri_v glad_debug_glGetIntegeri_v

 typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index);

 GLAPI PFNGLENABLEIPROC glad_glEnablei;

-#define glEnablei glad_glEnablei

+GLAPI PFNGLENABLEIPROC glad_debug_glEnablei;

+#define glEnablei glad_debug_glEnablei

 typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index);

 GLAPI PFNGLDISABLEIPROC glad_glDisablei;

-#define glDisablei glad_glDisablei

+GLAPI PFNGLDISABLEIPROC glad_debug_glDisablei;

+#define glDisablei glad_debug_glDisablei

 typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index);

 GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi;

-#define glIsEnabledi glad_glIsEnabledi

+GLAPI PFNGLISENABLEDIPROC glad_debug_glIsEnabledi;

+#define glIsEnabledi glad_debug_glIsEnabledi

 typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);

 GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;

-#define glBeginTransformFeedback glad_glBeginTransformFeedback

+GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_debug_glBeginTransformFeedback;

+#define glBeginTransformFeedback glad_debug_glBeginTransformFeedback

 typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void);

 GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;

-#define glEndTransformFeedback glad_glEndTransformFeedback

+GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_debug_glEndTransformFeedback;

+#define glEndTransformFeedback glad_debug_glEndTransformFeedback

 typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);

 GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;

-#define glBindBufferRange glad_glBindBufferRange

+GLAPI PFNGLBINDBUFFERRANGEPROC glad_debug_glBindBufferRange;

+#define glBindBufferRange glad_debug_glBindBufferRange

 typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);

 GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;

-#define glBindBufferBase glad_glBindBufferBase

+GLAPI PFNGLBINDBUFFERBASEPROC glad_debug_glBindBufferBase;

+#define glBindBufferBase glad_debug_glBindBufferBase

 typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);

 GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;

-#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings

+GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_debug_glTransformFeedbackVaryings;

+#define glTransformFeedbackVaryings glad_debug_glTransformFeedbackVaryings

 typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);

 GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;

-#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying

+GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_debug_glGetTransformFeedbackVarying;

+#define glGetTransformFeedbackVarying glad_debug_glGetTransformFeedbackVarying

 typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);

 GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor;

-#define glClampColor glad_glClampColor

+GLAPI PFNGLCLAMPCOLORPROC glad_debug_glClampColor;

+#define glClampColor glad_debug_glClampColor

 typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);

 GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;

-#define glBeginConditionalRender glad_glBeginConditionalRender

+GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_debug_glBeginConditionalRender;

+#define glBeginConditionalRender glad_debug_glBeginConditionalRender

 typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void);

 GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;

-#define glEndConditionalRender glad_glEndConditionalRender

+GLAPI PFNGLENDCONDITIONALRENDERPROC glad_debug_glEndConditionalRender;

+#define glEndConditionalRender glad_debug_glEndConditionalRender

 typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);

 GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;

-#define glVertexAttribIPointer glad_glVertexAttribIPointer

+GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_debug_glVertexAttribIPointer;

+#define glVertexAttribIPointer glad_debug_glVertexAttribIPointer

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params);

 GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;

-#define glGetVertexAttribIiv glad_glGetVertexAttribIiv

+GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_debug_glGetVertexAttribIiv;

+#define glGetVertexAttribIiv glad_debug_glGetVertexAttribIiv

 typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params);

 GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;

-#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv

+GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_debug_glGetVertexAttribIuiv;

+#define glGetVertexAttribIuiv glad_debug_glGetVertexAttribIuiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);

 GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;

-#define glVertexAttribI1i glad_glVertexAttribI1i

+GLAPI PFNGLVERTEXATTRIBI1IPROC glad_debug_glVertexAttribI1i;

+#define glVertexAttribI1i glad_debug_glVertexAttribI1i

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);

 GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;

-#define glVertexAttribI2i glad_glVertexAttribI2i

+GLAPI PFNGLVERTEXATTRIBI2IPROC glad_debug_glVertexAttribI2i;

+#define glVertexAttribI2i glad_debug_glVertexAttribI2i

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);

 GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;

-#define glVertexAttribI3i glad_glVertexAttribI3i

+GLAPI PFNGLVERTEXATTRIBI3IPROC glad_debug_glVertexAttribI3i;

+#define glVertexAttribI3i glad_debug_glVertexAttribI3i

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);

 GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;

-#define glVertexAttribI4i glad_glVertexAttribI4i

+GLAPI PFNGLVERTEXATTRIBI4IPROC glad_debug_glVertexAttribI4i;

+#define glVertexAttribI4i glad_debug_glVertexAttribI4i

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);

 GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;

-#define glVertexAttribI1ui glad_glVertexAttribI1ui

+GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_debug_glVertexAttribI1ui;

+#define glVertexAttribI1ui glad_debug_glVertexAttribI1ui

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);

 GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;

-#define glVertexAttribI2ui glad_glVertexAttribI2ui

+GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_debug_glVertexAttribI2ui;

+#define glVertexAttribI2ui glad_debug_glVertexAttribI2ui

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);

 GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;

-#define glVertexAttribI3ui glad_glVertexAttribI3ui

+GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_debug_glVertexAttribI3ui;

+#define glVertexAttribI3ui glad_debug_glVertexAttribI3ui

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);

 GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;

-#define glVertexAttribI4ui glad_glVertexAttribI4ui

+GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_debug_glVertexAttribI4ui;

+#define glVertexAttribI4ui glad_debug_glVertexAttribI4ui

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;

-#define glVertexAttribI1iv glad_glVertexAttribI1iv

+GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_debug_glVertexAttribI1iv;

+#define glVertexAttribI1iv glad_debug_glVertexAttribI1iv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;

-#define glVertexAttribI2iv glad_glVertexAttribI2iv

+GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_debug_glVertexAttribI2iv;

+#define glVertexAttribI2iv glad_debug_glVertexAttribI2iv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;

-#define glVertexAttribI3iv glad_glVertexAttribI3iv

+GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_debug_glVertexAttribI3iv;

+#define glVertexAttribI3iv glad_debug_glVertexAttribI3iv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v);

 GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;

-#define glVertexAttribI4iv glad_glVertexAttribI4iv

+GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_debug_glVertexAttribI4iv;

+#define glVertexAttribI4iv glad_debug_glVertexAttribI4iv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;

-#define glVertexAttribI1uiv glad_glVertexAttribI1uiv

+GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_debug_glVertexAttribI1uiv;

+#define glVertexAttribI1uiv glad_debug_glVertexAttribI1uiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;

-#define glVertexAttribI2uiv glad_glVertexAttribI2uiv

+GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_debug_glVertexAttribI2uiv;

+#define glVertexAttribI2uiv glad_debug_glVertexAttribI2uiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;

-#define glVertexAttribI3uiv glad_glVertexAttribI3uiv

+GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_debug_glVertexAttribI3uiv;

+#define glVertexAttribI3uiv glad_debug_glVertexAttribI3uiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v);

 GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;

-#define glVertexAttribI4uiv glad_glVertexAttribI4uiv

+GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_debug_glVertexAttribI4uiv;

+#define glVertexAttribI4uiv glad_debug_glVertexAttribI4uiv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v);

 GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;

-#define glVertexAttribI4bv glad_glVertexAttribI4bv

+GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_debug_glVertexAttribI4bv;

+#define glVertexAttribI4bv glad_debug_glVertexAttribI4bv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v);

 GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;

-#define glVertexAttribI4sv glad_glVertexAttribI4sv

+GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_debug_glVertexAttribI4sv;

+#define glVertexAttribI4sv glad_debug_glVertexAttribI4sv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v);

 GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;

-#define glVertexAttribI4ubv glad_glVertexAttribI4ubv

+GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_debug_glVertexAttribI4ubv;

+#define glVertexAttribI4ubv glad_debug_glVertexAttribI4ubv

 typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v);

 GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;

-#define glVertexAttribI4usv glad_glVertexAttribI4usv

+GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_debug_glVertexAttribI4usv;

+#define glVertexAttribI4usv glad_debug_glVertexAttribI4usv

 typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params);

 GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;

-#define glGetUniformuiv glad_glGetUniformuiv

+GLAPI PFNGLGETUNIFORMUIVPROC glad_debug_glGetUniformuiv;

+#define glGetUniformuiv glad_debug_glGetUniformuiv

 typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name);

 GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;

-#define glBindFragDataLocation glad_glBindFragDataLocation

+GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_debug_glBindFragDataLocation;

+#define glBindFragDataLocation glad_debug_glBindFragDataLocation

 typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name);

 GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;

-#define glGetFragDataLocation glad_glGetFragDataLocation

+GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_debug_glGetFragDataLocation;

+#define glGetFragDataLocation glad_debug_glGetFragDataLocation

 typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);

 GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui;

-#define glUniform1ui glad_glUniform1ui

+GLAPI PFNGLUNIFORM1UIPROC glad_debug_glUniform1ui;

+#define glUniform1ui glad_debug_glUniform1ui

 typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);

 GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui;

-#define glUniform2ui glad_glUniform2ui

+GLAPI PFNGLUNIFORM2UIPROC glad_debug_glUniform2ui;

+#define glUniform2ui glad_debug_glUniform2ui

 typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);

 GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui;

-#define glUniform3ui glad_glUniform3ui

+GLAPI PFNGLUNIFORM3UIPROC glad_debug_glUniform3ui;

+#define glUniform3ui glad_debug_glUniform3ui

 typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

 GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui;

-#define glUniform4ui glad_glUniform4ui

+GLAPI PFNGLUNIFORM4UIPROC glad_debug_glUniform4ui;

+#define glUniform4ui glad_debug_glUniform4ui

 typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value);

 GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;

-#define glUniform1uiv glad_glUniform1uiv

+GLAPI PFNGLUNIFORM1UIVPROC glad_debug_glUniform1uiv;

+#define glUniform1uiv glad_debug_glUniform1uiv

 typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value);

 GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;

-#define glUniform2uiv glad_glUniform2uiv

+GLAPI PFNGLUNIFORM2UIVPROC glad_debug_glUniform2uiv;

+#define glUniform2uiv glad_debug_glUniform2uiv

 typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value);

 GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;

-#define glUniform3uiv glad_glUniform3uiv

+GLAPI PFNGLUNIFORM3UIVPROC glad_debug_glUniform3uiv;

+#define glUniform3uiv glad_debug_glUniform3uiv

 typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value);

 GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;

-#define glUniform4uiv glad_glUniform4uiv

+GLAPI PFNGLUNIFORM4UIVPROC glad_debug_glUniform4uiv;

+#define glUniform4uiv glad_debug_glUniform4uiv

 typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params);

 GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;

-#define glTexParameterIiv glad_glTexParameterIiv

+GLAPI PFNGLTEXPARAMETERIIVPROC glad_debug_glTexParameterIiv;

+#define glTexParameterIiv glad_debug_glTexParameterIiv

 typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params);

 GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;

-#define glTexParameterIuiv glad_glTexParameterIuiv

+GLAPI PFNGLTEXPARAMETERIUIVPROC glad_debug_glTexParameterIuiv;

+#define glTexParameterIuiv glad_debug_glTexParameterIuiv

 typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params);

 GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;

-#define glGetTexParameterIiv glad_glGetTexParameterIiv

+GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_debug_glGetTexParameterIiv;

+#define glGetTexParameterIiv glad_debug_glGetTexParameterIiv

 typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params);

 GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;

-#define glGetTexParameterIuiv glad_glGetTexParameterIuiv

+GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_debug_glGetTexParameterIuiv;

+#define glGetTexParameterIuiv glad_debug_glGetTexParameterIuiv

 typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value);

 GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;

-#define glClearBufferiv glad_glClearBufferiv

+GLAPI PFNGLCLEARBUFFERIVPROC glad_debug_glClearBufferiv;

+#define glClearBufferiv glad_debug_glClearBufferiv

 typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value);

 GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;

-#define glClearBufferuiv glad_glClearBufferuiv

+GLAPI PFNGLCLEARBUFFERUIVPROC glad_debug_glClearBufferuiv;

+#define glClearBufferuiv glad_debug_glClearBufferuiv

 typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value);

 GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;

-#define glClearBufferfv glad_glClearBufferfv

+GLAPI PFNGLCLEARBUFFERFVPROC glad_debug_glClearBufferfv;

+#define glClearBufferfv glad_debug_glClearBufferfv

 typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);

 GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;

-#define glClearBufferfi glad_glClearBufferfi

+GLAPI PFNGLCLEARBUFFERFIPROC glad_debug_glClearBufferfi;

+#define glClearBufferfi glad_debug_glClearBufferfi

 typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);

 GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi;

-#define glGetStringi glad_glGetStringi

+GLAPI PFNGLGETSTRINGIPROC glad_debug_glGetStringi;

+#define glGetStringi glad_debug_glGetStringi

 typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);

 GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;

-#define glIsRenderbuffer glad_glIsRenderbuffer

+GLAPI PFNGLISRENDERBUFFERPROC glad_debug_glIsRenderbuffer;

+#define glIsRenderbuffer glad_debug_glIsRenderbuffer

 typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);

 GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;

-#define glBindRenderbuffer glad_glBindRenderbuffer

+GLAPI PFNGLBINDRENDERBUFFERPROC glad_debug_glBindRenderbuffer;

+#define glBindRenderbuffer glad_debug_glBindRenderbuffer

 typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers);

 GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;

-#define glDeleteRenderbuffers glad_glDeleteRenderbuffers

+GLAPI PFNGLDELETERENDERBUFFERSPROC glad_debug_glDeleteRenderbuffers;

+#define glDeleteRenderbuffers glad_debug_glDeleteRenderbuffers

 typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers);

 GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;

-#define glGenRenderbuffers glad_glGenRenderbuffers

+GLAPI PFNGLGENRENDERBUFFERSPROC glad_debug_glGenRenderbuffers;

+#define glGenRenderbuffers glad_debug_glGenRenderbuffers

 typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

 GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;

-#define glRenderbufferStorage glad_glRenderbufferStorage

+GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_debug_glRenderbufferStorage;

+#define glRenderbufferStorage glad_debug_glRenderbufferStorage

 typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params);

 GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;

-#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv

+GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_debug_glGetRenderbufferParameteriv;

+#define glGetRenderbufferParameteriv glad_debug_glGetRenderbufferParameteriv

 typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);

 GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;

-#define glIsFramebuffer glad_glIsFramebuffer

+GLAPI PFNGLISFRAMEBUFFERPROC glad_debug_glIsFramebuffer;

+#define glIsFramebuffer glad_debug_glIsFramebuffer

 typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);

 GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;

-#define glBindFramebuffer glad_glBindFramebuffer

+GLAPI PFNGLBINDFRAMEBUFFERPROC glad_debug_glBindFramebuffer;

+#define glBindFramebuffer glad_debug_glBindFramebuffer

 typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers);

 GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;

-#define glDeleteFramebuffers glad_glDeleteFramebuffers

+GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_debug_glDeleteFramebuffers;

+#define glDeleteFramebuffers glad_debug_glDeleteFramebuffers

 typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers);

 GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;

-#define glGenFramebuffers glad_glGenFramebuffers

+GLAPI PFNGLGENFRAMEBUFFERSPROC glad_debug_glGenFramebuffers;

+#define glGenFramebuffers glad_debug_glGenFramebuffers

 typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);

 GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;

-#define glCheckFramebufferStatus glad_glCheckFramebufferStatus

+GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_debug_glCheckFramebufferStatus;

+#define glCheckFramebufferStatus glad_debug_glCheckFramebufferStatus

 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

 GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;

-#define glFramebufferTexture1D glad_glFramebufferTexture1D

+GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_debug_glFramebufferTexture1D;

+#define glFramebufferTexture1D glad_debug_glFramebufferTexture1D

 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

 GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;

-#define glFramebufferTexture2D glad_glFramebufferTexture2D

+GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_debug_glFramebufferTexture2D;

+#define glFramebufferTexture2D glad_debug_glFramebufferTexture2D

 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);

 GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;

-#define glFramebufferTexture3D glad_glFramebufferTexture3D

+GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_debug_glFramebufferTexture3D;

+#define glFramebufferTexture3D glad_debug_glFramebufferTexture3D

 typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

 GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;

-#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer

+GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_debug_glFramebufferRenderbuffer;

+#define glFramebufferRenderbuffer glad_debug_glFramebufferRenderbuffer

 typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params);

 GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;

-#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv

+GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_debug_glGetFramebufferAttachmentParameteriv;

+#define glGetFramebufferAttachmentParameteriv glad_debug_glGetFramebufferAttachmentParameteriv

 typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target);

 GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;

-#define glGenerateMipmap glad_glGenerateMipmap

+GLAPI PFNGLGENERATEMIPMAPPROC glad_debug_glGenerateMipmap;

+#define glGenerateMipmap glad_debug_glGenerateMipmap

 typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

 GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;

-#define glBlitFramebuffer glad_glBlitFramebuffer

+GLAPI PFNGLBLITFRAMEBUFFERPROC glad_debug_glBlitFramebuffer;

+#define glBlitFramebuffer glad_debug_glBlitFramebuffer

 typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

 GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;

-#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample

+GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_debug_glRenderbufferStorageMultisample;

+#define glRenderbufferStorageMultisample glad_debug_glRenderbufferStorageMultisample

 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);

 GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;

-#define glFramebufferTextureLayer glad_glFramebufferTextureLayer

+GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_debug_glFramebufferTextureLayer;

+#define glFramebufferTextureLayer glad_debug_glFramebufferTextureLayer

 typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);

 GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;

-#define glMapBufferRange glad_glMapBufferRange

+GLAPI PFNGLMAPBUFFERRANGEPROC glad_debug_glMapBufferRange;

+#define glMapBufferRange glad_debug_glMapBufferRange

 typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);

 GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;

-#define glFlushMappedBufferRange glad_glFlushMappedBufferRange

+GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_debug_glFlushMappedBufferRange;

+#define glFlushMappedBufferRange glad_debug_glFlushMappedBufferRange

 typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array);

 GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;

-#define glBindVertexArray glad_glBindVertexArray

+GLAPI PFNGLBINDVERTEXARRAYPROC glad_debug_glBindVertexArray;

+#define glBindVertexArray glad_debug_glBindVertexArray

 typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays);

 GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;

-#define glDeleteVertexArrays glad_glDeleteVertexArrays

+GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_debug_glDeleteVertexArrays;

+#define glDeleteVertexArrays glad_debug_glDeleteVertexArrays

 typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays);

 GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;

-#define glGenVertexArrays glad_glGenVertexArrays

+GLAPI PFNGLGENVERTEXARRAYSPROC glad_debug_glGenVertexArrays;

+#define glGenVertexArrays glad_debug_glGenVertexArrays

 typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array);

 GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;

-#define glIsVertexArray glad_glIsVertexArray

+GLAPI PFNGLISVERTEXARRAYPROC glad_debug_glIsVertexArray;

+#define glIsVertexArray glad_debug_glIsVertexArray

 #endif

 #ifndef GL_VERSION_3_1

 #define GL_VERSION_3_1 1

@@ -1831,40 +2122,52 @@

 GLAPI int GLAD_GL_VERSION_3_1;

 typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);

 GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;

-#define glDrawArraysInstanced glad_glDrawArraysInstanced

+GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_debug_glDrawArraysInstanced;

+#define glDrawArraysInstanced glad_debug_glDrawArraysInstanced

 typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);

 GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;

-#define glDrawElementsInstanced glad_glDrawElementsInstanced

+GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_debug_glDrawElementsInstanced;

+#define glDrawElementsInstanced glad_debug_glDrawElementsInstanced

 typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);

 GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer;

-#define glTexBuffer glad_glTexBuffer

+GLAPI PFNGLTEXBUFFERPROC glad_debug_glTexBuffer;

+#define glTexBuffer glad_debug_glTexBuffer

 typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);

 GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;

-#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex

+GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_debug_glPrimitiveRestartIndex;

+#define glPrimitiveRestartIndex glad_debug_glPrimitiveRestartIndex

 typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);

 GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;

-#define glCopyBufferSubData glad_glCopyBufferSubData

+GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_debug_glCopyBufferSubData;

+#define glCopyBufferSubData glad_debug_glCopyBufferSubData

 typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);

 GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;

-#define glGetUniformIndices glad_glGetUniformIndices

+GLAPI PFNGLGETUNIFORMINDICESPROC glad_debug_glGetUniformIndices;

+#define glGetUniformIndices glad_debug_glGetUniformIndices

 typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);

 GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;

-#define glGetActiveUniformsiv glad_glGetActiveUniformsiv

+GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_debug_glGetActiveUniformsiv;

+#define glGetActiveUniformsiv glad_debug_glGetActiveUniformsiv

 typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);

 GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;

-#define glGetActiveUniformName glad_glGetActiveUniformName

+GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_debug_glGetActiveUniformName;

+#define glGetActiveUniformName glad_debug_glGetActiveUniformName

 typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName);

 GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;

-#define glGetUniformBlockIndex glad_glGetUniformBlockIndex

+GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_debug_glGetUniformBlockIndex;

+#define glGetUniformBlockIndex glad_debug_glGetUniformBlockIndex

 typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);

 GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;

-#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv

+GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_debug_glGetActiveUniformBlockiv;

+#define glGetActiveUniformBlockiv glad_debug_glGetActiveUniformBlockiv

 typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);

 GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;

-#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName

+GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_debug_glGetActiveUniformBlockName;

+#define glGetActiveUniformBlockName glad_debug_glGetActiveUniformBlockName

 typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);

 GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;

-#define glUniformBlockBinding glad_glUniformBlockBinding

+GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_debug_glUniformBlockBinding;

+#define glUniformBlockBinding glad_debug_glUniformBlockBinding

 #endif

 #ifndef GL_VERSION_3_2

 #define GL_VERSION_3_2 1

@@ -1871,61 +2174,80 @@

 GLAPI int GLAD_GL_VERSION_3_2;

 typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);

 GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;

-#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex

+GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_debug_glDrawElementsBaseVertex;

+#define glDrawElementsBaseVertex glad_debug_glDrawElementsBaseVertex

 typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex);

 GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;

-#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex

+GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_debug_glDrawRangeElementsBaseVertex;

+#define glDrawRangeElementsBaseVertex glad_debug_glDrawRangeElementsBaseVertex

 typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex);

 GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;

-#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex

+GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_debug_glDrawElementsInstancedBaseVertex;

+#define glDrawElementsInstancedBaseVertex glad_debug_glDrawElementsInstancedBaseVertex

 typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex);

 GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;

-#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex

+GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_debug_glMultiDrawElementsBaseVertex;

+#define glMultiDrawElementsBaseVertex glad_debug_glMultiDrawElementsBaseVertex

 typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode);

 GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;

-#define glProvokingVertex glad_glProvokingVertex

+GLAPI PFNGLPROVOKINGVERTEXPROC glad_debug_glProvokingVertex;

+#define glProvokingVertex glad_debug_glProvokingVertex

 typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);

 GLAPI PFNGLFENCESYNCPROC glad_glFenceSync;

-#define glFenceSync glad_glFenceSync

+GLAPI PFNGLFENCESYNCPROC glad_debug_glFenceSync;

+#define glFenceSync glad_debug_glFenceSync

 typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync);

 GLAPI PFNGLISSYNCPROC glad_glIsSync;

-#define glIsSync glad_glIsSync

+GLAPI PFNGLISSYNCPROC glad_debug_glIsSync;

+#define glIsSync glad_debug_glIsSync

 typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync);

 GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync;

-#define glDeleteSync glad_glDeleteSync

+GLAPI PFNGLDELETESYNCPROC glad_debug_glDeleteSync;

+#define glDeleteSync glad_debug_glDeleteSync

 typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);

 GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;

-#define glClientWaitSync glad_glClientWaitSync

+GLAPI PFNGLCLIENTWAITSYNCPROC glad_debug_glClientWaitSync;

+#define glClientWaitSync glad_debug_glClientWaitSync

 typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);

 GLAPI PFNGLWAITSYNCPROC glad_glWaitSync;

-#define glWaitSync glad_glWaitSync

+GLAPI PFNGLWAITSYNCPROC glad_debug_glWaitSync;

+#define glWaitSync glad_debug_glWaitSync

 typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data);

 GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v;

-#define glGetInteger64v glad_glGetInteger64v

+GLAPI PFNGLGETINTEGER64VPROC glad_debug_glGetInteger64v;

+#define glGetInteger64v glad_debug_glGetInteger64v

 typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values);

 GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv;

-#define glGetSynciv glad_glGetSynciv

+GLAPI PFNGLGETSYNCIVPROC glad_debug_glGetSynciv;

+#define glGetSynciv glad_debug_glGetSynciv

 typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data);

 GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;

-#define glGetInteger64i_v glad_glGetInteger64i_v

+GLAPI PFNGLGETINTEGER64I_VPROC glad_debug_glGetInteger64i_v;

+#define glGetInteger64i_v glad_debug_glGetInteger64i_v

 typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params);

 GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;

-#define glGetBufferParameteri64v glad_glGetBufferParameteri64v

+GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_debug_glGetBufferParameteri64v;

+#define glGetBufferParameteri64v glad_debug_glGetBufferParameteri64v

 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);

 GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;

-#define glFramebufferTexture glad_glFramebufferTexture

+GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_debug_glFramebufferTexture;

+#define glFramebufferTexture glad_debug_glFramebufferTexture

 typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

 GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;

-#define glTexImage2DMultisample glad_glTexImage2DMultisample

+GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_debug_glTexImage2DMultisample;

+#define glTexImage2DMultisample glad_debug_glTexImage2DMultisample

 typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

 GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;

-#define glTexImage3DMultisample glad_glTexImage3DMultisample

+GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_debug_glTexImage3DMultisample;

+#define glTexImage3DMultisample glad_debug_glTexImage3DMultisample

 typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val);

 GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;

-#define glGetMultisamplefv glad_glGetMultisamplefv

+GLAPI PFNGLGETMULTISAMPLEFVPROC glad_debug_glGetMultisamplefv;

+#define glGetMultisamplefv glad_debug_glGetMultisamplefv

 typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);

 GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski;

-#define glSampleMaski glad_glSampleMaski

+GLAPI PFNGLSAMPLEMASKIPROC glad_debug_glSampleMaski;

+#define glSampleMaski glad_debug_glSampleMaski

 #endif

 #ifdef __cplusplus

--- a/external/glad/src/glad.c

+++ b/external/glad/src/glad.c

@@ -1,8 +1,8 @@

/*

-    OpenGL loader generated by glad 0.1.33 on Wed Jan 15 07:22:49 2020.

+    OpenGL loader generated by glad 0.1.33 on Sat Apr 11 21:37:37 2020.

-    Language/Generator: C/C++

+    Language/Generator: C/C++ Debug

     Specification: gl

     APIs: gl=3.2

     Profile: core

@@ -14,9 +14,9 @@

     Reproducible: False

     Commandline:

-        --profile="core" --api="gl=3.2" --generator="c" --spec="gl" --extensions=""

+        --profile="core" --api="gl=3.2" --generator="c-debug" --spec="gl" --extensions=""

     Online:

-        https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.2

+        https://glad.dav1d.de/#profile=core&language=c-debug&specification=gl&loader=on&api=gl%3D3.2

*/

 #include <stdio.h>

@@ -24,6 +24,34 @@

 #include <string.h>

 #include <glad/glad.h>

+void _pre_call_callback_default(const char *name, void *funcptr, int len_args, ...) {

+    (void) name;

+    (void) funcptr;

+    (void) len_args;

+}

+void _post_call_callback_default(const char *name, void *funcptr, int len_args, ...) {

+    GLenum error_code;

+    (void) funcptr;

+    (void) len_args;

+    error_code = glad_glGetError();

+    if (error_code != GL_NO_ERROR) {

+        fprintf(stderr, "ERROR %d in %s\n", error_code, name);

+    }

+}

+static GLADcallback _pre_call_callback = _pre_call_callback_default;

+void glad_set_pre_callback(GLADcallback cb) {

+    _pre_call_callback = cb;

+}

+static GLADcallback _post_call_callback = _post_call_callback_default;

+void glad_set_post_callback(GLADcallback cb) {

+    _post_call_callback = cb;

+}

 static void* get_proc(const char *namez);

 #if defined(_WIN32) || defined(__CYGWIN__)

@@ -266,322 +294,2560 @@

 int GLAD_GL_VERSION_3_0 = 0;

 int GLAD_GL_VERSION_3_1 = 0;

 int GLAD_GL_VERSION_3_2 = 0;

-PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL;

-PFNGLATTACHSHADERPROC glad_glAttachShader = NULL;

-PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL;

-PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL;

-PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL;

-PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL;

-PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL;

-PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL;

-PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL;

-PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL;

-PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL;

-PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL;

-PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL;

-PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL;

-PFNGLBLENDCOLORPROC glad_glBlendColor = NULL;

-PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL;

-PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL;

-PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL;

-PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL;

-PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL;

-PFNGLBUFFERDATAPROC glad_glBufferData = NULL;

-PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL;

-PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL;

-PFNGLCLAMPCOLORPROC glad_glClampColor = NULL;

-PFNGLCLEARPROC glad_glClear = NULL;

-PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL;

-PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL;

-PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL;

-PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL;

-PFNGLCLEARCOLORPROC glad_glClearColor = NULL;

-PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL;

-PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL;

-PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL;

-PFNGLCOLORMASKPROC glad_glColorMask = NULL;

-PFNGLCOLORMASKIPROC glad_glColorMaski = NULL;

-PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL;

-PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL;

-PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL;

-PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL;

-PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL;

-PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL;

-PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL;

-PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL;

-PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL;

-PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL;

-PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL;

-PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL;

-PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL;

-PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL;

-PFNGLCREATESHADERPROC glad_glCreateShader = NULL;

-PFNGLCULLFACEPROC glad_glCullFace = NULL;

-PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL;

-PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL;

-PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL;

-PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL;

-PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL;

-PFNGLDELETESHADERPROC glad_glDeleteShader = NULL;

-PFNGLDELETESYNCPROC glad_glDeleteSync = NULL;

-PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL;

-PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL;

-PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL;

-PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;

-PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;

-PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;

-PFNGLDISABLEPROC glad_glDisable = NULL;

-PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL;

-PFNGLDISABLEIPROC glad_glDisablei = NULL;

-PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL;

-PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL;

-PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL;

-PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL;

-PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL;

-PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL;

-PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL;

-PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL;

-PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL;

-PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL;

-PFNGLENABLEPROC glad_glEnable = NULL;

-PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL;

-PFNGLENABLEIPROC glad_glEnablei = NULL;

-PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL;

-PFNGLENDQUERYPROC glad_glEndQuery = NULL;

-PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL;

-PFNGLFENCESYNCPROC glad_glFenceSync = NULL;

-PFNGLFINISHPROC glad_glFinish = NULL;

-PFNGLFLUSHPROC glad_glFlush = NULL;

-PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL;

-PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL;

-PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL;

-PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL;

-PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL;

-PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL;

-PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL;

-PFNGLFRONTFACEPROC glad_glFrontFace = NULL;

-PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL;

-PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL;

-PFNGLGENQUERIESPROC glad_glGenQueries = NULL;

-PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL;

-PFNGLGENTEXTURESPROC glad_glGenTextures = NULL;

-PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL;

-PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL;

-PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL;

-PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL;

-PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL;

-PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL;

-PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL;

-PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL;

-PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL;

-PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL;

-PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL;

-PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL;

-PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL;

-PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL;

-PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL;

-PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL;

-PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL;

-PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL;

-PFNGLGETERRORPROC glad_glGetError = NULL;

-PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;

-PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;

-PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;

-PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL;

-PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL;

-PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL;

-PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL;

-PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL;

-PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL;

-PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL;

-PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL;

-PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL;

-PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL;

-PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL;

-PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL;

-PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL;

-PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL;

-PFNGLGETSTRINGPROC glad_glGetString = NULL;

-PFNGLGETSTRINGIPROC glad_glGetStringi = NULL;

-PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;

-PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;

-PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL;

-PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL;

-PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL;

-PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL;

-PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL;

-PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL;

-PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL;

-PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL;

-PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL;

-PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL;

-PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL;

-PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL;

-PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL;

-PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL;

-PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL;

-PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL;

-PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL;

-PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL;

-PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL;

-PFNGLHINTPROC glad_glHint = NULL;

-PFNGLISBUFFERPROC glad_glIsBuffer = NULL;

-PFNGLISENABLEDPROC glad_glIsEnabled = NULL;

-PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL;

-PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL;

-PFNGLISPROGRAMPROC glad_glIsProgram = NULL;

-PFNGLISQUERYPROC glad_glIsQuery = NULL;

-PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL;

-PFNGLISSHADERPROC glad_glIsShader = NULL;

-PFNGLISSYNCPROC glad_glIsSync = NULL;

-PFNGLISTEXTUREPROC glad_glIsTexture = NULL;

-PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL;

-PFNGLLINEWIDTHPROC glad_glLineWidth = NULL;

-PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL;

-PFNGLLOGICOPPROC glad_glLogicOp = NULL;

-PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL;

-PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL;

-PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL;

-PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL;

-PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL;

-PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL;

-PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL;

-PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL;

-PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL;

-PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL;

-PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL;

-PFNGLPOINTSIZEPROC glad_glPointSize = NULL;

-PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL;

-PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL;

-PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL;

-PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL;

-PFNGLREADBUFFERPROC glad_glReadBuffer = NULL;

-PFNGLREADPIXELSPROC glad_glReadPixels = NULL;

-PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL;

-PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL;

-PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL;

-PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL;

-PFNGLSCISSORPROC glad_glScissor = NULL;

-PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL;

-PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL;

-PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL;

-PFNGLSTENCILMASKPROC glad_glStencilMask = NULL;

-PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL;

-PFNGLSTENCILOPPROC glad_glStencilOp = NULL;

-PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL;

-PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL;

-PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL;

-PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL;

-PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL;

-PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL;

-PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL;

-PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL;

-PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL;

-PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL;

-PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL;

-PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL;

-PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL;

-PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL;

-PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL;

-PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL;

-PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL;

-PFNGLUNIFORM1FPROC glad_glUniform1f = NULL;

-PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL;

-PFNGLUNIFORM1IPROC glad_glUniform1i = NULL;

-PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL;

-PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL;

-PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL;

-PFNGLUNIFORM2FPROC glad_glUniform2f = NULL;

-PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL;

-PFNGLUNIFORM2IPROC glad_glUniform2i = NULL;

-PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL;

-PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL;

-PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL;

-PFNGLUNIFORM3FPROC glad_glUniform3f = NULL;

-PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL;

-PFNGLUNIFORM3IPROC glad_glUniform3i = NULL;

-PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL;

-PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL;

-PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL;

-PFNGLUNIFORM4FPROC glad_glUniform4f = NULL;

-PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL;

-PFNGLUNIFORM4IPROC glad_glUniform4i = NULL;

-PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL;

-PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL;

-PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL;

-PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL;

-PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL;

-PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL;

-PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL;

-PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL;

-PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL;

-PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL;

-PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL;

-PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL;

-PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL;

-PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL;

-PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL;

-PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL;

-PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL;

-PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL;

-PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL;

-PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL;

-PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL;

-PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL;

-PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL;

-PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL;

-PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL;

-PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL;

-PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL;

-PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL;

-PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL;

-PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL;

-PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL;

-PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL;

-PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL;

-PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL;

-PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL;

-PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL;

-PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL;

-PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL;

-PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL;

-PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL;

-PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL;

-PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL;

-PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL;

-PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL;

-PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL;

-PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL;

-PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL;

-PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL;

-PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL;

-PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL;

-PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL;

-PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL;

-PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL;

-PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL;

-PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL;

-PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL;

-PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL;

-PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL;

-PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL;

-PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL;

-PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL;

-PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL;

-PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL;

-PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL;

-PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL;

-PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL;

-PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL;

-PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL;

-PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL;

-PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL;

-PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL;

-PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL;

-PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL;

-PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL;

-PFNGLVIEWPORTPROC glad_glViewport = NULL;

-PFNGLWAITSYNCPROC glad_glWaitSync = NULL;

+PFNGLACTIVETEXTUREPROC glad_glActiveTexture;

+void APIENTRY glad_debug_impl_glActiveTexture(GLenum arg0) {

+    _pre_call_callback("glActiveTexture", (void*)glActiveTexture, 1, arg0);

+     glad_glActiveTexture(arg0);

+    _post_call_callback("glActiveTexture", (void*)glActiveTexture, 1, arg0);

+}

+PFNGLACTIVETEXTUREPROC glad_debug_glActiveTexture = glad_debug_impl_glActiveTexture;

+PFNGLATTACHSHADERPROC glad_glAttachShader;

+void APIENTRY glad_debug_impl_glAttachShader(GLuint arg0, GLuint arg1) {

+    _pre_call_callback("glAttachShader", (void*)glAttachShader, 2, arg0, arg1);

+     glad_glAttachShader(arg0, arg1);

+    _post_call_callback("glAttachShader", (void*)glAttachShader, 2, arg0, arg1);

+}

+PFNGLATTACHSHADERPROC glad_debug_glAttachShader = glad_debug_impl_glAttachShader;

+PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;

+void APIENTRY glad_debug_impl_glBeginConditionalRender(GLuint arg0, GLenum arg1) {

+    _pre_call_callback("glBeginConditionalRender", (void*)glBeginConditionalRender, 2, arg0, arg1);

+     glad_glBeginConditionalRender(arg0, arg1);

+    _post_call_callback("glBeginConditionalRender", (void*)glBeginConditionalRender, 2, arg0, arg1);

+}

+PFNGLBEGINCONDITIONALRENDERPROC glad_debug_glBeginConditionalRender = glad_debug_impl_glBeginConditionalRender;

+PFNGLBEGINQUERYPROC glad_glBeginQuery;

+void APIENTRY glad_debug_impl_glBeginQuery(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glBeginQuery", (void*)glBeginQuery, 2, arg0, arg1);

+     glad_glBeginQuery(arg0, arg1);

+    _post_call_callback("glBeginQuery", (void*)glBeginQuery, 2, arg0, arg1);

+}

+PFNGLBEGINQUERYPROC glad_debug_glBeginQuery = glad_debug_impl_glBeginQuery;

+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;

+void APIENTRY glad_debug_impl_glBeginTransformFeedback(GLenum arg0) {

+    _pre_call_callback("glBeginTransformFeedback", (void*)glBeginTransformFeedback, 1, arg0);

+     glad_glBeginTransformFeedback(arg0);

+    _post_call_callback("glBeginTransformFeedback", (void*)glBeginTransformFeedback, 1, arg0);

+}

+PFNGLBEGINTRANSFORMFEEDBACKPROC glad_debug_glBeginTransformFeedback = glad_debug_impl_glBeginTransformFeedback;

+PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;

+void APIENTRY glad_debug_impl_glBindAttribLocation(GLuint arg0, GLuint arg1, const GLchar * arg2) {

+    _pre_call_callback("glBindAttribLocation", (void*)glBindAttribLocation, 3, arg0, arg1, arg2);

+     glad_glBindAttribLocation(arg0, arg1, arg2);

+    _post_call_callback("glBindAttribLocation", (void*)glBindAttribLocation, 3, arg0, arg1, arg2);

+}

+PFNGLBINDATTRIBLOCATIONPROC glad_debug_glBindAttribLocation = glad_debug_impl_glBindAttribLocation;

+PFNGLBINDBUFFERPROC glad_glBindBuffer;

+void APIENTRY glad_debug_impl_glBindBuffer(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glBindBuffer", (void*)glBindBuffer, 2, arg0, arg1);

+     glad_glBindBuffer(arg0, arg1);

+    _post_call_callback("glBindBuffer", (void*)glBindBuffer, 2, arg0, arg1);

+}

+PFNGLBINDBUFFERPROC glad_debug_glBindBuffer = glad_debug_impl_glBindBuffer;

+PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;

+void APIENTRY glad_debug_impl_glBindBufferBase(GLenum arg0, GLuint arg1, GLuint arg2) {

+    _pre_call_callback("glBindBufferBase", (void*)glBindBufferBase, 3, arg0, arg1, arg2);

+     glad_glBindBufferBase(arg0, arg1, arg2);

+    _post_call_callback("glBindBufferBase", (void*)glBindBufferBase, 3, arg0, arg1, arg2);

+}

+PFNGLBINDBUFFERBASEPROC glad_debug_glBindBufferBase = glad_debug_impl_glBindBufferBase;

+PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;

+void APIENTRY glad_debug_impl_glBindBufferRange(GLenum arg0, GLuint arg1, GLuint arg2, GLintptr arg3, GLsizeiptr arg4) {

+    _pre_call_callback("glBindBufferRange", (void*)glBindBufferRange, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glBindBufferRange(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glBindBufferRange", (void*)glBindBufferRange, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLBINDBUFFERRANGEPROC glad_debug_glBindBufferRange = glad_debug_impl_glBindBufferRange;

+PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;

+void APIENTRY glad_debug_impl_glBindFragDataLocation(GLuint arg0, GLuint arg1, const GLchar * arg2) {

+    _pre_call_callback("glBindFragDataLocation", (void*)glBindFragDataLocation, 3, arg0, arg1, arg2);

+     glad_glBindFragDataLocation(arg0, arg1, arg2);

+    _post_call_callback("glBindFragDataLocation", (void*)glBindFragDataLocation, 3, arg0, arg1, arg2);

+}

+PFNGLBINDFRAGDATALOCATIONPROC glad_debug_glBindFragDataLocation = glad_debug_impl_glBindFragDataLocation;

+PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;

+void APIENTRY glad_debug_impl_glBindFramebuffer(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glBindFramebuffer", (void*)glBindFramebuffer, 2, arg0, arg1);

+     glad_glBindFramebuffer(arg0, arg1);

+    _post_call_callback("glBindFramebuffer", (void*)glBindFramebuffer, 2, arg0, arg1);

+}

+PFNGLBINDFRAMEBUFFERPROC glad_debug_glBindFramebuffer = glad_debug_impl_glBindFramebuffer;

+PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;

+void APIENTRY glad_debug_impl_glBindRenderbuffer(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glBindRenderbuffer", (void*)glBindRenderbuffer, 2, arg0, arg1);

+     glad_glBindRenderbuffer(arg0, arg1);

+    _post_call_callback("glBindRenderbuffer", (void*)glBindRenderbuffer, 2, arg0, arg1);

+}

+PFNGLBINDRENDERBUFFERPROC glad_debug_glBindRenderbuffer = glad_debug_impl_glBindRenderbuffer;

+PFNGLBINDTEXTUREPROC glad_glBindTexture;

+void APIENTRY glad_debug_impl_glBindTexture(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glBindTexture", (void*)glBindTexture, 2, arg0, arg1);

+     glad_glBindTexture(arg0, arg1);

+    _post_call_callback("glBindTexture", (void*)glBindTexture, 2, arg0, arg1);

+}

+PFNGLBINDTEXTUREPROC glad_debug_glBindTexture = glad_debug_impl_glBindTexture;

+PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;

+void APIENTRY glad_debug_impl_glBindVertexArray(GLuint arg0) {

+    _pre_call_callback("glBindVertexArray", (void*)glBindVertexArray, 1, arg0);

+     glad_glBindVertexArray(arg0);

+    _post_call_callback("glBindVertexArray", (void*)glBindVertexArray, 1, arg0);

+}

+PFNGLBINDVERTEXARRAYPROC glad_debug_glBindVertexArray = glad_debug_impl_glBindVertexArray;

+PFNGLBLENDCOLORPROC glad_glBlendColor;

+void APIENTRY glad_debug_impl_glBlendColor(GLfloat arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) {

+    _pre_call_callback("glBlendColor", (void*)glBlendColor, 4, arg0, arg1, arg2, arg3);

+     glad_glBlendColor(arg0, arg1, arg2, arg3);

+    _post_call_callback("glBlendColor", (void*)glBlendColor, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLBLENDCOLORPROC glad_debug_glBlendColor = glad_debug_impl_glBlendColor;

+PFNGLBLENDEQUATIONPROC glad_glBlendEquation;

+void APIENTRY glad_debug_impl_glBlendEquation(GLenum arg0) {

+    _pre_call_callback("glBlendEquation", (void*)glBlendEquation, 1, arg0);

+     glad_glBlendEquation(arg0);

+    _post_call_callback("glBlendEquation", (void*)glBlendEquation, 1, arg0);

+}

+PFNGLBLENDEQUATIONPROC glad_debug_glBlendEquation = glad_debug_impl_glBlendEquation;

+PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;

+void APIENTRY glad_debug_impl_glBlendEquationSeparate(GLenum arg0, GLenum arg1) {

+    _pre_call_callback("glBlendEquationSeparate", (void*)glBlendEquationSeparate, 2, arg0, arg1);

+     glad_glBlendEquationSeparate(arg0, arg1);

+    _post_call_callback("glBlendEquationSeparate", (void*)glBlendEquationSeparate, 2, arg0, arg1);

+}

+PFNGLBLENDEQUATIONSEPARATEPROC glad_debug_glBlendEquationSeparate = glad_debug_impl_glBlendEquationSeparate;

+PFNGLBLENDFUNCPROC glad_glBlendFunc;

+void APIENTRY glad_debug_impl_glBlendFunc(GLenum arg0, GLenum arg1) {

+    _pre_call_callback("glBlendFunc", (void*)glBlendFunc, 2, arg0, arg1);

+     glad_glBlendFunc(arg0, arg1);

+    _post_call_callback("glBlendFunc", (void*)glBlendFunc, 2, arg0, arg1);

+}

+PFNGLBLENDFUNCPROC glad_debug_glBlendFunc = glad_debug_impl_glBlendFunc;

+PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;

+void APIENTRY glad_debug_impl_glBlendFuncSeparate(GLenum arg0, GLenum arg1, GLenum arg2, GLenum arg3) {

+    _pre_call_callback("glBlendFuncSeparate", (void*)glBlendFuncSeparate, 4, arg0, arg1, arg2, arg3);

+     glad_glBlendFuncSeparate(arg0, arg1, arg2, arg3);

+    _post_call_callback("glBlendFuncSeparate", (void*)glBlendFuncSeparate, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLBLENDFUNCSEPARATEPROC glad_debug_glBlendFuncSeparate = glad_debug_impl_glBlendFuncSeparate;

+PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;

+void APIENTRY glad_debug_impl_glBlitFramebuffer(GLint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLint arg6, GLint arg7, GLbitfield arg8, GLenum arg9) {

+    _pre_call_callback("glBlitFramebuffer", (void*)glBlitFramebuffer, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+     glad_glBlitFramebuffer(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+    _post_call_callback("glBlitFramebuffer", (void*)glBlitFramebuffer, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+}

+PFNGLBLITFRAMEBUFFERPROC glad_debug_glBlitFramebuffer = glad_debug_impl_glBlitFramebuffer;

+PFNGLBUFFERDATAPROC glad_glBufferData;

+void APIENTRY glad_debug_impl_glBufferData(GLenum arg0, GLsizeiptr arg1, const void * arg2, GLenum arg3) {

+    _pre_call_callback("glBufferData", (void*)glBufferData, 4, arg0, arg1, arg2, arg3);

+     glad_glBufferData(arg0, arg1, arg2, arg3);

+    _post_call_callback("glBufferData", (void*)glBufferData, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLBUFFERDATAPROC glad_debug_glBufferData = glad_debug_impl_glBufferData;

+PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;

+void APIENTRY glad_debug_impl_glBufferSubData(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, const void * arg3) {

+    _pre_call_callback("glBufferSubData", (void*)glBufferSubData, 4, arg0, arg1, arg2, arg3);

+     glad_glBufferSubData(arg0, arg1, arg2, arg3);

+    _post_call_callback("glBufferSubData", (void*)glBufferSubData, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLBUFFERSUBDATAPROC glad_debug_glBufferSubData = glad_debug_impl_glBufferSubData;

+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;

+GLenum APIENTRY glad_debug_impl_glCheckFramebufferStatus(GLenum arg0) {

+    GLenum ret;

+    _pre_call_callback("glCheckFramebufferStatus", (void*)glCheckFramebufferStatus, 1, arg0);

+    ret =  glad_glCheckFramebufferStatus(arg0);

+    _post_call_callback("glCheckFramebufferStatus", (void*)glCheckFramebufferStatus, 1, arg0);

+    return ret;

+}

+PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_debug_glCheckFramebufferStatus = glad_debug_impl_glCheckFramebufferStatus;

+PFNGLCLAMPCOLORPROC glad_glClampColor;

+void APIENTRY glad_debug_impl_glClampColor(GLenum arg0, GLenum arg1) {

+    _pre_call_callback("glClampColor", (void*)glClampColor, 2, arg0, arg1);

+     glad_glClampColor(arg0, arg1);

+    _post_call_callback("glClampColor", (void*)glClampColor, 2, arg0, arg1);

+}

+PFNGLCLAMPCOLORPROC glad_debug_glClampColor = glad_debug_impl_glClampColor;

+PFNGLCLEARPROC glad_glClear;

+void APIENTRY glad_debug_impl_glClear(GLbitfield arg0) {

+    _pre_call_callback("glClear", (void*)glClear, 1, arg0);

+     glad_glClear(arg0);

+    _post_call_callback("glClear", (void*)glClear, 1, arg0);

+}

+PFNGLCLEARPROC glad_debug_glClear = glad_debug_impl_glClear;

+PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;

+void APIENTRY glad_debug_impl_glClearBufferfi(GLenum arg0, GLint arg1, GLfloat arg2, GLint arg3) {

+    _pre_call_callback("glClearBufferfi", (void*)glClearBufferfi, 4, arg0, arg1, arg2, arg3);

+     glad_glClearBufferfi(arg0, arg1, arg2, arg3);

+    _post_call_callback("glClearBufferfi", (void*)glClearBufferfi, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLCLEARBUFFERFIPROC glad_debug_glClearBufferfi = glad_debug_impl_glClearBufferfi;

+PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;

+void APIENTRY glad_debug_impl_glClearBufferfv(GLenum arg0, GLint arg1, const GLfloat * arg2) {

+    _pre_call_callback("glClearBufferfv", (void*)glClearBufferfv, 3, arg0, arg1, arg2);

+     glad_glClearBufferfv(arg0, arg1, arg2);

+    _post_call_callback("glClearBufferfv", (void*)glClearBufferfv, 3, arg0, arg1, arg2);

+}

+PFNGLCLEARBUFFERFVPROC glad_debug_glClearBufferfv = glad_debug_impl_glClearBufferfv;

+PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;

+void APIENTRY glad_debug_impl_glClearBufferiv(GLenum arg0, GLint arg1, const GLint * arg2) {

+    _pre_call_callback("glClearBufferiv", (void*)glClearBufferiv, 3, arg0, arg1, arg2);

+     glad_glClearBufferiv(arg0, arg1, arg2);

+    _post_call_callback("glClearBufferiv", (void*)glClearBufferiv, 3, arg0, arg1, arg2);

+}

+PFNGLCLEARBUFFERIVPROC glad_debug_glClearBufferiv = glad_debug_impl_glClearBufferiv;

+PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;

+void APIENTRY glad_debug_impl_glClearBufferuiv(GLenum arg0, GLint arg1, const GLuint * arg2) {

+    _pre_call_callback("glClearBufferuiv", (void*)glClearBufferuiv, 3, arg0, arg1, arg2);

+     glad_glClearBufferuiv(arg0, arg1, arg2);

+    _post_call_callback("glClearBufferuiv", (void*)glClearBufferuiv, 3, arg0, arg1, arg2);

+}

+PFNGLCLEARBUFFERUIVPROC glad_debug_glClearBufferuiv = glad_debug_impl_glClearBufferuiv;

+PFNGLCLEARCOLORPROC glad_glClearColor;

+void APIENTRY glad_debug_impl_glClearColor(GLfloat arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) {

+    _pre_call_callback("glClearColor", (void*)glClearColor, 4, arg0, arg1, arg2, arg3);

+     glad_glClearColor(arg0, arg1, arg2, arg3);

+    _post_call_callback("glClearColor", (void*)glClearColor, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLCLEARCOLORPROC glad_debug_glClearColor = glad_debug_impl_glClearColor;

+PFNGLCLEARDEPTHPROC glad_glClearDepth;

+void APIENTRY glad_debug_impl_glClearDepth(GLdouble arg0) {

+    _pre_call_callback("glClearDepth", (void*)glClearDepth, 1, arg0);

+     glad_glClearDepth(arg0);

+    _post_call_callback("glClearDepth", (void*)glClearDepth, 1, arg0);

+}

+PFNGLCLEARDEPTHPROC glad_debug_glClearDepth = glad_debug_impl_glClearDepth;

+PFNGLCLEARSTENCILPROC glad_glClearStencil;

+void APIENTRY glad_debug_impl_glClearStencil(GLint arg0) {

+    _pre_call_callback("glClearStencil", (void*)glClearStencil, 1, arg0);

+     glad_glClearStencil(arg0);

+    _post_call_callback("glClearStencil", (void*)glClearStencil, 1, arg0);

+}

+PFNGLCLEARSTENCILPROC glad_debug_glClearStencil = glad_debug_impl_glClearStencil;

+PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;

+GLenum APIENTRY glad_debug_impl_glClientWaitSync(GLsync arg0, GLbitfield arg1, GLuint64 arg2) {

+    GLenum ret;

+    _pre_call_callback("glClientWaitSync", (void*)glClientWaitSync, 3, arg0, arg1, arg2);

+    ret =  glad_glClientWaitSync(arg0, arg1, arg2);

+    _post_call_callback("glClientWaitSync", (void*)glClientWaitSync, 3, arg0, arg1, arg2);

+    return ret;

+}

+PFNGLCLIENTWAITSYNCPROC glad_debug_glClientWaitSync = glad_debug_impl_glClientWaitSync;

+PFNGLCOLORMASKPROC glad_glColorMask;

+void APIENTRY glad_debug_impl_glColorMask(GLboolean arg0, GLboolean arg1, GLboolean arg2, GLboolean arg3) {

+    _pre_call_callback("glColorMask", (void*)glColorMask, 4, arg0, arg1, arg2, arg3);

+     glad_glColorMask(arg0, arg1, arg2, arg3);

+    _post_call_callback("glColorMask", (void*)glColorMask, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLCOLORMASKPROC glad_debug_glColorMask = glad_debug_impl_glColorMask;

+PFNGLCOLORMASKIPROC glad_glColorMaski;

+void APIENTRY glad_debug_impl_glColorMaski(GLuint arg0, GLboolean arg1, GLboolean arg2, GLboolean arg3, GLboolean arg4) {

+    _pre_call_callback("glColorMaski", (void*)glColorMaski, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glColorMaski(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glColorMaski", (void*)glColorMaski, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLCOLORMASKIPROC glad_debug_glColorMaski = glad_debug_impl_glColorMaski;

+PFNGLCOMPILESHADERPROC glad_glCompileShader;

+void APIENTRY glad_debug_impl_glCompileShader(GLuint arg0) {

+    _pre_call_callback("glCompileShader", (void*)glCompileShader, 1, arg0);

+     glad_glCompileShader(arg0);

+    _post_call_callback("glCompileShader", (void*)glCompileShader, 1, arg0);

+}

+PFNGLCOMPILESHADERPROC glad_debug_glCompileShader = glad_debug_impl_glCompileShader;

+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;

+void APIENTRY glad_debug_impl_glCompressedTexImage1D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLint arg4, GLsizei arg5, const void * arg6) {

+    _pre_call_callback("glCompressedTexImage1D", (void*)glCompressedTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glCompressedTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glCompressedTexImage1D", (void*)glCompressedTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_debug_glCompressedTexImage1D = glad_debug_impl_glCompressedTexImage1D;

+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;

+void APIENTRY glad_debug_impl_glCompressedTexImage2D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLsizei arg6, const void * arg7) {

+    _pre_call_callback("glCompressedTexImage2D", (void*)glCompressedTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+     glad_glCompressedTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+    _post_call_callback("glCompressedTexImage2D", (void*)glCompressedTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+}

+PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_debug_glCompressedTexImage2D = glad_debug_impl_glCompressedTexImage2D;

+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;

+void APIENTRY glad_debug_impl_glCompressedTexImage3D(GLenum arg0, GLint arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLint arg6, GLsizei arg7, const void * arg8) {

+    _pre_call_callback("glCompressedTexImage3D", (void*)glCompressedTexImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+     glad_glCompressedTexImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+    _post_call_callback("glCompressedTexImage3D", (void*)glCompressedTexImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+}

+PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_debug_glCompressedTexImage3D = glad_debug_impl_glCompressedTexImage3D;

+PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;

+void APIENTRY glad_debug_impl_glCompressedTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLenum arg4, GLsizei arg5, const void * arg6) {

+    _pre_call_callback("glCompressedTexSubImage1D", (void*)glCompressedTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glCompressedTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glCompressedTexSubImage1D", (void*)glCompressedTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_debug_glCompressedTexSubImage1D = glad_debug_impl_glCompressedTexSubImage1D;

+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;

+void APIENTRY glad_debug_impl_glCompressedTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLsizei arg4, GLsizei arg5, GLenum arg6, GLsizei arg7, const void * arg8) {

+    _pre_call_callback("glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+     glad_glCompressedTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+    _post_call_callback("glCompressedTexSubImage2D", (void*)glCompressedTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+}

+PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_debug_glCompressedTexSubImage2D = glad_debug_impl_glCompressedTexSubImage2D;

+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;

+void APIENTRY glad_debug_impl_glCompressedTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLsizei arg7, GLenum arg8, GLsizei arg9, const void * arg10) {

+    _pre_call_callback("glCompressedTexSubImage3D", (void*)glCompressedTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+     glad_glCompressedTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+    _post_call_callback("glCompressedTexSubImage3D", (void*)glCompressedTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+}

+PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_debug_glCompressedTexSubImage3D = glad_debug_impl_glCompressedTexSubImage3D;

+PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;

+void APIENTRY glad_debug_impl_glCopyBufferSubData(GLenum arg0, GLenum arg1, GLintptr arg2, GLintptr arg3, GLsizeiptr arg4) {

+    _pre_call_callback("glCopyBufferSubData", (void*)glCopyBufferSubData, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glCopyBufferSubData(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glCopyBufferSubData", (void*)glCopyBufferSubData, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLCOPYBUFFERSUBDATAPROC glad_debug_glCopyBufferSubData = glad_debug_impl_glCopyBufferSubData;

+PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;

+void APIENTRY glad_debug_impl_glCopyTexImage1D(GLenum arg0, GLint arg1, GLenum arg2, GLint arg3, GLint arg4, GLsizei arg5, GLint arg6) {

+    _pre_call_callback("glCopyTexImage1D", (void*)glCopyTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glCopyTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glCopyTexImage1D", (void*)glCopyTexImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLCOPYTEXIMAGE1DPROC glad_debug_glCopyTexImage1D = glad_debug_impl_glCopyTexImage1D;

+PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;

+void APIENTRY glad_debug_impl_glCopyTexImage2D(GLenum arg0, GLint arg1, GLenum arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLint arg7) {

+    _pre_call_callback("glCopyTexImage2D", (void*)glCopyTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+     glad_glCopyTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+    _post_call_callback("glCopyTexImage2D", (void*)glCopyTexImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+}

+PFNGLCOPYTEXIMAGE2DPROC glad_debug_glCopyTexImage2D = glad_debug_impl_glCopyTexImage2D;

+PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;

+void APIENTRY glad_debug_impl_glCopyTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5) {

+    _pre_call_callback("glCopyTexSubImage1D", (void*)glCopyTexSubImage1D, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glCopyTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glCopyTexSubImage1D", (void*)glCopyTexSubImage1D, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLCOPYTEXSUBIMAGE1DPROC glad_debug_glCopyTexSubImage1D = glad_debug_impl_glCopyTexSubImage1D;

+PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;

+void APIENTRY glad_debug_impl_glCopyTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLsizei arg6, GLsizei arg7) {

+    _pre_call_callback("glCopyTexSubImage2D", (void*)glCopyTexSubImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+     glad_glCopyTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+    _post_call_callback("glCopyTexSubImage2D", (void*)glCopyTexSubImage2D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+}

+PFNGLCOPYTEXSUBIMAGE2DPROC glad_debug_glCopyTexSubImage2D = glad_debug_impl_glCopyTexSubImage2D;

+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;

+void APIENTRY glad_debug_impl_glCopyTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLint arg5, GLint arg6, GLsizei arg7, GLsizei arg8) {

+    _pre_call_callback("glCopyTexSubImage3D", (void*)glCopyTexSubImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+     glad_glCopyTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+    _post_call_callback("glCopyTexSubImage3D", (void*)glCopyTexSubImage3D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+}

+PFNGLCOPYTEXSUBIMAGE3DPROC glad_debug_glCopyTexSubImage3D = glad_debug_impl_glCopyTexSubImage3D;

+PFNGLCREATEPROGRAMPROC glad_glCreateProgram;

+GLuint APIENTRY glad_debug_impl_glCreateProgram(void) {

+    GLuint ret;

+    _pre_call_callback("glCreateProgram", (void*)glCreateProgram, 0);

+    ret =  glad_glCreateProgram();

+    _post_call_callback("glCreateProgram", (void*)glCreateProgram, 0);

+    return ret;

+}

+PFNGLCREATEPROGRAMPROC glad_debug_glCreateProgram = glad_debug_impl_glCreateProgram;

+PFNGLCREATESHADERPROC glad_glCreateShader;

+GLuint APIENTRY glad_debug_impl_glCreateShader(GLenum arg0) {

+    GLuint ret;

+    _pre_call_callback("glCreateShader", (void*)glCreateShader, 1, arg0);

+    ret =  glad_glCreateShader(arg0);

+    _post_call_callback("glCreateShader", (void*)glCreateShader, 1, arg0);

+    return ret;

+}

+PFNGLCREATESHADERPROC glad_debug_glCreateShader = glad_debug_impl_glCreateShader;

+PFNGLCULLFACEPROC glad_glCullFace;

+void APIENTRY glad_debug_impl_glCullFace(GLenum arg0) {

+    _pre_call_callback("glCullFace", (void*)glCullFace, 1, arg0);

+     glad_glCullFace(arg0);

+    _post_call_callback("glCullFace", (void*)glCullFace, 1, arg0);

+}

+PFNGLCULLFACEPROC glad_debug_glCullFace = glad_debug_impl_glCullFace;

+PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;

+void APIENTRY glad_debug_impl_glDeleteBuffers(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteBuffers", (void*)glDeleteBuffers, 2, arg0, arg1);

+     glad_glDeleteBuffers(arg0, arg1);

+    _post_call_callback("glDeleteBuffers", (void*)glDeleteBuffers, 2, arg0, arg1);

+}

+PFNGLDELETEBUFFERSPROC glad_debug_glDeleteBuffers = glad_debug_impl_glDeleteBuffers;

+PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;

+void APIENTRY glad_debug_impl_glDeleteFramebuffers(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteFramebuffers", (void*)glDeleteFramebuffers, 2, arg0, arg1);

+     glad_glDeleteFramebuffers(arg0, arg1);

+    _post_call_callback("glDeleteFramebuffers", (void*)glDeleteFramebuffers, 2, arg0, arg1);

+}

+PFNGLDELETEFRAMEBUFFERSPROC glad_debug_glDeleteFramebuffers = glad_debug_impl_glDeleteFramebuffers;

+PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;

+void APIENTRY glad_debug_impl_glDeleteProgram(GLuint arg0) {

+    _pre_call_callback("glDeleteProgram", (void*)glDeleteProgram, 1, arg0);

+     glad_glDeleteProgram(arg0);

+    _post_call_callback("glDeleteProgram", (void*)glDeleteProgram, 1, arg0);

+}

+PFNGLDELETEPROGRAMPROC glad_debug_glDeleteProgram = glad_debug_impl_glDeleteProgram;

+PFNGLDELETEQUERIESPROC glad_glDeleteQueries;

+void APIENTRY glad_debug_impl_glDeleteQueries(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteQueries", (void*)glDeleteQueries, 2, arg0, arg1);

+     glad_glDeleteQueries(arg0, arg1);

+    _post_call_callback("glDeleteQueries", (void*)glDeleteQueries, 2, arg0, arg1);

+}

+PFNGLDELETEQUERIESPROC glad_debug_glDeleteQueries = glad_debug_impl_glDeleteQueries;

+PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;

+void APIENTRY glad_debug_impl_glDeleteRenderbuffers(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteRenderbuffers", (void*)glDeleteRenderbuffers, 2, arg0, arg1);

+     glad_glDeleteRenderbuffers(arg0, arg1);

+    _post_call_callback("glDeleteRenderbuffers", (void*)glDeleteRenderbuffers, 2, arg0, arg1);

+}

+PFNGLDELETERENDERBUFFERSPROC glad_debug_glDeleteRenderbuffers = glad_debug_impl_glDeleteRenderbuffers;

+PFNGLDELETESHADERPROC glad_glDeleteShader;

+void APIENTRY glad_debug_impl_glDeleteShader(GLuint arg0) {

+    _pre_call_callback("glDeleteShader", (void*)glDeleteShader, 1, arg0);

+     glad_glDeleteShader(arg0);

+    _post_call_callback("glDeleteShader", (void*)glDeleteShader, 1, arg0);

+}

+PFNGLDELETESHADERPROC glad_debug_glDeleteShader = glad_debug_impl_glDeleteShader;

+PFNGLDELETESYNCPROC glad_glDeleteSync;

+void APIENTRY glad_debug_impl_glDeleteSync(GLsync arg0) {

+    _pre_call_callback("glDeleteSync", (void*)glDeleteSync, 1, arg0);

+     glad_glDeleteSync(arg0);

+    _post_call_callback("glDeleteSync", (void*)glDeleteSync, 1, arg0);

+}

+PFNGLDELETESYNCPROC glad_debug_glDeleteSync = glad_debug_impl_glDeleteSync;

+PFNGLDELETETEXTURESPROC glad_glDeleteTextures;

+void APIENTRY glad_debug_impl_glDeleteTextures(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteTextures", (void*)glDeleteTextures, 2, arg0, arg1);

+     glad_glDeleteTextures(arg0, arg1);

+    _post_call_callback("glDeleteTextures", (void*)glDeleteTextures, 2, arg0, arg1);

+}

+PFNGLDELETETEXTURESPROC glad_debug_glDeleteTextures = glad_debug_impl_glDeleteTextures;

+PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;

+void APIENTRY glad_debug_impl_glDeleteVertexArrays(GLsizei arg0, const GLuint * arg1) {

+    _pre_call_callback("glDeleteVertexArrays", (void*)glDeleteVertexArrays, 2, arg0, arg1);

+     glad_glDeleteVertexArrays(arg0, arg1);

+    _post_call_callback("glDeleteVertexArrays", (void*)glDeleteVertexArrays, 2, arg0, arg1);

+}

+PFNGLDELETEVERTEXARRAYSPROC glad_debug_glDeleteVertexArrays = glad_debug_impl_glDeleteVertexArrays;

+PFNGLDEPTHFUNCPROC glad_glDepthFunc;

+void APIENTRY glad_debug_impl_glDepthFunc(GLenum arg0) {

+    _pre_call_callback("glDepthFunc", (void*)glDepthFunc, 1, arg0);

+     glad_glDepthFunc(arg0);

+    _post_call_callback("glDepthFunc", (void*)glDepthFunc, 1, arg0);

+}

+PFNGLDEPTHFUNCPROC glad_debug_glDepthFunc = glad_debug_impl_glDepthFunc;

+PFNGLDEPTHMASKPROC glad_glDepthMask;

+void APIENTRY glad_debug_impl_glDepthMask(GLboolean arg0) {

+    _pre_call_callback("glDepthMask", (void*)glDepthMask, 1, arg0);

+     glad_glDepthMask(arg0);

+    _post_call_callback("glDepthMask", (void*)glDepthMask, 1, arg0);

+}

+PFNGLDEPTHMASKPROC glad_debug_glDepthMask = glad_debug_impl_glDepthMask;

+PFNGLDEPTHRANGEPROC glad_glDepthRange;

+void APIENTRY glad_debug_impl_glDepthRange(GLdouble arg0, GLdouble arg1) {

+    _pre_call_callback("glDepthRange", (void*)glDepthRange, 2, arg0, arg1);

+     glad_glDepthRange(arg0, arg1);

+    _post_call_callback("glDepthRange", (void*)glDepthRange, 2, arg0, arg1);

+}

+PFNGLDEPTHRANGEPROC glad_debug_glDepthRange = glad_debug_impl_glDepthRange;

+PFNGLDETACHSHADERPROC glad_glDetachShader;

+void APIENTRY glad_debug_impl_glDetachShader(GLuint arg0, GLuint arg1) {

+    _pre_call_callback("glDetachShader", (void*)glDetachShader, 2, arg0, arg1);

+     glad_glDetachShader(arg0, arg1);

+    _post_call_callback("glDetachShader", (void*)glDetachShader, 2, arg0, arg1);

+}

+PFNGLDETACHSHADERPROC glad_debug_glDetachShader = glad_debug_impl_glDetachShader;

+PFNGLDISABLEPROC glad_glDisable;

+void APIENTRY glad_debug_impl_glDisable(GLenum arg0) {

+    _pre_call_callback("glDisable", (void*)glDisable, 1, arg0);

+     glad_glDisable(arg0);

+    _post_call_callback("glDisable", (void*)glDisable, 1, arg0);

+}

+PFNGLDISABLEPROC glad_debug_glDisable = glad_debug_impl_glDisable;

+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;

+void APIENTRY glad_debug_impl_glDisableVertexAttribArray(GLuint arg0) {

+    _pre_call_callback("glDisableVertexAttribArray", (void*)glDisableVertexAttribArray, 1, arg0);

+     glad_glDisableVertexAttribArray(arg0);

+    _post_call_callback("glDisableVertexAttribArray", (void*)glDisableVertexAttribArray, 1, arg0);

+}

+PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_debug_glDisableVertexAttribArray = glad_debug_impl_glDisableVertexAttribArray;

+PFNGLDISABLEIPROC glad_glDisablei;

+void APIENTRY glad_debug_impl_glDisablei(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glDisablei", (void*)glDisablei, 2, arg0, arg1);

+     glad_glDisablei(arg0, arg1);

+    _post_call_callback("glDisablei", (void*)glDisablei, 2, arg0, arg1);

+}

+PFNGLDISABLEIPROC glad_debug_glDisablei = glad_debug_impl_glDisablei;

+PFNGLDRAWARRAYSPROC glad_glDrawArrays;

+void APIENTRY glad_debug_impl_glDrawArrays(GLenum arg0, GLint arg1, GLsizei arg2) {

+    _pre_call_callback("glDrawArrays", (void*)glDrawArrays, 3, arg0, arg1, arg2);

+     glad_glDrawArrays(arg0, arg1, arg2);

+    _post_call_callback("glDrawArrays", (void*)glDrawArrays, 3, arg0, arg1, arg2);

+}

+PFNGLDRAWARRAYSPROC glad_debug_glDrawArrays = glad_debug_impl_glDrawArrays;

+PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;

+void APIENTRY glad_debug_impl_glDrawArraysInstanced(GLenum arg0, GLint arg1, GLsizei arg2, GLsizei arg3) {

+    _pre_call_callback("glDrawArraysInstanced", (void*)glDrawArraysInstanced, 4, arg0, arg1, arg2, arg3);

+     glad_glDrawArraysInstanced(arg0, arg1, arg2, arg3);

+    _post_call_callback("glDrawArraysInstanced", (void*)glDrawArraysInstanced, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLDRAWARRAYSINSTANCEDPROC glad_debug_glDrawArraysInstanced = glad_debug_impl_glDrawArraysInstanced;

+PFNGLDRAWBUFFERPROC glad_glDrawBuffer;

+void APIENTRY glad_debug_impl_glDrawBuffer(GLenum arg0) {

+    _pre_call_callback("glDrawBuffer", (void*)glDrawBuffer, 1, arg0);

+     glad_glDrawBuffer(arg0);

+    _post_call_callback("glDrawBuffer", (void*)glDrawBuffer, 1, arg0);

+}

+PFNGLDRAWBUFFERPROC glad_debug_glDrawBuffer = glad_debug_impl_glDrawBuffer;

+PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;

+void APIENTRY glad_debug_impl_glDrawBuffers(GLsizei arg0, const GLenum * arg1) {

+    _pre_call_callback("glDrawBuffers", (void*)glDrawBuffers, 2, arg0, arg1);

+     glad_glDrawBuffers(arg0, arg1);

+    _post_call_callback("glDrawBuffers", (void*)glDrawBuffers, 2, arg0, arg1);

+}

+PFNGLDRAWBUFFERSPROC glad_debug_glDrawBuffers = glad_debug_impl_glDrawBuffers;

+PFNGLDRAWELEMENTSPROC glad_glDrawElements;

+void APIENTRY glad_debug_impl_glDrawElements(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3) {

+    _pre_call_callback("glDrawElements", (void*)glDrawElements, 4, arg0, arg1, arg2, arg3);

+     glad_glDrawElements(arg0, arg1, arg2, arg3);

+    _post_call_callback("glDrawElements", (void*)glDrawElements, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLDRAWELEMENTSPROC glad_debug_glDrawElements = glad_debug_impl_glDrawElements;

+PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;

+void APIENTRY glad_debug_impl_glDrawElementsBaseVertex(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLint arg4) {

+    _pre_call_callback("glDrawElementsBaseVertex", (void*)glDrawElementsBaseVertex, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glDrawElementsBaseVertex(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glDrawElementsBaseVertex", (void*)glDrawElementsBaseVertex, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLDRAWELEMENTSBASEVERTEXPROC glad_debug_glDrawElementsBaseVertex = glad_debug_impl_glDrawElementsBaseVertex;

+PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;

+void APIENTRY glad_debug_impl_glDrawElementsInstanced(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLsizei arg4) {

+    _pre_call_callback("glDrawElementsInstanced", (void*)glDrawElementsInstanced, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glDrawElementsInstanced(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glDrawElementsInstanced", (void*)glDrawElementsInstanced, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLDRAWELEMENTSINSTANCEDPROC glad_debug_glDrawElementsInstanced = glad_debug_impl_glDrawElementsInstanced;

+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;

+void APIENTRY glad_debug_impl_glDrawElementsInstancedBaseVertex(GLenum arg0, GLsizei arg1, GLenum arg2, const void * arg3, GLsizei arg4, GLint arg5) {

+    _pre_call_callback("glDrawElementsInstancedBaseVertex", (void*)glDrawElementsInstancedBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glDrawElementsInstancedBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glDrawElementsInstancedBaseVertex", (void*)glDrawElementsInstancedBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_debug_glDrawElementsInstancedBaseVertex = glad_debug_impl_glDrawElementsInstancedBaseVertex;

+PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;

+void APIENTRY glad_debug_impl_glDrawRangeElements(GLenum arg0, GLuint arg1, GLuint arg2, GLsizei arg3, GLenum arg4, const void * arg5) {

+    _pre_call_callback("glDrawRangeElements", (void*)glDrawRangeElements, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glDrawRangeElements(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glDrawRangeElements", (void*)glDrawRangeElements, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLDRAWRANGEELEMENTSPROC glad_debug_glDrawRangeElements = glad_debug_impl_glDrawRangeElements;

+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;

+void APIENTRY glad_debug_impl_glDrawRangeElementsBaseVertex(GLenum arg0, GLuint arg1, GLuint arg2, GLsizei arg3, GLenum arg4, const void * arg5, GLint arg6) {

+    _pre_call_callback("glDrawRangeElementsBaseVertex", (void*)glDrawRangeElementsBaseVertex, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glDrawRangeElementsBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glDrawRangeElementsBaseVertex", (void*)glDrawRangeElementsBaseVertex, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_debug_glDrawRangeElementsBaseVertex = glad_debug_impl_glDrawRangeElementsBaseVertex;

+PFNGLENABLEPROC glad_glEnable;

+void APIENTRY glad_debug_impl_glEnable(GLenum arg0) {

+    _pre_call_callback("glEnable", (void*)glEnable, 1, arg0);

+     glad_glEnable(arg0);

+    _post_call_callback("glEnable", (void*)glEnable, 1, arg0);

+}

+PFNGLENABLEPROC glad_debug_glEnable = glad_debug_impl_glEnable;

+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;

+void APIENTRY glad_debug_impl_glEnableVertexAttribArray(GLuint arg0) {

+    _pre_call_callback("glEnableVertexAttribArray", (void*)glEnableVertexAttribArray, 1, arg0);

+     glad_glEnableVertexAttribArray(arg0);

+    _post_call_callback("glEnableVertexAttribArray", (void*)glEnableVertexAttribArray, 1, arg0);

+}

+PFNGLENABLEVERTEXATTRIBARRAYPROC glad_debug_glEnableVertexAttribArray = glad_debug_impl_glEnableVertexAttribArray;

+PFNGLENABLEIPROC glad_glEnablei;

+void APIENTRY glad_debug_impl_glEnablei(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glEnablei", (void*)glEnablei, 2, arg0, arg1);

+     glad_glEnablei(arg0, arg1);

+    _post_call_callback("glEnablei", (void*)glEnablei, 2, arg0, arg1);

+}

+PFNGLENABLEIPROC glad_debug_glEnablei = glad_debug_impl_glEnablei;

+PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;

+void APIENTRY glad_debug_impl_glEndConditionalRender(void) {

+    _pre_call_callback("glEndConditionalRender", (void*)glEndConditionalRender, 0);

+     glad_glEndConditionalRender();

+    _post_call_callback("glEndConditionalRender", (void*)glEndConditionalRender, 0);

+}

+PFNGLENDCONDITIONALRENDERPROC glad_debug_glEndConditionalRender = glad_debug_impl_glEndConditionalRender;

+PFNGLENDQUERYPROC glad_glEndQuery;

+void APIENTRY glad_debug_impl_glEndQuery(GLenum arg0) {

+    _pre_call_callback("glEndQuery", (void*)glEndQuery, 1, arg0);

+     glad_glEndQuery(arg0);

+    _post_call_callback("glEndQuery", (void*)glEndQuery, 1, arg0);

+}

+PFNGLENDQUERYPROC glad_debug_glEndQuery = glad_debug_impl_glEndQuery;

+PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;

+void APIENTRY glad_debug_impl_glEndTransformFeedback(void) {

+    _pre_call_callback("glEndTransformFeedback", (void*)glEndTransformFeedback, 0);

+     glad_glEndTransformFeedback();

+    _post_call_callback("glEndTransformFeedback", (void*)glEndTransformFeedback, 0);

+}

+PFNGLENDTRANSFORMFEEDBACKPROC glad_debug_glEndTransformFeedback = glad_debug_impl_glEndTransformFeedback;

+PFNGLFENCESYNCPROC glad_glFenceSync;

+GLsync APIENTRY glad_debug_impl_glFenceSync(GLenum arg0, GLbitfield arg1) {

+    GLsync ret;

+    _pre_call_callback("glFenceSync", (void*)glFenceSync, 2, arg0, arg1);

+    ret =  glad_glFenceSync(arg0, arg1);

+    _post_call_callback("glFenceSync", (void*)glFenceSync, 2, arg0, arg1);

+    return ret;

+}

+PFNGLFENCESYNCPROC glad_debug_glFenceSync = glad_debug_impl_glFenceSync;

+PFNGLFINISHPROC glad_glFinish;

+void APIENTRY glad_debug_impl_glFinish(void) {

+    _pre_call_callback("glFinish", (void*)glFinish, 0);

+     glad_glFinish();

+    _post_call_callback("glFinish", (void*)glFinish, 0);

+}

+PFNGLFINISHPROC glad_debug_glFinish = glad_debug_impl_glFinish;

+PFNGLFLUSHPROC glad_glFlush;

+void APIENTRY glad_debug_impl_glFlush(void) {

+    _pre_call_callback("glFlush", (void*)glFlush, 0);

+     glad_glFlush();

+    _post_call_callback("glFlush", (void*)glFlush, 0);

+}

+PFNGLFLUSHPROC glad_debug_glFlush = glad_debug_impl_glFlush;

+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;

+void APIENTRY glad_debug_impl_glFlushMappedBufferRange(GLenum arg0, GLintptr arg1, GLsizeiptr arg2) {

+    _pre_call_callback("glFlushMappedBufferRange", (void*)glFlushMappedBufferRange, 3, arg0, arg1, arg2);

+     glad_glFlushMappedBufferRange(arg0, arg1, arg2);

+    _post_call_callback("glFlushMappedBufferRange", (void*)glFlushMappedBufferRange, 3, arg0, arg1, arg2);

+}

+PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_debug_glFlushMappedBufferRange = glad_debug_impl_glFlushMappedBufferRange;

+PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;

+void APIENTRY glad_debug_impl_glFramebufferRenderbuffer(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3) {

+    _pre_call_callback("glFramebufferRenderbuffer", (void*)glFramebufferRenderbuffer, 4, arg0, arg1, arg2, arg3);

+     glad_glFramebufferRenderbuffer(arg0, arg1, arg2, arg3);

+    _post_call_callback("glFramebufferRenderbuffer", (void*)glFramebufferRenderbuffer, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_debug_glFramebufferRenderbuffer = glad_debug_impl_glFramebufferRenderbuffer;

+PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;

+void APIENTRY glad_debug_impl_glFramebufferTexture(GLenum arg0, GLenum arg1, GLuint arg2, GLint arg3) {

+    _pre_call_callback("glFramebufferTexture", (void*)glFramebufferTexture, 4, arg0, arg1, arg2, arg3);

+     glad_glFramebufferTexture(arg0, arg1, arg2, arg3);

+    _post_call_callback("glFramebufferTexture", (void*)glFramebufferTexture, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLFRAMEBUFFERTEXTUREPROC glad_debug_glFramebufferTexture = glad_debug_impl_glFramebufferTexture;

+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;

+void APIENTRY glad_debug_impl_glFramebufferTexture1D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4) {

+    _pre_call_callback("glFramebufferTexture1D", (void*)glFramebufferTexture1D, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glFramebufferTexture1D(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glFramebufferTexture1D", (void*)glFramebufferTexture1D, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLFRAMEBUFFERTEXTURE1DPROC glad_debug_glFramebufferTexture1D = glad_debug_impl_glFramebufferTexture1D;

+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;

+void APIENTRY glad_debug_impl_glFramebufferTexture2D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4) {

+    _pre_call_callback("glFramebufferTexture2D", (void*)glFramebufferTexture2D, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glFramebufferTexture2D(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glFramebufferTexture2D", (void*)glFramebufferTexture2D, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLFRAMEBUFFERTEXTURE2DPROC glad_debug_glFramebufferTexture2D = glad_debug_impl_glFramebufferTexture2D;

+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;

+void APIENTRY glad_debug_impl_glFramebufferTexture3D(GLenum arg0, GLenum arg1, GLenum arg2, GLuint arg3, GLint arg4, GLint arg5) {

+    _pre_call_callback("glFramebufferTexture3D", (void*)glFramebufferTexture3D, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glFramebufferTexture3D(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glFramebufferTexture3D", (void*)glFramebufferTexture3D, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLFRAMEBUFFERTEXTURE3DPROC glad_debug_glFramebufferTexture3D = glad_debug_impl_glFramebufferTexture3D;

+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;

+void APIENTRY glad_debug_impl_glFramebufferTextureLayer(GLenum arg0, GLenum arg1, GLuint arg2, GLint arg3, GLint arg4) {

+    _pre_call_callback("glFramebufferTextureLayer", (void*)glFramebufferTextureLayer, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glFramebufferTextureLayer(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glFramebufferTextureLayer", (void*)glFramebufferTextureLayer, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_debug_glFramebufferTextureLayer = glad_debug_impl_glFramebufferTextureLayer;

+PFNGLFRONTFACEPROC glad_glFrontFace;

+void APIENTRY glad_debug_impl_glFrontFace(GLenum arg0) {

+    _pre_call_callback("glFrontFace", (void*)glFrontFace, 1, arg0);

+     glad_glFrontFace(arg0);

+    _post_call_callback("glFrontFace", (void*)glFrontFace, 1, arg0);

+}

+PFNGLFRONTFACEPROC glad_debug_glFrontFace = glad_debug_impl_glFrontFace;

+PFNGLGENBUFFERSPROC glad_glGenBuffers;

+void APIENTRY glad_debug_impl_glGenBuffers(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenBuffers", (void*)glGenBuffers, 2, arg0, arg1);

+     glad_glGenBuffers(arg0, arg1);

+    _post_call_callback("glGenBuffers", (void*)glGenBuffers, 2, arg0, arg1);

+}

+PFNGLGENBUFFERSPROC glad_debug_glGenBuffers = glad_debug_impl_glGenBuffers;

+PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;

+void APIENTRY glad_debug_impl_glGenFramebuffers(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenFramebuffers", (void*)glGenFramebuffers, 2, arg0, arg1);

+     glad_glGenFramebuffers(arg0, arg1);

+    _post_call_callback("glGenFramebuffers", (void*)glGenFramebuffers, 2, arg0, arg1);

+}

+PFNGLGENFRAMEBUFFERSPROC glad_debug_glGenFramebuffers = glad_debug_impl_glGenFramebuffers;

+PFNGLGENQUERIESPROC glad_glGenQueries;

+void APIENTRY glad_debug_impl_glGenQueries(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenQueries", (void*)glGenQueries, 2, arg0, arg1);

+     glad_glGenQueries(arg0, arg1);

+    _post_call_callback("glGenQueries", (void*)glGenQueries, 2, arg0, arg1);

+}

+PFNGLGENQUERIESPROC glad_debug_glGenQueries = glad_debug_impl_glGenQueries;

+PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;

+void APIENTRY glad_debug_impl_glGenRenderbuffers(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenRenderbuffers", (void*)glGenRenderbuffers, 2, arg0, arg1);

+     glad_glGenRenderbuffers(arg0, arg1);

+    _post_call_callback("glGenRenderbuffers", (void*)glGenRenderbuffers, 2, arg0, arg1);

+}

+PFNGLGENRENDERBUFFERSPROC glad_debug_glGenRenderbuffers = glad_debug_impl_glGenRenderbuffers;

+PFNGLGENTEXTURESPROC glad_glGenTextures;

+void APIENTRY glad_debug_impl_glGenTextures(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenTextures", (void*)glGenTextures, 2, arg0, arg1);

+     glad_glGenTextures(arg0, arg1);

+    _post_call_callback("glGenTextures", (void*)glGenTextures, 2, arg0, arg1);

+}

+PFNGLGENTEXTURESPROC glad_debug_glGenTextures = glad_debug_impl_glGenTextures;

+PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;

+void APIENTRY glad_debug_impl_glGenVertexArrays(GLsizei arg0, GLuint * arg1) {

+    _pre_call_callback("glGenVertexArrays", (void*)glGenVertexArrays, 2, arg0, arg1);

+     glad_glGenVertexArrays(arg0, arg1);

+    _post_call_callback("glGenVertexArrays", (void*)glGenVertexArrays, 2, arg0, arg1);

+}

+PFNGLGENVERTEXARRAYSPROC glad_debug_glGenVertexArrays = glad_debug_impl_glGenVertexArrays;

+PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;

+void APIENTRY glad_debug_impl_glGenerateMipmap(GLenum arg0) {

+    _pre_call_callback("glGenerateMipmap", (void*)glGenerateMipmap, 1, arg0);

+     glad_glGenerateMipmap(arg0);

+    _post_call_callback("glGenerateMipmap", (void*)glGenerateMipmap, 1, arg0);

+}

+PFNGLGENERATEMIPMAPPROC glad_debug_glGenerateMipmap = glad_debug_impl_glGenerateMipmap;

+PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;

+void APIENTRY glad_debug_impl_glGetActiveAttrib(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4, GLenum * arg5, GLchar * arg6) {

+    _pre_call_callback("glGetActiveAttrib", (void*)glGetActiveAttrib, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glGetActiveAttrib(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glGetActiveAttrib", (void*)glGetActiveAttrib, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLGETACTIVEATTRIBPROC glad_debug_glGetActiveAttrib = glad_debug_impl_glGetActiveAttrib;

+PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;

+void APIENTRY glad_debug_impl_glGetActiveUniform(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4, GLenum * arg5, GLchar * arg6) {

+    _pre_call_callback("glGetActiveUniform", (void*)glGetActiveUniform, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glGetActiveUniform(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glGetActiveUniform", (void*)glGetActiveUniform, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLGETACTIVEUNIFORMPROC glad_debug_glGetActiveUniform = glad_debug_impl_glGetActiveUniform;

+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;

+void APIENTRY glad_debug_impl_glGetActiveUniformBlockName(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLchar * arg4) {

+    _pre_call_callback("glGetActiveUniformBlockName", (void*)glGetActiveUniformBlockName, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glGetActiveUniformBlockName(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glGetActiveUniformBlockName", (void*)glGetActiveUniformBlockName, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_debug_glGetActiveUniformBlockName = glad_debug_impl_glGetActiveUniformBlockName;

+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;

+void APIENTRY glad_debug_impl_glGetActiveUniformBlockiv(GLuint arg0, GLuint arg1, GLenum arg2, GLint * arg3) {

+    _pre_call_callback("glGetActiveUniformBlockiv", (void*)glGetActiveUniformBlockiv, 4, arg0, arg1, arg2, arg3);

+     glad_glGetActiveUniformBlockiv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetActiveUniformBlockiv", (void*)glGetActiveUniformBlockiv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_debug_glGetActiveUniformBlockiv = glad_debug_impl_glGetActiveUniformBlockiv;

+PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;

+void APIENTRY glad_debug_impl_glGetActiveUniformName(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLchar * arg4) {

+    _pre_call_callback("glGetActiveUniformName", (void*)glGetActiveUniformName, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glGetActiveUniformName(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glGetActiveUniformName", (void*)glGetActiveUniformName, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLGETACTIVEUNIFORMNAMEPROC glad_debug_glGetActiveUniformName = glad_debug_impl_glGetActiveUniformName;

+PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;

+void APIENTRY glad_debug_impl_glGetActiveUniformsiv(GLuint arg0, GLsizei arg1, const GLuint * arg2, GLenum arg3, GLint * arg4) {

+    _pre_call_callback("glGetActiveUniformsiv", (void*)glGetActiveUniformsiv, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glGetActiveUniformsiv(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glGetActiveUniformsiv", (void*)glGetActiveUniformsiv, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLGETACTIVEUNIFORMSIVPROC glad_debug_glGetActiveUniformsiv = glad_debug_impl_glGetActiveUniformsiv;

+PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;

+void APIENTRY glad_debug_impl_glGetAttachedShaders(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLuint * arg3) {

+    _pre_call_callback("glGetAttachedShaders", (void*)glGetAttachedShaders, 4, arg0, arg1, arg2, arg3);

+     glad_glGetAttachedShaders(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetAttachedShaders", (void*)glGetAttachedShaders, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETATTACHEDSHADERSPROC glad_debug_glGetAttachedShaders = glad_debug_impl_glGetAttachedShaders;

+PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;

+GLint APIENTRY glad_debug_impl_glGetAttribLocation(GLuint arg0, const GLchar * arg1) {

+    GLint ret;

+    _pre_call_callback("glGetAttribLocation", (void*)glGetAttribLocation, 2, arg0, arg1);

+    ret =  glad_glGetAttribLocation(arg0, arg1);

+    _post_call_callback("glGetAttribLocation", (void*)glGetAttribLocation, 2, arg0, arg1);

+    return ret;

+}

+PFNGLGETATTRIBLOCATIONPROC glad_debug_glGetAttribLocation = glad_debug_impl_glGetAttribLocation;

+PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;

+void APIENTRY glad_debug_impl_glGetBooleani_v(GLenum arg0, GLuint arg1, GLboolean * arg2) {

+    _pre_call_callback("glGetBooleani_v", (void*)glGetBooleani_v, 3, arg0, arg1, arg2);

+     glad_glGetBooleani_v(arg0, arg1, arg2);

+    _post_call_callback("glGetBooleani_v", (void*)glGetBooleani_v, 3, arg0, arg1, arg2);

+}

+PFNGLGETBOOLEANI_VPROC glad_debug_glGetBooleani_v = glad_debug_impl_glGetBooleani_v;

+PFNGLGETBOOLEANVPROC glad_glGetBooleanv;

+void APIENTRY glad_debug_impl_glGetBooleanv(GLenum arg0, GLboolean * arg1) {

+    _pre_call_callback("glGetBooleanv", (void*)glGetBooleanv, 2, arg0, arg1);

+     glad_glGetBooleanv(arg0, arg1);

+    _post_call_callback("glGetBooleanv", (void*)glGetBooleanv, 2, arg0, arg1);

+}

+PFNGLGETBOOLEANVPROC glad_debug_glGetBooleanv = glad_debug_impl_glGetBooleanv;

+PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;

+void APIENTRY glad_debug_impl_glGetBufferParameteri64v(GLenum arg0, GLenum arg1, GLint64 * arg2) {

+    _pre_call_callback("glGetBufferParameteri64v", (void*)glGetBufferParameteri64v, 3, arg0, arg1, arg2);

+     glad_glGetBufferParameteri64v(arg0, arg1, arg2);

+    _post_call_callback("glGetBufferParameteri64v", (void*)glGetBufferParameteri64v, 3, arg0, arg1, arg2);

+}

+PFNGLGETBUFFERPARAMETERI64VPROC glad_debug_glGetBufferParameteri64v = glad_debug_impl_glGetBufferParameteri64v;

+PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;

+void APIENTRY glad_debug_impl_glGetBufferParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetBufferParameteriv", (void*)glGetBufferParameteriv, 3, arg0, arg1, arg2);

+     glad_glGetBufferParameteriv(arg0, arg1, arg2);

+    _post_call_callback("glGetBufferParameteriv", (void*)glGetBufferParameteriv, 3, arg0, arg1, arg2);

+}

+PFNGLGETBUFFERPARAMETERIVPROC glad_debug_glGetBufferParameteriv = glad_debug_impl_glGetBufferParameteriv;

+PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;

+void APIENTRY glad_debug_impl_glGetBufferPointerv(GLenum arg0, GLenum arg1, void ** arg2) {

+    _pre_call_callback("glGetBufferPointerv", (void*)glGetBufferPointerv, 3, arg0, arg1, arg2);

+     glad_glGetBufferPointerv(arg0, arg1, arg2);

+    _post_call_callback("glGetBufferPointerv", (void*)glGetBufferPointerv, 3, arg0, arg1, arg2);

+}

+PFNGLGETBUFFERPOINTERVPROC glad_debug_glGetBufferPointerv = glad_debug_impl_glGetBufferPointerv;

+PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;

+void APIENTRY glad_debug_impl_glGetBufferSubData(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, void * arg3) {

+    _pre_call_callback("glGetBufferSubData", (void*)glGetBufferSubData, 4, arg0, arg1, arg2, arg3);

+     glad_glGetBufferSubData(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetBufferSubData", (void*)glGetBufferSubData, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETBUFFERSUBDATAPROC glad_debug_glGetBufferSubData = glad_debug_impl_glGetBufferSubData;

+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;

+void APIENTRY glad_debug_impl_glGetCompressedTexImage(GLenum arg0, GLint arg1, void * arg2) {

+    _pre_call_callback("glGetCompressedTexImage", (void*)glGetCompressedTexImage, 3, arg0, arg1, arg2);

+     glad_glGetCompressedTexImage(arg0, arg1, arg2);

+    _post_call_callback("glGetCompressedTexImage", (void*)glGetCompressedTexImage, 3, arg0, arg1, arg2);

+}

+PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_debug_glGetCompressedTexImage = glad_debug_impl_glGetCompressedTexImage;

+PFNGLGETDOUBLEVPROC glad_glGetDoublev;

+void APIENTRY glad_debug_impl_glGetDoublev(GLenum arg0, GLdouble * arg1) {

+    _pre_call_callback("glGetDoublev", (void*)glGetDoublev, 2, arg0, arg1);

+     glad_glGetDoublev(arg0, arg1);

+    _post_call_callback("glGetDoublev", (void*)glGetDoublev, 2, arg0, arg1);

+}

+PFNGLGETDOUBLEVPROC glad_debug_glGetDoublev = glad_debug_impl_glGetDoublev;

+PFNGLGETERRORPROC glad_glGetError;

+GLenum APIENTRY glad_debug_impl_glGetError(void) {

+    GLenum ret;

+    _pre_call_callback("glGetError", (void*)glGetError, 0);

+    ret =  glad_glGetError();

+    _post_call_callback("glGetError", (void*)glGetError, 0);

+    return ret;

+}

+PFNGLGETERRORPROC glad_debug_glGetError = glad_debug_impl_glGetError;

+PFNGLGETFLOATVPROC glad_glGetFloatv;

+void APIENTRY glad_debug_impl_glGetFloatv(GLenum arg0, GLfloat * arg1) {

+    _pre_call_callback("glGetFloatv", (void*)glGetFloatv, 2, arg0, arg1);

+     glad_glGetFloatv(arg0, arg1);

+    _post_call_callback("glGetFloatv", (void*)glGetFloatv, 2, arg0, arg1);

+}

+PFNGLGETFLOATVPROC glad_debug_glGetFloatv = glad_debug_impl_glGetFloatv;

+PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;

+GLint APIENTRY glad_debug_impl_glGetFragDataLocation(GLuint arg0, const GLchar * arg1) {

+    GLint ret;

+    _pre_call_callback("glGetFragDataLocation", (void*)glGetFragDataLocation, 2, arg0, arg1);

+    ret =  glad_glGetFragDataLocation(arg0, arg1);

+    _post_call_callback("glGetFragDataLocation", (void*)glGetFragDataLocation, 2, arg0, arg1);

+    return ret;

+}

+PFNGLGETFRAGDATALOCATIONPROC glad_debug_glGetFragDataLocation = glad_debug_impl_glGetFragDataLocation;

+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;

+void APIENTRY glad_debug_impl_glGetFramebufferAttachmentParameteriv(GLenum arg0, GLenum arg1, GLenum arg2, GLint * arg3) {

+    _pre_call_callback("glGetFramebufferAttachmentParameteriv", (void*)glGetFramebufferAttachmentParameteriv, 4, arg0, arg1, arg2, arg3);

+     glad_glGetFramebufferAttachmentParameteriv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetFramebufferAttachmentParameteriv", (void*)glGetFramebufferAttachmentParameteriv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_debug_glGetFramebufferAttachmentParameteriv = glad_debug_impl_glGetFramebufferAttachmentParameteriv;

+PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;

+void APIENTRY glad_debug_impl_glGetInteger64i_v(GLenum arg0, GLuint arg1, GLint64 * arg2) {

+    _pre_call_callback("glGetInteger64i_v", (void*)glGetInteger64i_v, 3, arg0, arg1, arg2);

+     glad_glGetInteger64i_v(arg0, arg1, arg2);

+    _post_call_callback("glGetInteger64i_v", (void*)glGetInteger64i_v, 3, arg0, arg1, arg2);

+}

+PFNGLGETINTEGER64I_VPROC glad_debug_glGetInteger64i_v = glad_debug_impl_glGetInteger64i_v;

+PFNGLGETINTEGER64VPROC glad_glGetInteger64v;

+void APIENTRY glad_debug_impl_glGetInteger64v(GLenum arg0, GLint64 * arg1) {

+    _pre_call_callback("glGetInteger64v", (void*)glGetInteger64v, 2, arg0, arg1);

+     glad_glGetInteger64v(arg0, arg1);

+    _post_call_callback("glGetInteger64v", (void*)glGetInteger64v, 2, arg0, arg1);

+}

+PFNGLGETINTEGER64VPROC glad_debug_glGetInteger64v = glad_debug_impl_glGetInteger64v;

+PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;

+void APIENTRY glad_debug_impl_glGetIntegeri_v(GLenum arg0, GLuint arg1, GLint * arg2) {

+    _pre_call_callback("glGetIntegeri_v", (void*)glGetIntegeri_v, 3, arg0, arg1, arg2);

+     glad_glGetIntegeri_v(arg0, arg1, arg2);

+    _post_call_callback("glGetIntegeri_v", (void*)glGetIntegeri_v, 3, arg0, arg1, arg2);

+}

+PFNGLGETINTEGERI_VPROC glad_debug_glGetIntegeri_v = glad_debug_impl_glGetIntegeri_v;

+PFNGLGETINTEGERVPROC glad_glGetIntegerv;

+void APIENTRY glad_debug_impl_glGetIntegerv(GLenum arg0, GLint * arg1) {

+    _pre_call_callback("glGetIntegerv", (void*)glGetIntegerv, 2, arg0, arg1);

+     glad_glGetIntegerv(arg0, arg1);

+    _post_call_callback("glGetIntegerv", (void*)glGetIntegerv, 2, arg0, arg1);

+}

+PFNGLGETINTEGERVPROC glad_debug_glGetIntegerv = glad_debug_impl_glGetIntegerv;

+PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;

+void APIENTRY glad_debug_impl_glGetMultisamplefv(GLenum arg0, GLuint arg1, GLfloat * arg2) {

+    _pre_call_callback("glGetMultisamplefv", (void*)glGetMultisamplefv, 3, arg0, arg1, arg2);

+     glad_glGetMultisamplefv(arg0, arg1, arg2);

+    _post_call_callback("glGetMultisamplefv", (void*)glGetMultisamplefv, 3, arg0, arg1, arg2);

+}

+PFNGLGETMULTISAMPLEFVPROC glad_debug_glGetMultisamplefv = glad_debug_impl_glGetMultisamplefv;

+PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;

+void APIENTRY glad_debug_impl_glGetProgramInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) {

+    _pre_call_callback("glGetProgramInfoLog", (void*)glGetProgramInfoLog, 4, arg0, arg1, arg2, arg3);

+     glad_glGetProgramInfoLog(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetProgramInfoLog", (void*)glGetProgramInfoLog, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETPROGRAMINFOLOGPROC glad_debug_glGetProgramInfoLog = glad_debug_impl_glGetProgramInfoLog;

+PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;

+void APIENTRY glad_debug_impl_glGetProgramiv(GLuint arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetProgramiv", (void*)glGetProgramiv, 3, arg0, arg1, arg2);

+     glad_glGetProgramiv(arg0, arg1, arg2);

+    _post_call_callback("glGetProgramiv", (void*)glGetProgramiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETPROGRAMIVPROC glad_debug_glGetProgramiv = glad_debug_impl_glGetProgramiv;

+PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;

+void APIENTRY glad_debug_impl_glGetQueryObjectiv(GLuint arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetQueryObjectiv", (void*)glGetQueryObjectiv, 3, arg0, arg1, arg2);

+     glad_glGetQueryObjectiv(arg0, arg1, arg2);

+    _post_call_callback("glGetQueryObjectiv", (void*)glGetQueryObjectiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETQUERYOBJECTIVPROC glad_debug_glGetQueryObjectiv = glad_debug_impl_glGetQueryObjectiv;

+PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;

+void APIENTRY glad_debug_impl_glGetQueryObjectuiv(GLuint arg0, GLenum arg1, GLuint * arg2) {

+    _pre_call_callback("glGetQueryObjectuiv", (void*)glGetQueryObjectuiv, 3, arg0, arg1, arg2);

+     glad_glGetQueryObjectuiv(arg0, arg1, arg2);

+    _post_call_callback("glGetQueryObjectuiv", (void*)glGetQueryObjectuiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETQUERYOBJECTUIVPROC glad_debug_glGetQueryObjectuiv = glad_debug_impl_glGetQueryObjectuiv;

+PFNGLGETQUERYIVPROC glad_glGetQueryiv;

+void APIENTRY glad_debug_impl_glGetQueryiv(GLenum arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetQueryiv", (void*)glGetQueryiv, 3, arg0, arg1, arg2);

+     glad_glGetQueryiv(arg0, arg1, arg2);

+    _post_call_callback("glGetQueryiv", (void*)glGetQueryiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETQUERYIVPROC glad_debug_glGetQueryiv = glad_debug_impl_glGetQueryiv;

+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;

+void APIENTRY glad_debug_impl_glGetRenderbufferParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetRenderbufferParameteriv", (void*)glGetRenderbufferParameteriv, 3, arg0, arg1, arg2);

+     glad_glGetRenderbufferParameteriv(arg0, arg1, arg2);

+    _post_call_callback("glGetRenderbufferParameteriv", (void*)glGetRenderbufferParameteriv, 3, arg0, arg1, arg2);

+}

+PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_debug_glGetRenderbufferParameteriv = glad_debug_impl_glGetRenderbufferParameteriv;

+PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;

+void APIENTRY glad_debug_impl_glGetShaderInfoLog(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) {

+    _pre_call_callback("glGetShaderInfoLog", (void*)glGetShaderInfoLog, 4, arg0, arg1, arg2, arg3);

+     glad_glGetShaderInfoLog(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetShaderInfoLog", (void*)glGetShaderInfoLog, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETSHADERINFOLOGPROC glad_debug_glGetShaderInfoLog = glad_debug_impl_glGetShaderInfoLog;

+PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;

+void APIENTRY glad_debug_impl_glGetShaderSource(GLuint arg0, GLsizei arg1, GLsizei * arg2, GLchar * arg3) {

+    _pre_call_callback("glGetShaderSource", (void*)glGetShaderSource, 4, arg0, arg1, arg2, arg3);

+     glad_glGetShaderSource(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetShaderSource", (void*)glGetShaderSource, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETSHADERSOURCEPROC glad_debug_glGetShaderSource = glad_debug_impl_glGetShaderSource;

+PFNGLGETSHADERIVPROC glad_glGetShaderiv;

+void APIENTRY glad_debug_impl_glGetShaderiv(GLuint arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetShaderiv", (void*)glGetShaderiv, 3, arg0, arg1, arg2);

+     glad_glGetShaderiv(arg0, arg1, arg2);

+    _post_call_callback("glGetShaderiv", (void*)glGetShaderiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETSHADERIVPROC glad_debug_glGetShaderiv = glad_debug_impl_glGetShaderiv;

+PFNGLGETSTRINGPROC glad_glGetString;

+const GLubyte * APIENTRY glad_debug_impl_glGetString(GLenum arg0) {

+    const GLubyte * ret;

+    _pre_call_callback("glGetString", (void*)glGetString, 1, arg0);

+    ret =  glad_glGetString(arg0);

+    _post_call_callback("glGetString", (void*)glGetString, 1, arg0);

+    return ret;

+}

+PFNGLGETSTRINGPROC glad_debug_glGetString = glad_debug_impl_glGetString;

+PFNGLGETSTRINGIPROC glad_glGetStringi;

+const GLubyte * APIENTRY glad_debug_impl_glGetStringi(GLenum arg0, GLuint arg1) {

+    const GLubyte * ret;

+    _pre_call_callback("glGetStringi", (void*)glGetStringi, 2, arg0, arg1);

+    ret =  glad_glGetStringi(arg0, arg1);

+    _post_call_callback("glGetStringi", (void*)glGetStringi, 2, arg0, arg1);

+    return ret;

+}

+PFNGLGETSTRINGIPROC glad_debug_glGetStringi = glad_debug_impl_glGetStringi;

+PFNGLGETSYNCIVPROC glad_glGetSynciv;

+void APIENTRY glad_debug_impl_glGetSynciv(GLsync arg0, GLenum arg1, GLsizei arg2, GLsizei * arg3, GLint * arg4) {

+    _pre_call_callback("glGetSynciv", (void*)glGetSynciv, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glGetSynciv(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glGetSynciv", (void*)glGetSynciv, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLGETSYNCIVPROC glad_debug_glGetSynciv = glad_debug_impl_glGetSynciv;

+PFNGLGETTEXIMAGEPROC glad_glGetTexImage;

+void APIENTRY glad_debug_impl_glGetTexImage(GLenum arg0, GLint arg1, GLenum arg2, GLenum arg3, void * arg4) {

+    _pre_call_callback("glGetTexImage", (void*)glGetTexImage, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glGetTexImage(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glGetTexImage", (void*)glGetTexImage, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLGETTEXIMAGEPROC glad_debug_glGetTexImage = glad_debug_impl_glGetTexImage;

+PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;

+void APIENTRY glad_debug_impl_glGetTexLevelParameterfv(GLenum arg0, GLint arg1, GLenum arg2, GLfloat * arg3) {

+    _pre_call_callback("glGetTexLevelParameterfv", (void*)glGetTexLevelParameterfv, 4, arg0, arg1, arg2, arg3);

+     glad_glGetTexLevelParameterfv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetTexLevelParameterfv", (void*)glGetTexLevelParameterfv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETTEXLEVELPARAMETERFVPROC glad_debug_glGetTexLevelParameterfv = glad_debug_impl_glGetTexLevelParameterfv;

+PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;

+void APIENTRY glad_debug_impl_glGetTexLevelParameteriv(GLenum arg0, GLint arg1, GLenum arg2, GLint * arg3) {

+    _pre_call_callback("glGetTexLevelParameteriv", (void*)glGetTexLevelParameteriv, 4, arg0, arg1, arg2, arg3);

+     glad_glGetTexLevelParameteriv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetTexLevelParameteriv", (void*)glGetTexLevelParameteriv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETTEXLEVELPARAMETERIVPROC glad_debug_glGetTexLevelParameteriv = glad_debug_impl_glGetTexLevelParameteriv;

+PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;

+void APIENTRY glad_debug_impl_glGetTexParameterIiv(GLenum arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetTexParameterIiv", (void*)glGetTexParameterIiv, 3, arg0, arg1, arg2);

+     glad_glGetTexParameterIiv(arg0, arg1, arg2);

+    _post_call_callback("glGetTexParameterIiv", (void*)glGetTexParameterIiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETTEXPARAMETERIIVPROC glad_debug_glGetTexParameterIiv = glad_debug_impl_glGetTexParameterIiv;

+PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;

+void APIENTRY glad_debug_impl_glGetTexParameterIuiv(GLenum arg0, GLenum arg1, GLuint * arg2) {

+    _pre_call_callback("glGetTexParameterIuiv", (void*)glGetTexParameterIuiv, 3, arg0, arg1, arg2);

+     glad_glGetTexParameterIuiv(arg0, arg1, arg2);

+    _post_call_callback("glGetTexParameterIuiv", (void*)glGetTexParameterIuiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETTEXPARAMETERIUIVPROC glad_debug_glGetTexParameterIuiv = glad_debug_impl_glGetTexParameterIuiv;

+PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;

+void APIENTRY glad_debug_impl_glGetTexParameterfv(GLenum arg0, GLenum arg1, GLfloat * arg2) {

+    _pre_call_callback("glGetTexParameterfv", (void*)glGetTexParameterfv, 3, arg0, arg1, arg2);

+     glad_glGetTexParameterfv(arg0, arg1, arg2);

+    _post_call_callback("glGetTexParameterfv", (void*)glGetTexParameterfv, 3, arg0, arg1, arg2);

+}

+PFNGLGETTEXPARAMETERFVPROC glad_debug_glGetTexParameterfv = glad_debug_impl_glGetTexParameterfv;

+PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;

+void APIENTRY glad_debug_impl_glGetTexParameteriv(GLenum arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetTexParameteriv", (void*)glGetTexParameteriv, 3, arg0, arg1, arg2);

+     glad_glGetTexParameteriv(arg0, arg1, arg2);

+    _post_call_callback("glGetTexParameteriv", (void*)glGetTexParameteriv, 3, arg0, arg1, arg2);

+}

+PFNGLGETTEXPARAMETERIVPROC glad_debug_glGetTexParameteriv = glad_debug_impl_glGetTexParameteriv;

+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;

+void APIENTRY glad_debug_impl_glGetTransformFeedbackVarying(GLuint arg0, GLuint arg1, GLsizei arg2, GLsizei * arg3, GLsizei * arg4, GLenum * arg5, GLchar * arg6) {

+    _pre_call_callback("glGetTransformFeedbackVarying", (void*)glGetTransformFeedbackVarying, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glGetTransformFeedbackVarying(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glGetTransformFeedbackVarying", (void*)glGetTransformFeedbackVarying, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_debug_glGetTransformFeedbackVarying = glad_debug_impl_glGetTransformFeedbackVarying;

+PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;

+GLuint APIENTRY glad_debug_impl_glGetUniformBlockIndex(GLuint arg0, const GLchar * arg1) {

+    GLuint ret;

+    _pre_call_callback("glGetUniformBlockIndex", (void*)glGetUniformBlockIndex, 2, arg0, arg1);

+    ret =  glad_glGetUniformBlockIndex(arg0, arg1);

+    _post_call_callback("glGetUniformBlockIndex", (void*)glGetUniformBlockIndex, 2, arg0, arg1);

+    return ret;

+}

+PFNGLGETUNIFORMBLOCKINDEXPROC glad_debug_glGetUniformBlockIndex = glad_debug_impl_glGetUniformBlockIndex;

+PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;

+void APIENTRY glad_debug_impl_glGetUniformIndices(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, GLuint * arg3) {

+    _pre_call_callback("glGetUniformIndices", (void*)glGetUniformIndices, 4, arg0, arg1, arg2, arg3);

+     glad_glGetUniformIndices(arg0, arg1, arg2, arg3);

+    _post_call_callback("glGetUniformIndices", (void*)glGetUniformIndices, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLGETUNIFORMINDICESPROC glad_debug_glGetUniformIndices = glad_debug_impl_glGetUniformIndices;

+PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;

+GLint APIENTRY glad_debug_impl_glGetUniformLocation(GLuint arg0, const GLchar * arg1) {

+    GLint ret;

+    _pre_call_callback("glGetUniformLocation", (void*)glGetUniformLocation, 2, arg0, arg1);

+    ret =  glad_glGetUniformLocation(arg0, arg1);

+    _post_call_callback("glGetUniformLocation", (void*)glGetUniformLocation, 2, arg0, arg1);

+    return ret;

+}

+PFNGLGETUNIFORMLOCATIONPROC glad_debug_glGetUniformLocation = glad_debug_impl_glGetUniformLocation;

+PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;

+void APIENTRY glad_debug_impl_glGetUniformfv(GLuint arg0, GLint arg1, GLfloat * arg2) {

+    _pre_call_callback("glGetUniformfv", (void*)glGetUniformfv, 3, arg0, arg1, arg2);

+     glad_glGetUniformfv(arg0, arg1, arg2);

+    _post_call_callback("glGetUniformfv", (void*)glGetUniformfv, 3, arg0, arg1, arg2);

+}

+PFNGLGETUNIFORMFVPROC glad_debug_glGetUniformfv = glad_debug_impl_glGetUniformfv;

+PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;

+void APIENTRY glad_debug_impl_glGetUniformiv(GLuint arg0, GLint arg1, GLint * arg2) {

+    _pre_call_callback("glGetUniformiv", (void*)glGetUniformiv, 3, arg0, arg1, arg2);

+     glad_glGetUniformiv(arg0, arg1, arg2);

+    _post_call_callback("glGetUniformiv", (void*)glGetUniformiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETUNIFORMIVPROC glad_debug_glGetUniformiv = glad_debug_impl_glGetUniformiv;

+PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;

+void APIENTRY glad_debug_impl_glGetUniformuiv(GLuint arg0, GLint arg1, GLuint * arg2) {

+    _pre_call_callback("glGetUniformuiv", (void*)glGetUniformuiv, 3, arg0, arg1, arg2);

+     glad_glGetUniformuiv(arg0, arg1, arg2);

+    _post_call_callback("glGetUniformuiv", (void*)glGetUniformuiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETUNIFORMUIVPROC glad_debug_glGetUniformuiv = glad_debug_impl_glGetUniformuiv;

+PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;

+void APIENTRY glad_debug_impl_glGetVertexAttribIiv(GLuint arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetVertexAttribIiv", (void*)glGetVertexAttribIiv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribIiv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribIiv", (void*)glGetVertexAttribIiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBIIVPROC glad_debug_glGetVertexAttribIiv = glad_debug_impl_glGetVertexAttribIiv;

+PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;

+void APIENTRY glad_debug_impl_glGetVertexAttribIuiv(GLuint arg0, GLenum arg1, GLuint * arg2) {

+    _pre_call_callback("glGetVertexAttribIuiv", (void*)glGetVertexAttribIuiv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribIuiv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribIuiv", (void*)glGetVertexAttribIuiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBIUIVPROC glad_debug_glGetVertexAttribIuiv = glad_debug_impl_glGetVertexAttribIuiv;

+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;

+void APIENTRY glad_debug_impl_glGetVertexAttribPointerv(GLuint arg0, GLenum arg1, void ** arg2) {

+    _pre_call_callback("glGetVertexAttribPointerv", (void*)glGetVertexAttribPointerv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribPointerv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribPointerv", (void*)glGetVertexAttribPointerv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBPOINTERVPROC glad_debug_glGetVertexAttribPointerv = glad_debug_impl_glGetVertexAttribPointerv;

+PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;

+void APIENTRY glad_debug_impl_glGetVertexAttribdv(GLuint arg0, GLenum arg1, GLdouble * arg2) {

+    _pre_call_callback("glGetVertexAttribdv", (void*)glGetVertexAttribdv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribdv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribdv", (void*)glGetVertexAttribdv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBDVPROC glad_debug_glGetVertexAttribdv = glad_debug_impl_glGetVertexAttribdv;

+PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;

+void APIENTRY glad_debug_impl_glGetVertexAttribfv(GLuint arg0, GLenum arg1, GLfloat * arg2) {

+    _pre_call_callback("glGetVertexAttribfv", (void*)glGetVertexAttribfv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribfv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribfv", (void*)glGetVertexAttribfv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBFVPROC glad_debug_glGetVertexAttribfv = glad_debug_impl_glGetVertexAttribfv;

+PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;

+void APIENTRY glad_debug_impl_glGetVertexAttribiv(GLuint arg0, GLenum arg1, GLint * arg2) {

+    _pre_call_callback("glGetVertexAttribiv", (void*)glGetVertexAttribiv, 3, arg0, arg1, arg2);

+     glad_glGetVertexAttribiv(arg0, arg1, arg2);

+    _post_call_callback("glGetVertexAttribiv", (void*)glGetVertexAttribiv, 3, arg0, arg1, arg2);

+}

+PFNGLGETVERTEXATTRIBIVPROC glad_debug_glGetVertexAttribiv = glad_debug_impl_glGetVertexAttribiv;

+PFNGLHINTPROC glad_glHint;

+void APIENTRY glad_debug_impl_glHint(GLenum arg0, GLenum arg1) {

+    _pre_call_callback("glHint", (void*)glHint, 2, arg0, arg1);

+     glad_glHint(arg0, arg1);

+    _post_call_callback("glHint", (void*)glHint, 2, arg0, arg1);

+}

+PFNGLHINTPROC glad_debug_glHint = glad_debug_impl_glHint;

+PFNGLISBUFFERPROC glad_glIsBuffer;

+GLboolean APIENTRY glad_debug_impl_glIsBuffer(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsBuffer", (void*)glIsBuffer, 1, arg0);

+    ret =  glad_glIsBuffer(arg0);

+    _post_call_callback("glIsBuffer", (void*)glIsBuffer, 1, arg0);

+    return ret;

+}

+PFNGLISBUFFERPROC glad_debug_glIsBuffer = glad_debug_impl_glIsBuffer;

+PFNGLISENABLEDPROC glad_glIsEnabled;

+GLboolean APIENTRY glad_debug_impl_glIsEnabled(GLenum arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsEnabled", (void*)glIsEnabled, 1, arg0);

+    ret =  glad_glIsEnabled(arg0);

+    _post_call_callback("glIsEnabled", (void*)glIsEnabled, 1, arg0);

+    return ret;

+}

+PFNGLISENABLEDPROC glad_debug_glIsEnabled = glad_debug_impl_glIsEnabled;

+PFNGLISENABLEDIPROC glad_glIsEnabledi;

+GLboolean APIENTRY glad_debug_impl_glIsEnabledi(GLenum arg0, GLuint arg1) {

+    GLboolean ret;

+    _pre_call_callback("glIsEnabledi", (void*)glIsEnabledi, 2, arg0, arg1);

+    ret =  glad_glIsEnabledi(arg0, arg1);

+    _post_call_callback("glIsEnabledi", (void*)glIsEnabledi, 2, arg0, arg1);

+    return ret;

+}

+PFNGLISENABLEDIPROC glad_debug_glIsEnabledi = glad_debug_impl_glIsEnabledi;

+PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;

+GLboolean APIENTRY glad_debug_impl_glIsFramebuffer(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsFramebuffer", (void*)glIsFramebuffer, 1, arg0);

+    ret =  glad_glIsFramebuffer(arg0);

+    _post_call_callback("glIsFramebuffer", (void*)glIsFramebuffer, 1, arg0);

+    return ret;

+}

+PFNGLISFRAMEBUFFERPROC glad_debug_glIsFramebuffer = glad_debug_impl_glIsFramebuffer;

+PFNGLISPROGRAMPROC glad_glIsProgram;

+GLboolean APIENTRY glad_debug_impl_glIsProgram(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsProgram", (void*)glIsProgram, 1, arg0);

+    ret =  glad_glIsProgram(arg0);

+    _post_call_callback("glIsProgram", (void*)glIsProgram, 1, arg0);

+    return ret;

+}

+PFNGLISPROGRAMPROC glad_debug_glIsProgram = glad_debug_impl_glIsProgram;

+PFNGLISQUERYPROC glad_glIsQuery;

+GLboolean APIENTRY glad_debug_impl_glIsQuery(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsQuery", (void*)glIsQuery, 1, arg0);

+    ret =  glad_glIsQuery(arg0);

+    _post_call_callback("glIsQuery", (void*)glIsQuery, 1, arg0);

+    return ret;

+}

+PFNGLISQUERYPROC glad_debug_glIsQuery = glad_debug_impl_glIsQuery;

+PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;

+GLboolean APIENTRY glad_debug_impl_glIsRenderbuffer(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsRenderbuffer", (void*)glIsRenderbuffer, 1, arg0);

+    ret =  glad_glIsRenderbuffer(arg0);

+    _post_call_callback("glIsRenderbuffer", (void*)glIsRenderbuffer, 1, arg0);

+    return ret;

+}

+PFNGLISRENDERBUFFERPROC glad_debug_glIsRenderbuffer = glad_debug_impl_glIsRenderbuffer;

+PFNGLISSHADERPROC glad_glIsShader;

+GLboolean APIENTRY glad_debug_impl_glIsShader(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsShader", (void*)glIsShader, 1, arg0);

+    ret =  glad_glIsShader(arg0);

+    _post_call_callback("glIsShader", (void*)glIsShader, 1, arg0);

+    return ret;

+}

+PFNGLISSHADERPROC glad_debug_glIsShader = glad_debug_impl_glIsShader;

+PFNGLISSYNCPROC glad_glIsSync;

+GLboolean APIENTRY glad_debug_impl_glIsSync(GLsync arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsSync", (void*)glIsSync, 1, arg0);

+    ret =  glad_glIsSync(arg0);

+    _post_call_callback("glIsSync", (void*)glIsSync, 1, arg0);

+    return ret;

+}

+PFNGLISSYNCPROC glad_debug_glIsSync = glad_debug_impl_glIsSync;

+PFNGLISTEXTUREPROC glad_glIsTexture;

+GLboolean APIENTRY glad_debug_impl_glIsTexture(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsTexture", (void*)glIsTexture, 1, arg0);

+    ret =  glad_glIsTexture(arg0);

+    _post_call_callback("glIsTexture", (void*)glIsTexture, 1, arg0);

+    return ret;

+}

+PFNGLISTEXTUREPROC glad_debug_glIsTexture = glad_debug_impl_glIsTexture;

+PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;

+GLboolean APIENTRY glad_debug_impl_glIsVertexArray(GLuint arg0) {

+    GLboolean ret;

+    _pre_call_callback("glIsVertexArray", (void*)glIsVertexArray, 1, arg0);

+    ret =  glad_glIsVertexArray(arg0);

+    _post_call_callback("glIsVertexArray", (void*)glIsVertexArray, 1, arg0);

+    return ret;

+}

+PFNGLISVERTEXARRAYPROC glad_debug_glIsVertexArray = glad_debug_impl_glIsVertexArray;

+PFNGLLINEWIDTHPROC glad_glLineWidth;

+void APIENTRY glad_debug_impl_glLineWidth(GLfloat arg0) {

+    _pre_call_callback("glLineWidth", (void*)glLineWidth, 1, arg0);

+     glad_glLineWidth(arg0);

+    _post_call_callback("glLineWidth", (void*)glLineWidth, 1, arg0);

+}

+PFNGLLINEWIDTHPROC glad_debug_glLineWidth = glad_debug_impl_glLineWidth;

+PFNGLLINKPROGRAMPROC glad_glLinkProgram;

+void APIENTRY glad_debug_impl_glLinkProgram(GLuint arg0) {

+    _pre_call_callback("glLinkProgram", (void*)glLinkProgram, 1, arg0);

+     glad_glLinkProgram(arg0);

+    _post_call_callback("glLinkProgram", (void*)glLinkProgram, 1, arg0);

+}

+PFNGLLINKPROGRAMPROC glad_debug_glLinkProgram = glad_debug_impl_glLinkProgram;

+PFNGLLOGICOPPROC glad_glLogicOp;

+void APIENTRY glad_debug_impl_glLogicOp(GLenum arg0) {

+    _pre_call_callback("glLogicOp", (void*)glLogicOp, 1, arg0);

+     glad_glLogicOp(arg0);

+    _post_call_callback("glLogicOp", (void*)glLogicOp, 1, arg0);

+}

+PFNGLLOGICOPPROC glad_debug_glLogicOp = glad_debug_impl_glLogicOp;

+PFNGLMAPBUFFERPROC glad_glMapBuffer;

+void * APIENTRY glad_debug_impl_glMapBuffer(GLenum arg0, GLenum arg1) {

+    void * ret;

+    _pre_call_callback("glMapBuffer", (void*)glMapBuffer, 2, arg0, arg1);

+    ret =  glad_glMapBuffer(arg0, arg1);

+    _post_call_callback("glMapBuffer", (void*)glMapBuffer, 2, arg0, arg1);

+    return ret;

+}

+PFNGLMAPBUFFERPROC glad_debug_glMapBuffer = glad_debug_impl_glMapBuffer;

+PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;

+void * APIENTRY glad_debug_impl_glMapBufferRange(GLenum arg0, GLintptr arg1, GLsizeiptr arg2, GLbitfield arg3) {

+    void * ret;

+    _pre_call_callback("glMapBufferRange", (void*)glMapBufferRange, 4, arg0, arg1, arg2, arg3);

+    ret =  glad_glMapBufferRange(arg0, arg1, arg2, arg3);

+    _post_call_callback("glMapBufferRange", (void*)glMapBufferRange, 4, arg0, arg1, arg2, arg3);

+    return ret;

+}

+PFNGLMAPBUFFERRANGEPROC glad_debug_glMapBufferRange = glad_debug_impl_glMapBufferRange;

+PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;

+void APIENTRY glad_debug_impl_glMultiDrawArrays(GLenum arg0, const GLint * arg1, const GLsizei * arg2, GLsizei arg3) {

+    _pre_call_callback("glMultiDrawArrays", (void*)glMultiDrawArrays, 4, arg0, arg1, arg2, arg3);

+     glad_glMultiDrawArrays(arg0, arg1, arg2, arg3);

+    _post_call_callback("glMultiDrawArrays", (void*)glMultiDrawArrays, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLMULTIDRAWARRAYSPROC glad_debug_glMultiDrawArrays = glad_debug_impl_glMultiDrawArrays;

+PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;

+void APIENTRY glad_debug_impl_glMultiDrawElements(GLenum arg0, const GLsizei * arg1, GLenum arg2, const void *const* arg3, GLsizei arg4) {

+    _pre_call_callback("glMultiDrawElements", (void*)glMultiDrawElements, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glMultiDrawElements(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glMultiDrawElements", (void*)glMultiDrawElements, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLMULTIDRAWELEMENTSPROC glad_debug_glMultiDrawElements = glad_debug_impl_glMultiDrawElements;

+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;

+void APIENTRY glad_debug_impl_glMultiDrawElementsBaseVertex(GLenum arg0, const GLsizei * arg1, GLenum arg2, const void *const* arg3, GLsizei arg4, const GLint * arg5) {

+    _pre_call_callback("glMultiDrawElementsBaseVertex", (void*)glMultiDrawElementsBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glMultiDrawElementsBaseVertex(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glMultiDrawElementsBaseVertex", (void*)glMultiDrawElementsBaseVertex, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_debug_glMultiDrawElementsBaseVertex = glad_debug_impl_glMultiDrawElementsBaseVertex;

+PFNGLPIXELSTOREFPROC glad_glPixelStoref;

+void APIENTRY glad_debug_impl_glPixelStoref(GLenum arg0, GLfloat arg1) {

+    _pre_call_callback("glPixelStoref", (void*)glPixelStoref, 2, arg0, arg1);

+     glad_glPixelStoref(arg0, arg1);

+    _post_call_callback("glPixelStoref", (void*)glPixelStoref, 2, arg0, arg1);

+}

+PFNGLPIXELSTOREFPROC glad_debug_glPixelStoref = glad_debug_impl_glPixelStoref;

+PFNGLPIXELSTOREIPROC glad_glPixelStorei;

+void APIENTRY glad_debug_impl_glPixelStorei(GLenum arg0, GLint arg1) {

+    _pre_call_callback("glPixelStorei", (void*)glPixelStorei, 2, arg0, arg1);

+     glad_glPixelStorei(arg0, arg1);

+    _post_call_callback("glPixelStorei", (void*)glPixelStorei, 2, arg0, arg1);

+}

+PFNGLPIXELSTOREIPROC glad_debug_glPixelStorei = glad_debug_impl_glPixelStorei;

+PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;

+void APIENTRY glad_debug_impl_glPointParameterf(GLenum arg0, GLfloat arg1) {

+    _pre_call_callback("glPointParameterf", (void*)glPointParameterf, 2, arg0, arg1);

+     glad_glPointParameterf(arg0, arg1);

+    _post_call_callback("glPointParameterf", (void*)glPointParameterf, 2, arg0, arg1);

+}

+PFNGLPOINTPARAMETERFPROC glad_debug_glPointParameterf = glad_debug_impl_glPointParameterf;

+PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;

+void APIENTRY glad_debug_impl_glPointParameterfv(GLenum arg0, const GLfloat * arg1) {

+    _pre_call_callback("glPointParameterfv", (void*)glPointParameterfv, 2, arg0, arg1);

+     glad_glPointParameterfv(arg0, arg1);

+    _post_call_callback("glPointParameterfv", (void*)glPointParameterfv, 2, arg0, arg1);

+}

+PFNGLPOINTPARAMETERFVPROC glad_debug_glPointParameterfv = glad_debug_impl_glPointParameterfv;

+PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;

+void APIENTRY glad_debug_impl_glPointParameteri(GLenum arg0, GLint arg1) {

+    _pre_call_callback("glPointParameteri", (void*)glPointParameteri, 2, arg0, arg1);

+     glad_glPointParameteri(arg0, arg1);

+    _post_call_callback("glPointParameteri", (void*)glPointParameteri, 2, arg0, arg1);

+}

+PFNGLPOINTPARAMETERIPROC glad_debug_glPointParameteri = glad_debug_impl_glPointParameteri;

+PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;

+void APIENTRY glad_debug_impl_glPointParameteriv(GLenum arg0, const GLint * arg1) {

+    _pre_call_callback("glPointParameteriv", (void*)glPointParameteriv, 2, arg0, arg1);

+     glad_glPointParameteriv(arg0, arg1);

+    _post_call_callback("glPointParameteriv", (void*)glPointParameteriv, 2, arg0, arg1);

+}

+PFNGLPOINTPARAMETERIVPROC glad_debug_glPointParameteriv = glad_debug_impl_glPointParameteriv;

+PFNGLPOINTSIZEPROC glad_glPointSize;

+void APIENTRY glad_debug_impl_glPointSize(GLfloat arg0) {

+    _pre_call_callback("glPointSize", (void*)glPointSize, 1, arg0);

+     glad_glPointSize(arg0);

+    _post_call_callback("glPointSize", (void*)glPointSize, 1, arg0);

+}

+PFNGLPOINTSIZEPROC glad_debug_glPointSize = glad_debug_impl_glPointSize;

+PFNGLPOLYGONMODEPROC glad_glPolygonMode;

+void APIENTRY glad_debug_impl_glPolygonMode(GLenum arg0, GLenum arg1) {

+    _pre_call_callback("glPolygonMode", (void*)glPolygonMode, 2, arg0, arg1);

+     glad_glPolygonMode(arg0, arg1);

+    _post_call_callback("glPolygonMode", (void*)glPolygonMode, 2, arg0, arg1);

+}

+PFNGLPOLYGONMODEPROC glad_debug_glPolygonMode = glad_debug_impl_glPolygonMode;

+PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;

+void APIENTRY glad_debug_impl_glPolygonOffset(GLfloat arg0, GLfloat arg1) {

+    _pre_call_callback("glPolygonOffset", (void*)glPolygonOffset, 2, arg0, arg1);

+     glad_glPolygonOffset(arg0, arg1);

+    _post_call_callback("glPolygonOffset", (void*)glPolygonOffset, 2, arg0, arg1);

+}

+PFNGLPOLYGONOFFSETPROC glad_debug_glPolygonOffset = glad_debug_impl_glPolygonOffset;

+PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;

+void APIENTRY glad_debug_impl_glPrimitiveRestartIndex(GLuint arg0) {

+    _pre_call_callback("glPrimitiveRestartIndex", (void*)glPrimitiveRestartIndex, 1, arg0);

+     glad_glPrimitiveRestartIndex(arg0);

+    _post_call_callback("glPrimitiveRestartIndex", (void*)glPrimitiveRestartIndex, 1, arg0);

+}

+PFNGLPRIMITIVERESTARTINDEXPROC glad_debug_glPrimitiveRestartIndex = glad_debug_impl_glPrimitiveRestartIndex;

+PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;

+void APIENTRY glad_debug_impl_glProvokingVertex(GLenum arg0) {

+    _pre_call_callback("glProvokingVertex", (void*)glProvokingVertex, 1, arg0);

+     glad_glProvokingVertex(arg0);

+    _post_call_callback("glProvokingVertex", (void*)glProvokingVertex, 1, arg0);

+}

+PFNGLPROVOKINGVERTEXPROC glad_debug_glProvokingVertex = glad_debug_impl_glProvokingVertex;

+PFNGLREADBUFFERPROC glad_glReadBuffer;

+void APIENTRY glad_debug_impl_glReadBuffer(GLenum arg0) {

+    _pre_call_callback("glReadBuffer", (void*)glReadBuffer, 1, arg0);

+     glad_glReadBuffer(arg0);

+    _post_call_callback("glReadBuffer", (void*)glReadBuffer, 1, arg0);

+}

+PFNGLREADBUFFERPROC glad_debug_glReadBuffer = glad_debug_impl_glReadBuffer;

+PFNGLREADPIXELSPROC glad_glReadPixels;

+void APIENTRY glad_debug_impl_glReadPixels(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3, GLenum arg4, GLenum arg5, void * arg6) {

+    _pre_call_callback("glReadPixels", (void*)glReadPixels, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glReadPixels(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glReadPixels", (void*)glReadPixels, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLREADPIXELSPROC glad_debug_glReadPixels = glad_debug_impl_glReadPixels;

+PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;

+void APIENTRY glad_debug_impl_glRenderbufferStorage(GLenum arg0, GLenum arg1, GLsizei arg2, GLsizei arg3) {

+    _pre_call_callback("glRenderbufferStorage", (void*)glRenderbufferStorage, 4, arg0, arg1, arg2, arg3);

+     glad_glRenderbufferStorage(arg0, arg1, arg2, arg3);

+    _post_call_callback("glRenderbufferStorage", (void*)glRenderbufferStorage, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLRENDERBUFFERSTORAGEPROC glad_debug_glRenderbufferStorage = glad_debug_impl_glRenderbufferStorage;

+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;

+void APIENTRY glad_debug_impl_glRenderbufferStorageMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4) {

+    _pre_call_callback("glRenderbufferStorageMultisample", (void*)glRenderbufferStorageMultisample, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glRenderbufferStorageMultisample(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glRenderbufferStorageMultisample", (void*)glRenderbufferStorageMultisample, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_debug_glRenderbufferStorageMultisample = glad_debug_impl_glRenderbufferStorageMultisample;

+PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;

+void APIENTRY glad_debug_impl_glSampleCoverage(GLfloat arg0, GLboolean arg1) {

+    _pre_call_callback("glSampleCoverage", (void*)glSampleCoverage, 2, arg0, arg1);

+     glad_glSampleCoverage(arg0, arg1);

+    _post_call_callback("glSampleCoverage", (void*)glSampleCoverage, 2, arg0, arg1);

+}

+PFNGLSAMPLECOVERAGEPROC glad_debug_glSampleCoverage = glad_debug_impl_glSampleCoverage;

+PFNGLSAMPLEMASKIPROC glad_glSampleMaski;

+void APIENTRY glad_debug_impl_glSampleMaski(GLuint arg0, GLbitfield arg1) {

+    _pre_call_callback("glSampleMaski", (void*)glSampleMaski, 2, arg0, arg1);

+     glad_glSampleMaski(arg0, arg1);

+    _post_call_callback("glSampleMaski", (void*)glSampleMaski, 2, arg0, arg1);

+}

+PFNGLSAMPLEMASKIPROC glad_debug_glSampleMaski = glad_debug_impl_glSampleMaski;

+PFNGLSCISSORPROC glad_glScissor;

+void APIENTRY glad_debug_impl_glScissor(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3) {

+    _pre_call_callback("glScissor", (void*)glScissor, 4, arg0, arg1, arg2, arg3);

+     glad_glScissor(arg0, arg1, arg2, arg3);

+    _post_call_callback("glScissor", (void*)glScissor, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLSCISSORPROC glad_debug_glScissor = glad_debug_impl_glScissor;

+PFNGLSHADERSOURCEPROC glad_glShaderSource;

+void APIENTRY glad_debug_impl_glShaderSource(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, const GLint * arg3) {

+    _pre_call_callback("glShaderSource", (void*)glShaderSource, 4, arg0, arg1, arg2, arg3);

+     glad_glShaderSource(arg0, arg1, arg2, arg3);

+    _post_call_callback("glShaderSource", (void*)glShaderSource, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLSHADERSOURCEPROC glad_debug_glShaderSource = glad_debug_impl_glShaderSource;

+PFNGLSTENCILFUNCPROC glad_glStencilFunc;

+void APIENTRY glad_debug_impl_glStencilFunc(GLenum arg0, GLint arg1, GLuint arg2) {

+    _pre_call_callback("glStencilFunc", (void*)glStencilFunc, 3, arg0, arg1, arg2);

+     glad_glStencilFunc(arg0, arg1, arg2);

+    _post_call_callback("glStencilFunc", (void*)glStencilFunc, 3, arg0, arg1, arg2);

+}

+PFNGLSTENCILFUNCPROC glad_debug_glStencilFunc = glad_debug_impl_glStencilFunc;

+PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;

+void APIENTRY glad_debug_impl_glStencilFuncSeparate(GLenum arg0, GLenum arg1, GLint arg2, GLuint arg3) {

+    _pre_call_callback("glStencilFuncSeparate", (void*)glStencilFuncSeparate, 4, arg0, arg1, arg2, arg3);

+     glad_glStencilFuncSeparate(arg0, arg1, arg2, arg3);

+    _post_call_callback("glStencilFuncSeparate", (void*)glStencilFuncSeparate, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLSTENCILFUNCSEPARATEPROC glad_debug_glStencilFuncSeparate = glad_debug_impl_glStencilFuncSeparate;

+PFNGLSTENCILMASKPROC glad_glStencilMask;

+void APIENTRY glad_debug_impl_glStencilMask(GLuint arg0) {

+    _pre_call_callback("glStencilMask", (void*)glStencilMask, 1, arg0);

+     glad_glStencilMask(arg0);

+    _post_call_callback("glStencilMask", (void*)glStencilMask, 1, arg0);

+}

+PFNGLSTENCILMASKPROC glad_debug_glStencilMask = glad_debug_impl_glStencilMask;

+PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;

+void APIENTRY glad_debug_impl_glStencilMaskSeparate(GLenum arg0, GLuint arg1) {

+    _pre_call_callback("glStencilMaskSeparate", (void*)glStencilMaskSeparate, 2, arg0, arg1);

+     glad_glStencilMaskSeparate(arg0, arg1);

+    _post_call_callback("glStencilMaskSeparate", (void*)glStencilMaskSeparate, 2, arg0, arg1);

+}

+PFNGLSTENCILMASKSEPARATEPROC glad_debug_glStencilMaskSeparate = glad_debug_impl_glStencilMaskSeparate;

+PFNGLSTENCILOPPROC glad_glStencilOp;

+void APIENTRY glad_debug_impl_glStencilOp(GLenum arg0, GLenum arg1, GLenum arg2) {

+    _pre_call_callback("glStencilOp", (void*)glStencilOp, 3, arg0, arg1, arg2);

+     glad_glStencilOp(arg0, arg1, arg2);

+    _post_call_callback("glStencilOp", (void*)glStencilOp, 3, arg0, arg1, arg2);

+}

+PFNGLSTENCILOPPROC glad_debug_glStencilOp = glad_debug_impl_glStencilOp;

+PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;

+void APIENTRY glad_debug_impl_glStencilOpSeparate(GLenum arg0, GLenum arg1, GLenum arg2, GLenum arg3) {

+    _pre_call_callback("glStencilOpSeparate", (void*)glStencilOpSeparate, 4, arg0, arg1, arg2, arg3);

+     glad_glStencilOpSeparate(arg0, arg1, arg2, arg3);

+    _post_call_callback("glStencilOpSeparate", (void*)glStencilOpSeparate, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLSTENCILOPSEPARATEPROC glad_debug_glStencilOpSeparate = glad_debug_impl_glStencilOpSeparate;

+PFNGLTEXBUFFERPROC glad_glTexBuffer;

+void APIENTRY glad_debug_impl_glTexBuffer(GLenum arg0, GLenum arg1, GLuint arg2) {

+    _pre_call_callback("glTexBuffer", (void*)glTexBuffer, 3, arg0, arg1, arg2);

+     glad_glTexBuffer(arg0, arg1, arg2);

+    _post_call_callback("glTexBuffer", (void*)glTexBuffer, 3, arg0, arg1, arg2);

+}

+PFNGLTEXBUFFERPROC glad_debug_glTexBuffer = glad_debug_impl_glTexBuffer;

+PFNGLTEXIMAGE1DPROC glad_glTexImage1D;

+void APIENTRY glad_debug_impl_glTexImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLint arg4, GLenum arg5, GLenum arg6, const void * arg7) {

+    _pre_call_callback("glTexImage1D", (void*)glTexImage1D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+     glad_glTexImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+    _post_call_callback("glTexImage1D", (void*)glTexImage1D, 8, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);

+}

+PFNGLTEXIMAGE1DPROC glad_debug_glTexImage1D = glad_debug_impl_glTexImage1D;

+PFNGLTEXIMAGE2DPROC glad_glTexImage2D;

+void APIENTRY glad_debug_impl_glTexImage2D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLint arg5, GLenum arg6, GLenum arg7, const void * arg8) {

+    _pre_call_callback("glTexImage2D", (void*)glTexImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+     glad_glTexImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+    _post_call_callback("glTexImage2D", (void*)glTexImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+}

+PFNGLTEXIMAGE2DPROC glad_debug_glTexImage2D = glad_debug_impl_glTexImage2D;

+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;

+void APIENTRY glad_debug_impl_glTexImage2DMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLboolean arg5) {

+    _pre_call_callback("glTexImage2DMultisample", (void*)glTexImage2DMultisample, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glTexImage2DMultisample(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glTexImage2DMultisample", (void*)glTexImage2DMultisample, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_debug_glTexImage2DMultisample = glad_debug_impl_glTexImage2DMultisample;

+PFNGLTEXIMAGE3DPROC glad_glTexImage3D;

+void APIENTRY glad_debug_impl_glTexImage3D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLint arg6, GLenum arg7, GLenum arg8, const void * arg9) {

+    _pre_call_callback("glTexImage3D", (void*)glTexImage3D, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+     glad_glTexImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+    _post_call_callback("glTexImage3D", (void*)glTexImage3D, 10, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

+}

+PFNGLTEXIMAGE3DPROC glad_debug_glTexImage3D = glad_debug_impl_glTexImage3D;

+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;

+void APIENTRY glad_debug_impl_glTexImage3DMultisample(GLenum arg0, GLsizei arg1, GLenum arg2, GLsizei arg3, GLsizei arg4, GLsizei arg5, GLboolean arg6) {

+    _pre_call_callback("glTexImage3DMultisample", (void*)glTexImage3DMultisample, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glTexImage3DMultisample(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glTexImage3DMultisample", (void*)glTexImage3DMultisample, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_debug_glTexImage3DMultisample = glad_debug_impl_glTexImage3DMultisample;

+PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;

+void APIENTRY glad_debug_impl_glTexParameterIiv(GLenum arg0, GLenum arg1, const GLint * arg2) {

+    _pre_call_callback("glTexParameterIiv", (void*)glTexParameterIiv, 3, arg0, arg1, arg2);

+     glad_glTexParameterIiv(arg0, arg1, arg2);

+    _post_call_callback("glTexParameterIiv", (void*)glTexParameterIiv, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERIIVPROC glad_debug_glTexParameterIiv = glad_debug_impl_glTexParameterIiv;

+PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;

+void APIENTRY glad_debug_impl_glTexParameterIuiv(GLenum arg0, GLenum arg1, const GLuint * arg2) {

+    _pre_call_callback("glTexParameterIuiv", (void*)glTexParameterIuiv, 3, arg0, arg1, arg2);

+     glad_glTexParameterIuiv(arg0, arg1, arg2);

+    _post_call_callback("glTexParameterIuiv", (void*)glTexParameterIuiv, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERIUIVPROC glad_debug_glTexParameterIuiv = glad_debug_impl_glTexParameterIuiv;

+PFNGLTEXPARAMETERFPROC glad_glTexParameterf;

+void APIENTRY glad_debug_impl_glTexParameterf(GLenum arg0, GLenum arg1, GLfloat arg2) {

+    _pre_call_callback("glTexParameterf", (void*)glTexParameterf, 3, arg0, arg1, arg2);

+     glad_glTexParameterf(arg0, arg1, arg2);

+    _post_call_callback("glTexParameterf", (void*)glTexParameterf, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERFPROC glad_debug_glTexParameterf = glad_debug_impl_glTexParameterf;

+PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;

+void APIENTRY glad_debug_impl_glTexParameterfv(GLenum arg0, GLenum arg1, const GLfloat * arg2) {

+    _pre_call_callback("glTexParameterfv", (void*)glTexParameterfv, 3, arg0, arg1, arg2);

+     glad_glTexParameterfv(arg0, arg1, arg2);

+    _post_call_callback("glTexParameterfv", (void*)glTexParameterfv, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERFVPROC glad_debug_glTexParameterfv = glad_debug_impl_glTexParameterfv;

+PFNGLTEXPARAMETERIPROC glad_glTexParameteri;

+void APIENTRY glad_debug_impl_glTexParameteri(GLenum arg0, GLenum arg1, GLint arg2) {

+    _pre_call_callback("glTexParameteri", (void*)glTexParameteri, 3, arg0, arg1, arg2);

+     glad_glTexParameteri(arg0, arg1, arg2);

+    _post_call_callback("glTexParameteri", (void*)glTexParameteri, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERIPROC glad_debug_glTexParameteri = glad_debug_impl_glTexParameteri;

+PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;

+void APIENTRY glad_debug_impl_glTexParameteriv(GLenum arg0, GLenum arg1, const GLint * arg2) {

+    _pre_call_callback("glTexParameteriv", (void*)glTexParameteriv, 3, arg0, arg1, arg2);

+     glad_glTexParameteriv(arg0, arg1, arg2);

+    _post_call_callback("glTexParameteriv", (void*)glTexParameteriv, 3, arg0, arg1, arg2);

+}

+PFNGLTEXPARAMETERIVPROC glad_debug_glTexParameteriv = glad_debug_impl_glTexParameteriv;

+PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;

+void APIENTRY glad_debug_impl_glTexSubImage1D(GLenum arg0, GLint arg1, GLint arg2, GLsizei arg3, GLenum arg4, GLenum arg5, const void * arg6) {

+    _pre_call_callback("glTexSubImage1D", (void*)glTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+     glad_glTexSubImage1D(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+    _post_call_callback("glTexSubImage1D", (void*)glTexSubImage1D, 7, arg0, arg1, arg2, arg3, arg4, arg5, arg6);

+}

+PFNGLTEXSUBIMAGE1DPROC glad_debug_glTexSubImage1D = glad_debug_impl_glTexSubImage1D;

+PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;

+void APIENTRY glad_debug_impl_glTexSubImage2D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLsizei arg4, GLsizei arg5, GLenum arg6, GLenum arg7, const void * arg8) {

+    _pre_call_callback("glTexSubImage2D", (void*)glTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+     glad_glTexSubImage2D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+    _post_call_callback("glTexSubImage2D", (void*)glTexSubImage2D, 9, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

+}

+PFNGLTEXSUBIMAGE2DPROC glad_debug_glTexSubImage2D = glad_debug_impl_glTexSubImage2D;

+PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;

+void APIENTRY glad_debug_impl_glTexSubImage3D(GLenum arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4, GLsizei arg5, GLsizei arg6, GLsizei arg7, GLenum arg8, GLenum arg9, const void * arg10) {

+    _pre_call_callback("glTexSubImage3D", (void*)glTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+     glad_glTexSubImage3D(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+    _post_call_callback("glTexSubImage3D", (void*)glTexSubImage3D, 11, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);

+}

+PFNGLTEXSUBIMAGE3DPROC glad_debug_glTexSubImage3D = glad_debug_impl_glTexSubImage3D;

+PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;

+void APIENTRY glad_debug_impl_glTransformFeedbackVaryings(GLuint arg0, GLsizei arg1, const GLchar *const* arg2, GLenum arg3) {

+    _pre_call_callback("glTransformFeedbackVaryings", (void*)glTransformFeedbackVaryings, 4, arg0, arg1, arg2, arg3);

+     glad_glTransformFeedbackVaryings(arg0, arg1, arg2, arg3);

+    _post_call_callback("glTransformFeedbackVaryings", (void*)glTransformFeedbackVaryings, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_debug_glTransformFeedbackVaryings = glad_debug_impl_glTransformFeedbackVaryings;

+PFNGLUNIFORM1FPROC glad_glUniform1f;

+void APIENTRY glad_debug_impl_glUniform1f(GLint arg0, GLfloat arg1) {

+    _pre_call_callback("glUniform1f", (void*)glUniform1f, 2, arg0, arg1);

+     glad_glUniform1f(arg0, arg1);

+    _post_call_callback("glUniform1f", (void*)glUniform1f, 2, arg0, arg1);

+}

+PFNGLUNIFORM1FPROC glad_debug_glUniform1f = glad_debug_impl_glUniform1f;

+PFNGLUNIFORM1FVPROC glad_glUniform1fv;

+void APIENTRY glad_debug_impl_glUniform1fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) {

+    _pre_call_callback("glUniform1fv", (void*)glUniform1fv, 3, arg0, arg1, arg2);

+     glad_glUniform1fv(arg0, arg1, arg2);

+    _post_call_callback("glUniform1fv", (void*)glUniform1fv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM1FVPROC glad_debug_glUniform1fv = glad_debug_impl_glUniform1fv;

+PFNGLUNIFORM1IPROC glad_glUniform1i;

+void APIENTRY glad_debug_impl_glUniform1i(GLint arg0, GLint arg1) {

+    _pre_call_callback("glUniform1i", (void*)glUniform1i, 2, arg0, arg1);

+     glad_glUniform1i(arg0, arg1);

+    _post_call_callback("glUniform1i", (void*)glUniform1i, 2, arg0, arg1);

+}

+PFNGLUNIFORM1IPROC glad_debug_glUniform1i = glad_debug_impl_glUniform1i;

+PFNGLUNIFORM1IVPROC glad_glUniform1iv;

+void APIENTRY glad_debug_impl_glUniform1iv(GLint arg0, GLsizei arg1, const GLint * arg2) {

+    _pre_call_callback("glUniform1iv", (void*)glUniform1iv, 3, arg0, arg1, arg2);

+     glad_glUniform1iv(arg0, arg1, arg2);

+    _post_call_callback("glUniform1iv", (void*)glUniform1iv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM1IVPROC glad_debug_glUniform1iv = glad_debug_impl_glUniform1iv;

+PFNGLUNIFORM1UIPROC glad_glUniform1ui;

+void APIENTRY glad_debug_impl_glUniform1ui(GLint arg0, GLuint arg1) {

+    _pre_call_callback("glUniform1ui", (void*)glUniform1ui, 2, arg0, arg1);

+     glad_glUniform1ui(arg0, arg1);

+    _post_call_callback("glUniform1ui", (void*)glUniform1ui, 2, arg0, arg1);

+}

+PFNGLUNIFORM1UIPROC glad_debug_glUniform1ui = glad_debug_impl_glUniform1ui;

+PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;

+void APIENTRY glad_debug_impl_glUniform1uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) {

+    _pre_call_callback("glUniform1uiv", (void*)glUniform1uiv, 3, arg0, arg1, arg2);

+     glad_glUniform1uiv(arg0, arg1, arg2);

+    _post_call_callback("glUniform1uiv", (void*)glUniform1uiv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM1UIVPROC glad_debug_glUniform1uiv = glad_debug_impl_glUniform1uiv;

+PFNGLUNIFORM2FPROC glad_glUniform2f;

+void APIENTRY glad_debug_impl_glUniform2f(GLint arg0, GLfloat arg1, GLfloat arg2) {

+    _pre_call_callback("glUniform2f", (void*)glUniform2f, 3, arg0, arg1, arg2);

+     glad_glUniform2f(arg0, arg1, arg2);

+    _post_call_callback("glUniform2f", (void*)glUniform2f, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2FPROC glad_debug_glUniform2f = glad_debug_impl_glUniform2f;

+PFNGLUNIFORM2FVPROC glad_glUniform2fv;

+void APIENTRY glad_debug_impl_glUniform2fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) {

+    _pre_call_callback("glUniform2fv", (void*)glUniform2fv, 3, arg0, arg1, arg2);

+     glad_glUniform2fv(arg0, arg1, arg2);

+    _post_call_callback("glUniform2fv", (void*)glUniform2fv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2FVPROC glad_debug_glUniform2fv = glad_debug_impl_glUniform2fv;

+PFNGLUNIFORM2IPROC glad_glUniform2i;

+void APIENTRY glad_debug_impl_glUniform2i(GLint arg0, GLint arg1, GLint arg2) {

+    _pre_call_callback("glUniform2i", (void*)glUniform2i, 3, arg0, arg1, arg2);

+     glad_glUniform2i(arg0, arg1, arg2);

+    _post_call_callback("glUniform2i", (void*)glUniform2i, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2IPROC glad_debug_glUniform2i = glad_debug_impl_glUniform2i;

+PFNGLUNIFORM2IVPROC glad_glUniform2iv;

+void APIENTRY glad_debug_impl_glUniform2iv(GLint arg0, GLsizei arg1, const GLint * arg2) {

+    _pre_call_callback("glUniform2iv", (void*)glUniform2iv, 3, arg0, arg1, arg2);

+     glad_glUniform2iv(arg0, arg1, arg2);

+    _post_call_callback("glUniform2iv", (void*)glUniform2iv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2IVPROC glad_debug_glUniform2iv = glad_debug_impl_glUniform2iv;

+PFNGLUNIFORM2UIPROC glad_glUniform2ui;

+void APIENTRY glad_debug_impl_glUniform2ui(GLint arg0, GLuint arg1, GLuint arg2) {

+    _pre_call_callback("glUniform2ui", (void*)glUniform2ui, 3, arg0, arg1, arg2);

+     glad_glUniform2ui(arg0, arg1, arg2);

+    _post_call_callback("glUniform2ui", (void*)glUniform2ui, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2UIPROC glad_debug_glUniform2ui = glad_debug_impl_glUniform2ui;

+PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;

+void APIENTRY glad_debug_impl_glUniform2uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) {

+    _pre_call_callback("glUniform2uiv", (void*)glUniform2uiv, 3, arg0, arg1, arg2);

+     glad_glUniform2uiv(arg0, arg1, arg2);

+    _post_call_callback("glUniform2uiv", (void*)glUniform2uiv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM2UIVPROC glad_debug_glUniform2uiv = glad_debug_impl_glUniform2uiv;

+PFNGLUNIFORM3FPROC glad_glUniform3f;

+void APIENTRY glad_debug_impl_glUniform3f(GLint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) {

+    _pre_call_callback("glUniform3f", (void*)glUniform3f, 4, arg0, arg1, arg2, arg3);

+     glad_glUniform3f(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniform3f", (void*)glUniform3f, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORM3FPROC glad_debug_glUniform3f = glad_debug_impl_glUniform3f;

+PFNGLUNIFORM3FVPROC glad_glUniform3fv;

+void APIENTRY glad_debug_impl_glUniform3fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) {

+    _pre_call_callback("glUniform3fv", (void*)glUniform3fv, 3, arg0, arg1, arg2);

+     glad_glUniform3fv(arg0, arg1, arg2);

+    _post_call_callback("glUniform3fv", (void*)glUniform3fv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM3FVPROC glad_debug_glUniform3fv = glad_debug_impl_glUniform3fv;

+PFNGLUNIFORM3IPROC glad_glUniform3i;

+void APIENTRY glad_debug_impl_glUniform3i(GLint arg0, GLint arg1, GLint arg2, GLint arg3) {

+    _pre_call_callback("glUniform3i", (void*)glUniform3i, 4, arg0, arg1, arg2, arg3);

+     glad_glUniform3i(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniform3i", (void*)glUniform3i, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORM3IPROC glad_debug_glUniform3i = glad_debug_impl_glUniform3i;

+PFNGLUNIFORM3IVPROC glad_glUniform3iv;

+void APIENTRY glad_debug_impl_glUniform3iv(GLint arg0, GLsizei arg1, const GLint * arg2) {

+    _pre_call_callback("glUniform3iv", (void*)glUniform3iv, 3, arg0, arg1, arg2);

+     glad_glUniform3iv(arg0, arg1, arg2);

+    _post_call_callback("glUniform3iv", (void*)glUniform3iv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM3IVPROC glad_debug_glUniform3iv = glad_debug_impl_glUniform3iv;

+PFNGLUNIFORM3UIPROC glad_glUniform3ui;

+void APIENTRY glad_debug_impl_glUniform3ui(GLint arg0, GLuint arg1, GLuint arg2, GLuint arg3) {

+    _pre_call_callback("glUniform3ui", (void*)glUniform3ui, 4, arg0, arg1, arg2, arg3);

+     glad_glUniform3ui(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniform3ui", (void*)glUniform3ui, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORM3UIPROC glad_debug_glUniform3ui = glad_debug_impl_glUniform3ui;

+PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;

+void APIENTRY glad_debug_impl_glUniform3uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) {

+    _pre_call_callback("glUniform3uiv", (void*)glUniform3uiv, 3, arg0, arg1, arg2);

+     glad_glUniform3uiv(arg0, arg1, arg2);

+    _post_call_callback("glUniform3uiv", (void*)glUniform3uiv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM3UIVPROC glad_debug_glUniform3uiv = glad_debug_impl_glUniform3uiv;

+PFNGLUNIFORM4FPROC glad_glUniform4f;

+void APIENTRY glad_debug_impl_glUniform4f(GLint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3, GLfloat arg4) {

+    _pre_call_callback("glUniform4f", (void*)glUniform4f, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glUniform4f(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glUniform4f", (void*)glUniform4f, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLUNIFORM4FPROC glad_debug_glUniform4f = glad_debug_impl_glUniform4f;

+PFNGLUNIFORM4FVPROC glad_glUniform4fv;

+void APIENTRY glad_debug_impl_glUniform4fv(GLint arg0, GLsizei arg1, const GLfloat * arg2) {

+    _pre_call_callback("glUniform4fv", (void*)glUniform4fv, 3, arg0, arg1, arg2);

+     glad_glUniform4fv(arg0, arg1, arg2);

+    _post_call_callback("glUniform4fv", (void*)glUniform4fv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM4FVPROC glad_debug_glUniform4fv = glad_debug_impl_glUniform4fv;

+PFNGLUNIFORM4IPROC glad_glUniform4i;

+void APIENTRY glad_debug_impl_glUniform4i(GLint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4) {

+    _pre_call_callback("glUniform4i", (void*)glUniform4i, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glUniform4i(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glUniform4i", (void*)glUniform4i, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLUNIFORM4IPROC glad_debug_glUniform4i = glad_debug_impl_glUniform4i;

+PFNGLUNIFORM4IVPROC glad_glUniform4iv;

+void APIENTRY glad_debug_impl_glUniform4iv(GLint arg0, GLsizei arg1, const GLint * arg2) {

+    _pre_call_callback("glUniform4iv", (void*)glUniform4iv, 3, arg0, arg1, arg2);

+     glad_glUniform4iv(arg0, arg1, arg2);

+    _post_call_callback("glUniform4iv", (void*)glUniform4iv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM4IVPROC glad_debug_glUniform4iv = glad_debug_impl_glUniform4iv;

+PFNGLUNIFORM4UIPROC glad_glUniform4ui;

+void APIENTRY glad_debug_impl_glUniform4ui(GLint arg0, GLuint arg1, GLuint arg2, GLuint arg3, GLuint arg4) {

+    _pre_call_callback("glUniform4ui", (void*)glUniform4ui, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glUniform4ui(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glUniform4ui", (void*)glUniform4ui, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLUNIFORM4UIPROC glad_debug_glUniform4ui = glad_debug_impl_glUniform4ui;

+PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;

+void APIENTRY glad_debug_impl_glUniform4uiv(GLint arg0, GLsizei arg1, const GLuint * arg2) {

+    _pre_call_callback("glUniform4uiv", (void*)glUniform4uiv, 3, arg0, arg1, arg2);

+     glad_glUniform4uiv(arg0, arg1, arg2);

+    _post_call_callback("glUniform4uiv", (void*)glUniform4uiv, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORM4UIVPROC glad_debug_glUniform4uiv = glad_debug_impl_glUniform4uiv;

+PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;

+void APIENTRY glad_debug_impl_glUniformBlockBinding(GLuint arg0, GLuint arg1, GLuint arg2) {

+    _pre_call_callback("glUniformBlockBinding", (void*)glUniformBlockBinding, 3, arg0, arg1, arg2);

+     glad_glUniformBlockBinding(arg0, arg1, arg2);

+    _post_call_callback("glUniformBlockBinding", (void*)glUniformBlockBinding, 3, arg0, arg1, arg2);

+}

+PFNGLUNIFORMBLOCKBINDINGPROC glad_debug_glUniformBlockBinding = glad_debug_impl_glUniformBlockBinding;

+PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;

+void APIENTRY glad_debug_impl_glUniformMatrix2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix2fv", (void*)glUniformMatrix2fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix2fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix2fv", (void*)glUniformMatrix2fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX2FVPROC glad_debug_glUniformMatrix2fv = glad_debug_impl_glUniformMatrix2fv;

+PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;

+void APIENTRY glad_debug_impl_glUniformMatrix2x3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix2x3fv", (void*)glUniformMatrix2x3fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix2x3fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix2x3fv", (void*)glUniformMatrix2x3fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX2X3FVPROC glad_debug_glUniformMatrix2x3fv = glad_debug_impl_glUniformMatrix2x3fv;

+PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;

+void APIENTRY glad_debug_impl_glUniformMatrix2x4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix2x4fv", (void*)glUniformMatrix2x4fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix2x4fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix2x4fv", (void*)glUniformMatrix2x4fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX2X4FVPROC glad_debug_glUniformMatrix2x4fv = glad_debug_impl_glUniformMatrix2x4fv;

+PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;

+void APIENTRY glad_debug_impl_glUniformMatrix3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix3fv", (void*)glUniformMatrix3fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix3fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix3fv", (void*)glUniformMatrix3fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX3FVPROC glad_debug_glUniformMatrix3fv = glad_debug_impl_glUniformMatrix3fv;

+PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;

+void APIENTRY glad_debug_impl_glUniformMatrix3x2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix3x2fv", (void*)glUniformMatrix3x2fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix3x2fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix3x2fv", (void*)glUniformMatrix3x2fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX3X2FVPROC glad_debug_glUniformMatrix3x2fv = glad_debug_impl_glUniformMatrix3x2fv;

+PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;

+void APIENTRY glad_debug_impl_glUniformMatrix3x4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix3x4fv", (void*)glUniformMatrix3x4fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix3x4fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix3x4fv", (void*)glUniformMatrix3x4fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX3X4FVPROC glad_debug_glUniformMatrix3x4fv = glad_debug_impl_glUniformMatrix3x4fv;

+PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;

+void APIENTRY glad_debug_impl_glUniformMatrix4fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix4fv", (void*)glUniformMatrix4fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix4fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix4fv", (void*)glUniformMatrix4fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX4FVPROC glad_debug_glUniformMatrix4fv = glad_debug_impl_glUniformMatrix4fv;

+PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;

+void APIENTRY glad_debug_impl_glUniformMatrix4x2fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix4x2fv", (void*)glUniformMatrix4x2fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix4x2fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix4x2fv", (void*)glUniformMatrix4x2fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX4X2FVPROC glad_debug_glUniformMatrix4x2fv = glad_debug_impl_glUniformMatrix4x2fv;

+PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;

+void APIENTRY glad_debug_impl_glUniformMatrix4x3fv(GLint arg0, GLsizei arg1, GLboolean arg2, const GLfloat * arg3) {

+    _pre_call_callback("glUniformMatrix4x3fv", (void*)glUniformMatrix4x3fv, 4, arg0, arg1, arg2, arg3);

+     glad_glUniformMatrix4x3fv(arg0, arg1, arg2, arg3);

+    _post_call_callback("glUniformMatrix4x3fv", (void*)glUniformMatrix4x3fv, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLUNIFORMMATRIX4X3FVPROC glad_debug_glUniformMatrix4x3fv = glad_debug_impl_glUniformMatrix4x3fv;

+PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;

+GLboolean APIENTRY glad_debug_impl_glUnmapBuffer(GLenum arg0) {

+    GLboolean ret;

+    _pre_call_callback("glUnmapBuffer", (void*)glUnmapBuffer, 1, arg0);

+    ret =  glad_glUnmapBuffer(arg0);

+    _post_call_callback("glUnmapBuffer", (void*)glUnmapBuffer, 1, arg0);

+    return ret;

+}

+PFNGLUNMAPBUFFERPROC glad_debug_glUnmapBuffer = glad_debug_impl_glUnmapBuffer;

+PFNGLUSEPROGRAMPROC glad_glUseProgram;

+void APIENTRY glad_debug_impl_glUseProgram(GLuint arg0) {

+    _pre_call_callback("glUseProgram", (void*)glUseProgram, 1, arg0);

+     glad_glUseProgram(arg0);

+    _post_call_callback("glUseProgram", (void*)glUseProgram, 1, arg0);

+}

+PFNGLUSEPROGRAMPROC glad_debug_glUseProgram = glad_debug_impl_glUseProgram;

+PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;

+void APIENTRY glad_debug_impl_glValidateProgram(GLuint arg0) {

+    _pre_call_callback("glValidateProgram", (void*)glValidateProgram, 1, arg0);

+     glad_glValidateProgram(arg0);

+    _post_call_callback("glValidateProgram", (void*)glValidateProgram, 1, arg0);

+}

+PFNGLVALIDATEPROGRAMPROC glad_debug_glValidateProgram = glad_debug_impl_glValidateProgram;

+PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;

+void APIENTRY glad_debug_impl_glVertexAttrib1d(GLuint arg0, GLdouble arg1) {

+    _pre_call_callback("glVertexAttrib1d", (void*)glVertexAttrib1d, 2, arg0, arg1);

+     glad_glVertexAttrib1d(arg0, arg1);

+    _post_call_callback("glVertexAttrib1d", (void*)glVertexAttrib1d, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1DPROC glad_debug_glVertexAttrib1d = glad_debug_impl_glVertexAttrib1d;

+PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;

+void APIENTRY glad_debug_impl_glVertexAttrib1dv(GLuint arg0, const GLdouble * arg1) {

+    _pre_call_callback("glVertexAttrib1dv", (void*)glVertexAttrib1dv, 2, arg0, arg1);

+     glad_glVertexAttrib1dv(arg0, arg1);

+    _post_call_callback("glVertexAttrib1dv", (void*)glVertexAttrib1dv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1DVPROC glad_debug_glVertexAttrib1dv = glad_debug_impl_glVertexAttrib1dv;

+PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;

+void APIENTRY glad_debug_impl_glVertexAttrib1f(GLuint arg0, GLfloat arg1) {

+    _pre_call_callback("glVertexAttrib1f", (void*)glVertexAttrib1f, 2, arg0, arg1);

+     glad_glVertexAttrib1f(arg0, arg1);

+    _post_call_callback("glVertexAttrib1f", (void*)glVertexAttrib1f, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1FPROC glad_debug_glVertexAttrib1f = glad_debug_impl_glVertexAttrib1f;

+PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;

+void APIENTRY glad_debug_impl_glVertexAttrib1fv(GLuint arg0, const GLfloat * arg1) {

+    _pre_call_callback("glVertexAttrib1fv", (void*)glVertexAttrib1fv, 2, arg0, arg1);

+     glad_glVertexAttrib1fv(arg0, arg1);

+    _post_call_callback("glVertexAttrib1fv", (void*)glVertexAttrib1fv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1FVPROC glad_debug_glVertexAttrib1fv = glad_debug_impl_glVertexAttrib1fv;

+PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;

+void APIENTRY glad_debug_impl_glVertexAttrib1s(GLuint arg0, GLshort arg1) {

+    _pre_call_callback("glVertexAttrib1s", (void*)glVertexAttrib1s, 2, arg0, arg1);

+     glad_glVertexAttrib1s(arg0, arg1);

+    _post_call_callback("glVertexAttrib1s", (void*)glVertexAttrib1s, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1SPROC glad_debug_glVertexAttrib1s = glad_debug_impl_glVertexAttrib1s;

+PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;

+void APIENTRY glad_debug_impl_glVertexAttrib1sv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttrib1sv", (void*)glVertexAttrib1sv, 2, arg0, arg1);

+     glad_glVertexAttrib1sv(arg0, arg1);

+    _post_call_callback("glVertexAttrib1sv", (void*)glVertexAttrib1sv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB1SVPROC glad_debug_glVertexAttrib1sv = glad_debug_impl_glVertexAttrib1sv;

+PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;

+void APIENTRY glad_debug_impl_glVertexAttrib2d(GLuint arg0, GLdouble arg1, GLdouble arg2) {

+    _pre_call_callback("glVertexAttrib2d", (void*)glVertexAttrib2d, 3, arg0, arg1, arg2);

+     glad_glVertexAttrib2d(arg0, arg1, arg2);

+    _post_call_callback("glVertexAttrib2d", (void*)glVertexAttrib2d, 3, arg0, arg1, arg2);

+}

+PFNGLVERTEXATTRIB2DPROC glad_debug_glVertexAttrib2d = glad_debug_impl_glVertexAttrib2d;

+PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;

+void APIENTRY glad_debug_impl_glVertexAttrib2dv(GLuint arg0, const GLdouble * arg1) {

+    _pre_call_callback("glVertexAttrib2dv", (void*)glVertexAttrib2dv, 2, arg0, arg1);

+     glad_glVertexAttrib2dv(arg0, arg1);

+    _post_call_callback("glVertexAttrib2dv", (void*)glVertexAttrib2dv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB2DVPROC glad_debug_glVertexAttrib2dv = glad_debug_impl_glVertexAttrib2dv;

+PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;

+void APIENTRY glad_debug_impl_glVertexAttrib2f(GLuint arg0, GLfloat arg1, GLfloat arg2) {

+    _pre_call_callback("glVertexAttrib2f", (void*)glVertexAttrib2f, 3, arg0, arg1, arg2);

+     glad_glVertexAttrib2f(arg0, arg1, arg2);

+    _post_call_callback("glVertexAttrib2f", (void*)glVertexAttrib2f, 3, arg0, arg1, arg2);

+}

+PFNGLVERTEXATTRIB2FPROC glad_debug_glVertexAttrib2f = glad_debug_impl_glVertexAttrib2f;

+PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;

+void APIENTRY glad_debug_impl_glVertexAttrib2fv(GLuint arg0, const GLfloat * arg1) {

+    _pre_call_callback("glVertexAttrib2fv", (void*)glVertexAttrib2fv, 2, arg0, arg1);

+     glad_glVertexAttrib2fv(arg0, arg1);

+    _post_call_callback("glVertexAttrib2fv", (void*)glVertexAttrib2fv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB2FVPROC glad_debug_glVertexAttrib2fv = glad_debug_impl_glVertexAttrib2fv;

+PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;

+void APIENTRY glad_debug_impl_glVertexAttrib2s(GLuint arg0, GLshort arg1, GLshort arg2) {

+    _pre_call_callback("glVertexAttrib2s", (void*)glVertexAttrib2s, 3, arg0, arg1, arg2);

+     glad_glVertexAttrib2s(arg0, arg1, arg2);

+    _post_call_callback("glVertexAttrib2s", (void*)glVertexAttrib2s, 3, arg0, arg1, arg2);

+}

+PFNGLVERTEXATTRIB2SPROC glad_debug_glVertexAttrib2s = glad_debug_impl_glVertexAttrib2s;

+PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;

+void APIENTRY glad_debug_impl_glVertexAttrib2sv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttrib2sv", (void*)glVertexAttrib2sv, 2, arg0, arg1);

+     glad_glVertexAttrib2sv(arg0, arg1);

+    _post_call_callback("glVertexAttrib2sv", (void*)glVertexAttrib2sv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB2SVPROC glad_debug_glVertexAttrib2sv = glad_debug_impl_glVertexAttrib2sv;

+PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;

+void APIENTRY glad_debug_impl_glVertexAttrib3d(GLuint arg0, GLdouble arg1, GLdouble arg2, GLdouble arg3) {

+    _pre_call_callback("glVertexAttrib3d", (void*)glVertexAttrib3d, 4, arg0, arg1, arg2, arg3);

+     glad_glVertexAttrib3d(arg0, arg1, arg2, arg3);

+    _post_call_callback("glVertexAttrib3d", (void*)glVertexAttrib3d, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVERTEXATTRIB3DPROC glad_debug_glVertexAttrib3d = glad_debug_impl_glVertexAttrib3d;

+PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;

+void APIENTRY glad_debug_impl_glVertexAttrib3dv(GLuint arg0, const GLdouble * arg1) {

+    _pre_call_callback("glVertexAttrib3dv", (void*)glVertexAttrib3dv, 2, arg0, arg1);

+     glad_glVertexAttrib3dv(arg0, arg1);

+    _post_call_callback("glVertexAttrib3dv", (void*)glVertexAttrib3dv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB3DVPROC glad_debug_glVertexAttrib3dv = glad_debug_impl_glVertexAttrib3dv;

+PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;

+void APIENTRY glad_debug_impl_glVertexAttrib3f(GLuint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3) {

+    _pre_call_callback("glVertexAttrib3f", (void*)glVertexAttrib3f, 4, arg0, arg1, arg2, arg3);

+     glad_glVertexAttrib3f(arg0, arg1, arg2, arg3);

+    _post_call_callback("glVertexAttrib3f", (void*)glVertexAttrib3f, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVERTEXATTRIB3FPROC glad_debug_glVertexAttrib3f = glad_debug_impl_glVertexAttrib3f;

+PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;

+void APIENTRY glad_debug_impl_glVertexAttrib3fv(GLuint arg0, const GLfloat * arg1) {

+    _pre_call_callback("glVertexAttrib3fv", (void*)glVertexAttrib3fv, 2, arg0, arg1);

+     glad_glVertexAttrib3fv(arg0, arg1);

+    _post_call_callback("glVertexAttrib3fv", (void*)glVertexAttrib3fv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB3FVPROC glad_debug_glVertexAttrib3fv = glad_debug_impl_glVertexAttrib3fv;

+PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;

+void APIENTRY glad_debug_impl_glVertexAttrib3s(GLuint arg0, GLshort arg1, GLshort arg2, GLshort arg3) {

+    _pre_call_callback("glVertexAttrib3s", (void*)glVertexAttrib3s, 4, arg0, arg1, arg2, arg3);

+     glad_glVertexAttrib3s(arg0, arg1, arg2, arg3);

+    _post_call_callback("glVertexAttrib3s", (void*)glVertexAttrib3s, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVERTEXATTRIB3SPROC glad_debug_glVertexAttrib3s = glad_debug_impl_glVertexAttrib3s;

+PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;

+void APIENTRY glad_debug_impl_glVertexAttrib3sv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttrib3sv", (void*)glVertexAttrib3sv, 2, arg0, arg1);

+     glad_glVertexAttrib3sv(arg0, arg1);

+    _post_call_callback("glVertexAttrib3sv", (void*)glVertexAttrib3sv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB3SVPROC glad_debug_glVertexAttrib3sv = glad_debug_impl_glVertexAttrib3sv;

+PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nbv(GLuint arg0, const GLbyte * arg1) {

+    _pre_call_callback("glVertexAttrib4Nbv", (void*)glVertexAttrib4Nbv, 2, arg0, arg1);

+     glad_glVertexAttrib4Nbv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Nbv", (void*)glVertexAttrib4Nbv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NBVPROC glad_debug_glVertexAttrib4Nbv = glad_debug_impl_glVertexAttrib4Nbv;

+PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Niv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttrib4Niv", (void*)glVertexAttrib4Niv, 2, arg0, arg1);

+     glad_glVertexAttrib4Niv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Niv", (void*)glVertexAttrib4Niv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NIVPROC glad_debug_glVertexAttrib4Niv = glad_debug_impl_glVertexAttrib4Niv;

+PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nsv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttrib4Nsv", (void*)glVertexAttrib4Nsv, 2, arg0, arg1);

+     glad_glVertexAttrib4Nsv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Nsv", (void*)glVertexAttrib4Nsv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NSVPROC glad_debug_glVertexAttrib4Nsv = glad_debug_impl_glVertexAttrib4Nsv;

+PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nub(GLuint arg0, GLubyte arg1, GLubyte arg2, GLubyte arg3, GLubyte arg4) {

+    _pre_call_callback("glVertexAttrib4Nub", (void*)glVertexAttrib4Nub, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttrib4Nub(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttrib4Nub", (void*)glVertexAttrib4Nub, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIB4NUBPROC glad_debug_glVertexAttrib4Nub = glad_debug_impl_glVertexAttrib4Nub;

+PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nubv(GLuint arg0, const GLubyte * arg1) {

+    _pre_call_callback("glVertexAttrib4Nubv", (void*)glVertexAttrib4Nubv, 2, arg0, arg1);

+     glad_glVertexAttrib4Nubv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Nubv", (void*)glVertexAttrib4Nubv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NUBVPROC glad_debug_glVertexAttrib4Nubv = glad_debug_impl_glVertexAttrib4Nubv;

+PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nuiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttrib4Nuiv", (void*)glVertexAttrib4Nuiv, 2, arg0, arg1);

+     glad_glVertexAttrib4Nuiv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Nuiv", (void*)glVertexAttrib4Nuiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NUIVPROC glad_debug_glVertexAttrib4Nuiv = glad_debug_impl_glVertexAttrib4Nuiv;

+PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;

+void APIENTRY glad_debug_impl_glVertexAttrib4Nusv(GLuint arg0, const GLushort * arg1) {

+    _pre_call_callback("glVertexAttrib4Nusv", (void*)glVertexAttrib4Nusv, 2, arg0, arg1);

+     glad_glVertexAttrib4Nusv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4Nusv", (void*)glVertexAttrib4Nusv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4NUSVPROC glad_debug_glVertexAttrib4Nusv = glad_debug_impl_glVertexAttrib4Nusv;

+PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;

+void APIENTRY glad_debug_impl_glVertexAttrib4bv(GLuint arg0, const GLbyte * arg1) {

+    _pre_call_callback("glVertexAttrib4bv", (void*)glVertexAttrib4bv, 2, arg0, arg1);

+     glad_glVertexAttrib4bv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4bv", (void*)glVertexAttrib4bv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4BVPROC glad_debug_glVertexAttrib4bv = glad_debug_impl_glVertexAttrib4bv;

+PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;

+void APIENTRY glad_debug_impl_glVertexAttrib4d(GLuint arg0, GLdouble arg1, GLdouble arg2, GLdouble arg3, GLdouble arg4) {

+    _pre_call_callback("glVertexAttrib4d", (void*)glVertexAttrib4d, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttrib4d(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttrib4d", (void*)glVertexAttrib4d, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIB4DPROC glad_debug_glVertexAttrib4d = glad_debug_impl_glVertexAttrib4d;

+PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;

+void APIENTRY glad_debug_impl_glVertexAttrib4dv(GLuint arg0, const GLdouble * arg1) {

+    _pre_call_callback("glVertexAttrib4dv", (void*)glVertexAttrib4dv, 2, arg0, arg1);

+     glad_glVertexAttrib4dv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4dv", (void*)glVertexAttrib4dv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4DVPROC glad_debug_glVertexAttrib4dv = glad_debug_impl_glVertexAttrib4dv;

+PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;

+void APIENTRY glad_debug_impl_glVertexAttrib4f(GLuint arg0, GLfloat arg1, GLfloat arg2, GLfloat arg3, GLfloat arg4) {

+    _pre_call_callback("glVertexAttrib4f", (void*)glVertexAttrib4f, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttrib4f(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttrib4f", (void*)glVertexAttrib4f, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIB4FPROC glad_debug_glVertexAttrib4f = glad_debug_impl_glVertexAttrib4f;

+PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;

+void APIENTRY glad_debug_impl_glVertexAttrib4fv(GLuint arg0, const GLfloat * arg1) {

+    _pre_call_callback("glVertexAttrib4fv", (void*)glVertexAttrib4fv, 2, arg0, arg1);

+     glad_glVertexAttrib4fv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4fv", (void*)glVertexAttrib4fv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4FVPROC glad_debug_glVertexAttrib4fv = glad_debug_impl_glVertexAttrib4fv;

+PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;

+void APIENTRY glad_debug_impl_glVertexAttrib4iv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttrib4iv", (void*)glVertexAttrib4iv, 2, arg0, arg1);

+     glad_glVertexAttrib4iv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4iv", (void*)glVertexAttrib4iv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4IVPROC glad_debug_glVertexAttrib4iv = glad_debug_impl_glVertexAttrib4iv;

+PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;

+void APIENTRY glad_debug_impl_glVertexAttrib4s(GLuint arg0, GLshort arg1, GLshort arg2, GLshort arg3, GLshort arg4) {

+    _pre_call_callback("glVertexAttrib4s", (void*)glVertexAttrib4s, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttrib4s(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttrib4s", (void*)glVertexAttrib4s, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIB4SPROC glad_debug_glVertexAttrib4s = glad_debug_impl_glVertexAttrib4s;

+PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;

+void APIENTRY glad_debug_impl_glVertexAttrib4sv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttrib4sv", (void*)glVertexAttrib4sv, 2, arg0, arg1);

+     glad_glVertexAttrib4sv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4sv", (void*)glVertexAttrib4sv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4SVPROC glad_debug_glVertexAttrib4sv = glad_debug_impl_glVertexAttrib4sv;

+PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;

+void APIENTRY glad_debug_impl_glVertexAttrib4ubv(GLuint arg0, const GLubyte * arg1) {

+    _pre_call_callback("glVertexAttrib4ubv", (void*)glVertexAttrib4ubv, 2, arg0, arg1);

+     glad_glVertexAttrib4ubv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4ubv", (void*)glVertexAttrib4ubv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4UBVPROC glad_debug_glVertexAttrib4ubv = glad_debug_impl_glVertexAttrib4ubv;

+PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;

+void APIENTRY glad_debug_impl_glVertexAttrib4uiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttrib4uiv", (void*)glVertexAttrib4uiv, 2, arg0, arg1);

+     glad_glVertexAttrib4uiv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4uiv", (void*)glVertexAttrib4uiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4UIVPROC glad_debug_glVertexAttrib4uiv = glad_debug_impl_glVertexAttrib4uiv;

+PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;

+void APIENTRY glad_debug_impl_glVertexAttrib4usv(GLuint arg0, const GLushort * arg1) {

+    _pre_call_callback("glVertexAttrib4usv", (void*)glVertexAttrib4usv, 2, arg0, arg1);

+     glad_glVertexAttrib4usv(arg0, arg1);

+    _post_call_callback("glVertexAttrib4usv", (void*)glVertexAttrib4usv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIB4USVPROC glad_debug_glVertexAttrib4usv = glad_debug_impl_glVertexAttrib4usv;

+PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;

+void APIENTRY glad_debug_impl_glVertexAttribI1i(GLuint arg0, GLint arg1) {

+    _pre_call_callback("glVertexAttribI1i", (void*)glVertexAttribI1i, 2, arg0, arg1);

+     glad_glVertexAttribI1i(arg0, arg1);

+    _post_call_callback("glVertexAttribI1i", (void*)glVertexAttribI1i, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI1IPROC glad_debug_glVertexAttribI1i = glad_debug_impl_glVertexAttribI1i;

+PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;

+void APIENTRY glad_debug_impl_glVertexAttribI1iv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttribI1iv", (void*)glVertexAttribI1iv, 2, arg0, arg1);

+     glad_glVertexAttribI1iv(arg0, arg1);

+    _post_call_callback("glVertexAttribI1iv", (void*)glVertexAttribI1iv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI1IVPROC glad_debug_glVertexAttribI1iv = glad_debug_impl_glVertexAttribI1iv;

+PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;

+void APIENTRY glad_debug_impl_glVertexAttribI1ui(GLuint arg0, GLuint arg1) {

+    _pre_call_callback("glVertexAttribI1ui", (void*)glVertexAttribI1ui, 2, arg0, arg1);

+     glad_glVertexAttribI1ui(arg0, arg1);

+    _post_call_callback("glVertexAttribI1ui", (void*)glVertexAttribI1ui, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI1UIPROC glad_debug_glVertexAttribI1ui = glad_debug_impl_glVertexAttribI1ui;

+PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;

+void APIENTRY glad_debug_impl_glVertexAttribI1uiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttribI1uiv", (void*)glVertexAttribI1uiv, 2, arg0, arg1);

+     glad_glVertexAttribI1uiv(arg0, arg1);

+    _post_call_callback("glVertexAttribI1uiv", (void*)glVertexAttribI1uiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI1UIVPROC glad_debug_glVertexAttribI1uiv = glad_debug_impl_glVertexAttribI1uiv;

+PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;

+void APIENTRY glad_debug_impl_glVertexAttribI2i(GLuint arg0, GLint arg1, GLint arg2) {

+    _pre_call_callback("glVertexAttribI2i", (void*)glVertexAttribI2i, 3, arg0, arg1, arg2);

+     glad_glVertexAttribI2i(arg0, arg1, arg2);

+    _post_call_callback("glVertexAttribI2i", (void*)glVertexAttribI2i, 3, arg0, arg1, arg2);

+}

+PFNGLVERTEXATTRIBI2IPROC glad_debug_glVertexAttribI2i = glad_debug_impl_glVertexAttribI2i;

+PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;

+void APIENTRY glad_debug_impl_glVertexAttribI2iv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttribI2iv", (void*)glVertexAttribI2iv, 2, arg0, arg1);

+     glad_glVertexAttribI2iv(arg0, arg1);

+    _post_call_callback("glVertexAttribI2iv", (void*)glVertexAttribI2iv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI2IVPROC glad_debug_glVertexAttribI2iv = glad_debug_impl_glVertexAttribI2iv;

+PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;

+void APIENTRY glad_debug_impl_glVertexAttribI2ui(GLuint arg0, GLuint arg1, GLuint arg2) {

+    _pre_call_callback("glVertexAttribI2ui", (void*)glVertexAttribI2ui, 3, arg0, arg1, arg2);

+     glad_glVertexAttribI2ui(arg0, arg1, arg2);

+    _post_call_callback("glVertexAttribI2ui", (void*)glVertexAttribI2ui, 3, arg0, arg1, arg2);

+}

+PFNGLVERTEXATTRIBI2UIPROC glad_debug_glVertexAttribI2ui = glad_debug_impl_glVertexAttribI2ui;

+PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;

+void APIENTRY glad_debug_impl_glVertexAttribI2uiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttribI2uiv", (void*)glVertexAttribI2uiv, 2, arg0, arg1);

+     glad_glVertexAttribI2uiv(arg0, arg1);

+    _post_call_callback("glVertexAttribI2uiv", (void*)glVertexAttribI2uiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI2UIVPROC glad_debug_glVertexAttribI2uiv = glad_debug_impl_glVertexAttribI2uiv;

+PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;

+void APIENTRY glad_debug_impl_glVertexAttribI3i(GLuint arg0, GLint arg1, GLint arg2, GLint arg3) {

+    _pre_call_callback("glVertexAttribI3i", (void*)glVertexAttribI3i, 4, arg0, arg1, arg2, arg3);

+     glad_glVertexAttribI3i(arg0, arg1, arg2, arg3);

+    _post_call_callback("glVertexAttribI3i", (void*)glVertexAttribI3i, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVERTEXATTRIBI3IPROC glad_debug_glVertexAttribI3i = glad_debug_impl_glVertexAttribI3i;

+PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;

+void APIENTRY glad_debug_impl_glVertexAttribI3iv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttribI3iv", (void*)glVertexAttribI3iv, 2, arg0, arg1);

+     glad_glVertexAttribI3iv(arg0, arg1);

+    _post_call_callback("glVertexAttribI3iv", (void*)glVertexAttribI3iv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI3IVPROC glad_debug_glVertexAttribI3iv = glad_debug_impl_glVertexAttribI3iv;

+PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;

+void APIENTRY glad_debug_impl_glVertexAttribI3ui(GLuint arg0, GLuint arg1, GLuint arg2, GLuint arg3) {

+    _pre_call_callback("glVertexAttribI3ui", (void*)glVertexAttribI3ui, 4, arg0, arg1, arg2, arg3);

+     glad_glVertexAttribI3ui(arg0, arg1, arg2, arg3);

+    _post_call_callback("glVertexAttribI3ui", (void*)glVertexAttribI3ui, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVERTEXATTRIBI3UIPROC glad_debug_glVertexAttribI3ui = glad_debug_impl_glVertexAttribI3ui;

+PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;

+void APIENTRY glad_debug_impl_glVertexAttribI3uiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttribI3uiv", (void*)glVertexAttribI3uiv, 2, arg0, arg1);

+     glad_glVertexAttribI3uiv(arg0, arg1);

+    _post_call_callback("glVertexAttribI3uiv", (void*)glVertexAttribI3uiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI3UIVPROC glad_debug_glVertexAttribI3uiv = glad_debug_impl_glVertexAttribI3uiv;

+PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;

+void APIENTRY glad_debug_impl_glVertexAttribI4bv(GLuint arg0, const GLbyte * arg1) {

+    _pre_call_callback("glVertexAttribI4bv", (void*)glVertexAttribI4bv, 2, arg0, arg1);

+     glad_glVertexAttribI4bv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4bv", (void*)glVertexAttribI4bv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4BVPROC glad_debug_glVertexAttribI4bv = glad_debug_impl_glVertexAttribI4bv;

+PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;

+void APIENTRY glad_debug_impl_glVertexAttribI4i(GLuint arg0, GLint arg1, GLint arg2, GLint arg3, GLint arg4) {

+    _pre_call_callback("glVertexAttribI4i", (void*)glVertexAttribI4i, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttribI4i(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttribI4i", (void*)glVertexAttribI4i, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIBI4IPROC glad_debug_glVertexAttribI4i = glad_debug_impl_glVertexAttribI4i;

+PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;

+void APIENTRY glad_debug_impl_glVertexAttribI4iv(GLuint arg0, const GLint * arg1) {

+    _pre_call_callback("glVertexAttribI4iv", (void*)glVertexAttribI4iv, 2, arg0, arg1);

+     glad_glVertexAttribI4iv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4iv", (void*)glVertexAttribI4iv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4IVPROC glad_debug_glVertexAttribI4iv = glad_debug_impl_glVertexAttribI4iv;

+PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;

+void APIENTRY glad_debug_impl_glVertexAttribI4sv(GLuint arg0, const GLshort * arg1) {

+    _pre_call_callback("glVertexAttribI4sv", (void*)glVertexAttribI4sv, 2, arg0, arg1);

+     glad_glVertexAttribI4sv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4sv", (void*)glVertexAttribI4sv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4SVPROC glad_debug_glVertexAttribI4sv = glad_debug_impl_glVertexAttribI4sv;

+PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;

+void APIENTRY glad_debug_impl_glVertexAttribI4ubv(GLuint arg0, const GLubyte * arg1) {

+    _pre_call_callback("glVertexAttribI4ubv", (void*)glVertexAttribI4ubv, 2, arg0, arg1);

+     glad_glVertexAttribI4ubv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4ubv", (void*)glVertexAttribI4ubv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4UBVPROC glad_debug_glVertexAttribI4ubv = glad_debug_impl_glVertexAttribI4ubv;

+PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;

+void APIENTRY glad_debug_impl_glVertexAttribI4ui(GLuint arg0, GLuint arg1, GLuint arg2, GLuint arg3, GLuint arg4) {

+    _pre_call_callback("glVertexAttribI4ui", (void*)glVertexAttribI4ui, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttribI4ui(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttribI4ui", (void*)glVertexAttribI4ui, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIBI4UIPROC glad_debug_glVertexAttribI4ui = glad_debug_impl_glVertexAttribI4ui;

+PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;

+void APIENTRY glad_debug_impl_glVertexAttribI4uiv(GLuint arg0, const GLuint * arg1) {

+    _pre_call_callback("glVertexAttribI4uiv", (void*)glVertexAttribI4uiv, 2, arg0, arg1);

+     glad_glVertexAttribI4uiv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4uiv", (void*)glVertexAttribI4uiv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4UIVPROC glad_debug_glVertexAttribI4uiv = glad_debug_impl_glVertexAttribI4uiv;

+PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;

+void APIENTRY glad_debug_impl_glVertexAttribI4usv(GLuint arg0, const GLushort * arg1) {

+    _pre_call_callback("glVertexAttribI4usv", (void*)glVertexAttribI4usv, 2, arg0, arg1);

+     glad_glVertexAttribI4usv(arg0, arg1);

+    _post_call_callback("glVertexAttribI4usv", (void*)glVertexAttribI4usv, 2, arg0, arg1);

+}

+PFNGLVERTEXATTRIBI4USVPROC glad_debug_glVertexAttribI4usv = glad_debug_impl_glVertexAttribI4usv;

+PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;

+void APIENTRY glad_debug_impl_glVertexAttribIPointer(GLuint arg0, GLint arg1, GLenum arg2, GLsizei arg3, const void * arg4) {

+    _pre_call_callback("glVertexAttribIPointer", (void*)glVertexAttribIPointer, 5, arg0, arg1, arg2, arg3, arg4);

+     glad_glVertexAttribIPointer(arg0, arg1, arg2, arg3, arg4);

+    _post_call_callback("glVertexAttribIPointer", (void*)glVertexAttribIPointer, 5, arg0, arg1, arg2, arg3, arg4);

+}

+PFNGLVERTEXATTRIBIPOINTERPROC glad_debug_glVertexAttribIPointer = glad_debug_impl_glVertexAttribIPointer;

+PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;

+void APIENTRY glad_debug_impl_glVertexAttribPointer(GLuint arg0, GLint arg1, GLenum arg2, GLboolean arg3, GLsizei arg4, const void * arg5) {

+    _pre_call_callback("glVertexAttribPointer", (void*)glVertexAttribPointer, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+     glad_glVertexAttribPointer(arg0, arg1, arg2, arg3, arg4, arg5);

+    _post_call_callback("glVertexAttribPointer", (void*)glVertexAttribPointer, 6, arg0, arg1, arg2, arg3, arg4, arg5);

+}

+PFNGLVERTEXATTRIBPOINTERPROC glad_debug_glVertexAttribPointer = glad_debug_impl_glVertexAttribPointer;

+PFNGLVIEWPORTPROC glad_glViewport;

+void APIENTRY glad_debug_impl_glViewport(GLint arg0, GLint arg1, GLsizei arg2, GLsizei arg3) {

+    _pre_call_callback("glViewport", (void*)glViewport, 4, arg0, arg1, arg2, arg3);

+     glad_glViewport(arg0, arg1, arg2, arg3);

+    _post_call_callback("glViewport", (void*)glViewport, 4, arg0, arg1, arg2, arg3);

+}

+PFNGLVIEWPORTPROC glad_debug_glViewport = glad_debug_impl_glViewport;

+PFNGLWAITSYNCPROC glad_glWaitSync;

+void APIENTRY glad_debug_impl_glWaitSync(GLsync arg0, GLbitfield arg1, GLuint64 arg2) {

+    _pre_call_callback("glWaitSync", (void*)glWaitSync, 3, arg0, arg1, arg2);

+     glad_glWaitSync(arg0, arg1, arg2);

+    _post_call_callback("glWaitSync", (void*)glWaitSync, 3, arg0, arg1, arg2);

+}

+PFNGLWAITSYNCPROC glad_debug_glWaitSync = glad_debug_impl_glWaitSync;

 static void load_GL_VERSION_1_0(GLADloadproc load) {

 	if(!GLAD_GL_VERSION_1_0) return;

 	glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");

--- a/src/Attributes.h

+++ b/src/Attributes.h

@@ -1,5 +1,15 @@

 #pragma once

+/// Include file for portable usage of __attribute__

+#ifdef __MINGW32__

+#define ATTRIBUTE_FORMAT_PRINTF(stringIndex, firstToCheck) __attribute__((format(__MINGW_PRINTF_FORMAT, stringIndex, firstToCheck)))

+#elif defined(__GNUC__)

+#define ATTRIBUTE_FORMAT_PRINTF(stringIndex, firstToCheck) __attribute__((format(printf, stringIndex, firstToCheck)))

+#else

+#define ATTRIBUTE_FORMAT_PRINTF(stringIndex, firstToCheck)

+#endif

 #ifdef __GNUC__

 #define ATTRIBUTE_HOT __attribute__((hot))

--- a/src/Backends/Audio/SDL2.cpp

+++ b/src/Backends/Audio/SDL2.cpp

@@ -2,6 +2,7 @@

 #include <stddef.h>

 #include <stdio.h>

+#include <string>

 #include "SDL.h"

@@ -64,16 +65,18 @@

 BOOL AudioBackend_Init(void)

+	Backend_PrintInfo("Initializing SDL2 audio backend...");

 	if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)

-		Backend_ShowMessageBox("Fatal error (SDL2 audio backend)", "'SDL_InitSubSystem(SDL_INIT_AUDIO)' failed");

+		std::string errorMessage = std::string("'SDL_InitSubSystem(SDL_INIT_AUDIO)' failed: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (SDL2 audio backend)", errorMessage.c_str());

 		return FALSE;

-	puts("Available SDL2 audio drivers:");

+	Backend_PrintInfo("Available SDL audio drivers:");

 	for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i)

-		puts(SDL_GetAudioDriver(i));

+		Backend_PrintInfo("%s", SDL_GetAudioDriver(i));

 	SDL_AudioSpec specification;

 	specification.freq = 48000;

@@ -85,27 +88,31 @@

 	SDL_AudioSpec obtained_specification;

 	device_id = SDL_OpenAudioDevice(NULL, 0, &specification, &obtained_specification, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE);

-	output_frequency = obtained_specification.freq;

-	Mixer_Init(obtained_specification.freq);

 	if (device_id == 0)

-		Backend_ShowMessageBox("Fatal error (SDL2 audio backend)", "'SDL_OpenAudioDevice' failed");

+		std::string error_message = std::string("'SDL_OpenAudioDevice' failed: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (SDL2 audio backend)", error_message.c_str());

 		return FALSE;

+	output_frequency = obtained_specification.freq;

+	Mixer_Init(obtained_specification.freq);

 	SDL_PauseAudioDevice(device_id, 0);

-	printf("Selected SDL2 audio driver: %s\n", SDL_GetCurrentAudioDriver());

+	Backend_PrintInfo("Selected SDL audio driver: %s", SDL_GetCurrentAudioDriver());

+	Backend_PrintInfo("Succesfully initialized SDL2 audio backend");

 	return TRUE;

 void AudioBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing SDL2 audio backend...");

 	SDL_CloseAudioDevice(device_id);

 	SDL_QuitSubSystem(SDL_INIT_AUDIO);

+	Backend_PrintInfo("Finished de-initializing SDL2 audio backend");

 AudioBackend_Sound* AudioBackend_CreateSound(unsigned int frequency, const unsigned char *samples, size_t length)

--- a/src/Backends/Audio/miniaudio.cpp

+++ b/src/Backends/Audio/miniaudio.cpp

@@ -9,6 +9,7 @@

 #include "../../Organya.h"

 #include "../../WindowsWrapper.h"

+#include "../Misc.h"

 #include "SoftwareMixer.h"

@@ -72,6 +73,7 @@

 BOOL AudioBackend_Init(void)

+	Backend_PrintInfo("Initializing miniaudio audio backend...");

 	ma_device_config config = ma_device_config_init(ma_device_type_playback);

 	config.playback.pDeviceID = NULL;

 	config.playback.format = ma_format_f32;

@@ -80,42 +82,72 @@

 	config.dataCallback = Callback;

 	config.pUserData = NULL;

-	if (ma_device_init(NULL, &config, &device) == MA_SUCCESS)

+	ma_result return_value;

+	return_value = ma_device_init(NULL, &config, &device);

+	if (return_value == MA_SUCCESS)

-		if (ma_mutex_init(device.pContext, &mutex) == MA_SUCCESS)

+		return_value = ma_mutex_init(device.pContext, &mutex);

+		if (return_value == MA_SUCCESS)

-			if (ma_mutex_init(device.pContext, &organya_mutex) == MA_SUCCESS)

+			return_value = ma_mutex_init(device.pContext, &organya_mutex);

+			if (return_value == MA_SUCCESS)

-				if (ma_device_start(&device) == MA_SUCCESS)

+				return_value = ma_device_start(&device);

+				if (return_value == MA_SUCCESS)

 					output_frequency = device.sampleRate;

 					Mixer_Init(device.sampleRate);

+					Backend_PrintInfo("Successfully initialized miniaudio audio backend");

 					return TRUE;

+				else

+				{

+					Backend_PrintError("Failed to start playback device: %s", ma_result_description(return_value));

+				}

 				ma_mutex_uninit(&organya_mutex);

+			else

+			{

+				Backend_PrintError("Failed to create organya mutex: %s", ma_result_description(return_value));

+			}

 			ma_mutex_uninit(&mutex);

+		else

+		{

+			Backend_PrintError("Failed to create mutex: %s", ma_result_description(return_value));

+		}

 		ma_device_uninit(&device);

+	else

+	{

+		Backend_PrintError("Failed to initialize playback device: %s", ma_result_description(return_value));

+	}

 	return FALSE;

 void AudioBackend_Deinit(void)

-	ma_device_stop(&device);

+	Backend_PrintInfo("De-initializing miniaudio audio backend...");

+	ma_result return_value;

+	return_value = ma_device_stop(&device);

+	if (return_value != MA_SUCCESS)

+		Backend_PrintError("Failed to stop playback device: %s", ma_result_description(return_value));

 	ma_mutex_uninit(&organya_mutex);

 	ma_mutex_uninit(&mutex);

 	ma_device_uninit(&device);

+	Backend_PrintInfo("Finished de-initializing miniaudio audio backend...");

 AudioBackend_Sound* AudioBackend_CreateSound(unsigned int frequency, const unsigned char *samples, size_t length)

--- a/src/Backends/GLFW3/Controller.cpp

+++ b/src/Backends/GLFW3/Controller.cpp

@@ -8,6 +8,7 @@

 #include <GLFW/glfw3.h>

 #include "../../WindowsWrapper.h"

+#include "../Misc.h"

 #define DEADZONE (10000.0f / 32767.0f)

@@ -21,7 +22,7 @@

 	switch (event)

 		case GLFW_CONNECTED:

-			printf("Joystick #%d connected - %s\n", joystick_id, glfwGetJoystickName(joystick_id));

+			Backend_PrintInfo("Joystick #%d connected - %s", joystick_id, glfwGetJoystickName(joystick_id));

 			if (!joystick_connected)

@@ -44,8 +45,11 @@

 						// Set up neutral axes

 						axis_neutrals = (float*)malloc(sizeof(float) * total_axes);

-						for (int i = 0; i < total_axes; ++i)

-							axis_neutrals[i] = axes[i];

+						if (axis_neutrals != NULL)

+							for (int i = 0; i < total_axes; ++i)

+								axis_neutrals[i] = axes[i];

+						else

+							Backend_PrintError("Couldn't allocate memory for axis");

@@ -55,7 +59,7 @@

 		case GLFW_DISCONNECTED:

 			if (joystick_connected && joystick_id == connected_joystick_id)

-				printf("Joystick #%d disconnected\n", connected_joystick_id);

+				Backend_PrintInfo("Joystick #%d disconnected", connected_joystick_id);

 				joystick_connected = FALSE;

 				free(axis_neutrals);

@@ -67,6 +71,7 @@

 BOOL ControllerBackend_Init(void)

+	Backend_PrintInfo("Initializing GLFW controller backend...");

 	// Connect joysticks that are already plugged-in

 	for (int i = GLFW_JOYSTICK_1; i < GLFW_JOYSTICK_LAST; ++i)

 		if (glfwJoystickPresent(i) == GLFW_TRUE)

@@ -75,11 +80,13 @@

 	// Set-up the callback for future (dis)connections

 	glfwSetJoystickCallback(JoystickCallback);

+	Backend_PrintInfo("Sucessfully initialized GLFW controller backend");

 	return TRUE;

 void ControllerBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing GLFW controller backend...");

 	glfwSetJoystickCallback(NULL);

 	joystick_connected = FALSE;

@@ -87,6 +94,7 @@

 	free(axis_neutrals);

 	axis_neutrals = NULL;

+	Backend_PrintInfo("Finished de-initializing GLFW controller backend");

 BOOL ControllerBackend_GetJoystickStatus(JOYSTICK_STATUS *status)

--- a/src/Backends/GLFW3/Misc.cpp

+++ b/src/Backends/GLFW3/Misc.cpp

@@ -1,6 +1,7 @@

 #include "../Misc.h"

 #include <chrono>

+#include <stdarg.h>

 #include <stddef.h>

 #include <stdio.h>

 #include <stdlib.h>

@@ -17,6 +18,7 @@

 #include "../../Organya.h"

 #include "../../Profile.h"

 #include "../../Resource.h"

+#include "../../Attributes.h"

 #define DO_KEY(GLFW_KEY, BACKEND_KEY) \

 	case GLFW_KEY: \

@@ -150,10 +152,21 @@

 	LoadProfile(paths[0]);

+static void ErrorCallback(int code, const char *description)

+{

+	Backend_PrintError("GLFW error received (%d): %s", code, description);

+}

 BOOL Backend_Init(void)

+	Backend_PrintInfo("Initializing GLFW platform backend...");

+	glfwSetErrorCallback(ErrorCallback);

 	if (glfwInit() == GL_TRUE)

+	{

+		Backend_PrintInfo("Successfully initialized GLFW platform backend");

 		return TRUE;

+	}

 	Backend_ShowMessageBox("Fatal error", "Could not initialise GLFW3");

@@ -162,10 +175,12 @@

 void Backend_Deinit(void)

+	Backend_PrintInfo("De-initializing GLFW platform backend...");

 	if (cursor != NULL)

 		glfwDestroyCursor(cursor);

 	glfwTerminate();

+	Backend_PrintInfo("Finished de-initializing GLFW platform backend ");

 void Backend_PostWindowCreation(void)

@@ -288,6 +303,26 @@

 	// GLFW3 doesn't have a message box

 	printf("ShowMessageBox - '%s' - '%s'\n", title, message);

+}

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintError(const char *format, ...)

+{

+	va_list argumentList;

+	va_start(argumentList, format);

+	fputs("ERROR: ", stderr);

+	vfprintf(stderr, format, argumentList);

+	fputc('\n', stderr);

+	va_end(argumentList);

+}

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintInfo(const char *format, ...)

+{

+	va_list argumentList;

+	va_start(argumentList, format);

+	fputs("INFO: ", stdout);

+	vprintf(format, argumentList);

+	putchar('\n');

+	va_end(argumentList);

 unsigned long Backend_GetTicks(void)

--- a/src/Backends/GLFW3/Window-OpenGL3.cpp

+++ b/src/Backends/GLFW3/Window-OpenGL3.cpp

@@ -71,7 +71,7 @@

 				else

-					Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not load OpenGL functions");

+					Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not initialize OpenGL context");

 			#endif

--- a/src/Backends/Misc.h

+++ b/src/Backends/Misc.h

@@ -1,6 +1,7 @@

 #pragma once

 #include "../WindowsWrapper.h"

+#include "../Attributes.h"

 enum

@@ -96,5 +97,7 @@

 BOOL Backend_SystemTask(void);

 void Backend_GetKeyboardState(BOOL *keyboard_state);

 void Backend_ShowMessageBox(const char *title, const char *message);

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintError(const char *format, ...);

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintInfo(const char *format, ...);

 unsigned long Backend_GetTicks(void);

 void Backend_Delay(unsigned int ticks);

--- a/src/Backends/Rendering/OpenGL3.cpp

+++ b/src/Backends/Rendering/OpenGL3.cpp

@@ -252,7 +252,7 @@

 	(void)userParam;

 	if (severity != GL_DEBUG_SEVERITY_NOTIFICATION)

-		printf("OpenGL debug: %s\n", message);

+		Backend_PrintInfo("OpenGL debug: %s", message);

*/

 // ====================

@@ -289,7 +289,7 @@

 	glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &shader_status);

 	if (shader_status != GL_TRUE)

-		char buffer[0x200];

+		char buffer[0x400];

 		glGetShaderInfoLog(fragment_shader, sizeof(buffer), NULL, buffer);

 		Backend_ShowMessageBox("Fragment shader error", buffer);

 		return 0;

@@ -306,7 +306,7 @@

 	glGetProgramiv(program_id, GL_LINK_STATUS, &shader_status);

 	if (shader_status != GL_TRUE)

-		char buffer[0x200];

+		char buffer[0x400];

 		glGetProgramInfoLog(program_id, sizeof(buffer), NULL, buffer);

 		Backend_ShowMessageBox("Shader linker error", buffer);

 		return 0;

@@ -329,7 +329,16 @@

 		while (current_vertex_buffer_slot + slots_needed > local_vertex_buffer_size)

 			local_vertex_buffer_size <<= 1;

-		local_vertex_buffer = (VertexBufferSlot*)realloc(local_vertex_buffer, local_vertex_buffer_size * sizeof(VertexBufferSlot));

+		VertexBufferSlot *reallocResult = (VertexBufferSlot *)realloc(local_vertex_buffer, local_vertex_buffer_size * sizeof(VertexBufferSlot));

+		if (reallocResult != NULL)

+		{

+			local_vertex_buffer = reallocResult;

+		}

+		else

+		{

+			Backend_PrintError("Couldn't expand vertex buffer");

+			return NULL;

+		}

 	current_vertex_buffer_slot += slots_needed;

@@ -513,6 +522,60 @@

 	glDeleteTextures(1, &gl_texture_id);

+#ifndef USE_OPENGLES2

+static const char *GetOpenGLErrorCodeDescription(GLenum error_code)

+{

+	switch (error_code)

+	{

+		case GL_NO_ERROR:

+			return "No error";

+		case GL_INVALID_ENUM:

+			return "An unacceptable value was specified for enumerated argument";

+		case GL_INVALID_VALUE:

+			return "A numeric argument is out of range";

+		case GL_INVALID_OPERATION:

+			return "The specified operation is not allowed in the current state";

+		case GL_INVALID_FRAMEBUFFER_OPERATION:

+			return "The framebuffer object is not complete";

+		case GL_OUT_OF_MEMORY:

+			return "There is not enough memory left to execute the command";

+		/*

+		 * For some reason glad does not define these even though they are there in OpenGL 3.2

+		 */

+/*

+		case GL_STACK_UNDERFLOW:

+			return "An attempt has been made to perform an operation that would cause an internal stack to underflow";

+		case GL_STACK_OVERFLOW:

+			return "An attempt has been made to perform an operation that would cause an internal stack to overflow";

+*/

+		default:

+			return "Unknown error";

+	}

+}

+static void PostGLCallCallback(const char *name, void *function_pointer, int length_arguments, ...)

+{

+	(void)function_pointer;

+	(void)length_arguments;

+	GLenum error_code = glad_glGetError();	// Manually use glad_glGetError. Otherwise, glad_debug_glGetError would be called and we'd get infinite recursion into this function

+	if (error_code != GL_NO_ERROR)

+		Backend_PrintError("Error %d in %s: %s", error_code, name, GetOpenGLErrorCodeDescription(error_code));

+}

+#endif

 // ====================

 // Render-backend initialisation

 // ====================

@@ -519,14 +582,22 @@

 RenderBackend_Surface* RenderBackend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)

+#ifndef USE_OPENGLES2

+	Backend_PrintInfo("Initializing OpenGL3 rendering backend...");

+	glad_set_post_callback(PostGLCallCallback);

+#else

+	Backend_PrintInfo("Initializing OpenGLES2 rendering backend...");

+#endif

 	actual_screen_width = screen_width;

 	actual_screen_height = screen_height;

 	if (WindowBackend_OpenGL_CreateWindow(window_title, &actual_screen_width, &actual_screen_height, fullscreen))

-		printf("GL_VENDOR = %s\n", glGetString(GL_VENDOR));

-		printf("GL_RENDERER = %s\n", glGetString(GL_RENDERER));

-		printf("GL_VERSION = %s\n", glGetString(GL_VERSION));

+		Backend_PrintInfo("GL_VENDOR = %s", glGetString(GL_VENDOR));

+		Backend_PrintInfo("GL_RENDERER = %s", glGetString(GL_RENDERER));

+		Backend_PrintInfo("GL_VERSION = %s", glGetString(GL_VERSION));

+		Backend_PrintInfo("GL_SHADING_LANGUAGE_VERSION = %s", glGetString(GL_SHADING_LANGUAGE_VERSION));

 		// Set up blending (only used for font-rendering)

 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

@@ -600,6 +671,12 @@

 			config.delete_texture_callback = GlyphBatch_DestroyTexture;

 			spritebatch_init(&glyph_batcher, &config, NULL);

+#ifndef USE_OPENGLES2

+			Backend_PrintInfo("Successfully initialized OpenGL3 rendering backend");

+#else

+			Backend_PrintInfo("Successfully initialized OpenGLES2 rendering backend");

+#endif

 			return &framebuffer;

@@ -626,6 +703,11 @@

 void RenderBackend_Deinit(void)

+#ifndef USE_OPENGLES2

+	Backend_PrintInfo("De-initializing OpenGL3 rendering backend...");

+#else

+	Backend_PrintInfo("De-initializing OpenGLES2 rendering backend...");

+#endif

 	free(local_vertex_buffer);

 	spritebatch_term(&glyph_batcher);

@@ -642,6 +724,12 @@

 #endif

 	WindowBackend_OpenGL_DestroyWindow();

+#ifndef USE_OPENGLES2

+	Backend_PrintInfo("Finished de-initializing OpenGL3 rendering backend");

+#else

+	Backend_PrintInfo("Finished de-initializing OpenGLES2 rendering backend");

+#endif

 void RenderBackend_DrawScreen(void)

--- a/src/Backends/Rendering/SDLSurface.cpp

+++ b/src/Backends/Rendering/SDLSurface.cpp

@@ -3,6 +3,7 @@

 #include <stddef.h>

 #include <stdlib.h>

 #include <string.h>

+#include <string>

 #include "SDL.h"

@@ -46,26 +47,37 @@

 RenderBackend_Surface* RenderBackend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)

+	Backend_PrintInfo("Initializing SDLSurface rendering backend...");

 	window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screen_width, screen_height, 0);

 	if (window != NULL)

 		if (fullscreen)

-			SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);

+		{

+			if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN) < 0)

+				Backend_PrintError("Could not set window to fullscreen: %s", SDL_GetError());

+		}

 		window_sdlsurface = SDL_GetWindowSurface(window);

+		if (window_sdlsurface != NULL)

+		{

+			framebuffer.sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);

-		framebuffer.sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);

+			if (framebuffer.sdlsurface != NULL)

+			{

+				Backend_PostWindowCreation();

-		if (framebuffer.sdlsurface != NULL)

-		{

-			Backend_PostWindowCreation();

+				Backend_PrintInfo("Successfully initialized SDLSurface rendering backend");

+				return &framebuffer;

+			}

-			return &framebuffer;

+			std::string error_message = std::string("Could not create framebuffer surface: ") + SDL_GetError();

+			Backend_ShowMessageBox("Fatal error (SDLSurface rendering backend)", error_message.c_str());

 		else

-			Backend_ShowMessageBox("Fatal error (SDLSurface rendering backend)", "Could not create framebuffer surface");

+			std::string error_message = std::string("Could not get SDL surface of the window: ") + SDL_GetError();

+			Backend_ShowMessageBox("Fatal error (SDLSurface rendering backend)", error_message.c_str());

 		SDL_DestroyWindow(window);

@@ -72,7 +84,8 @@

 	else

-		Backend_ShowMessageBox("Fatal error (SDLSurface rendering backend)", "Could not create window");

+		std::string error_message = std::string("Could not create window: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (SDLSurface rendering backend)", error_message.c_str());

 	return NULL;

@@ -80,14 +93,19 @@

 void RenderBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing SDLSurface rendering backend...");

 	SDL_FreeSurface(framebuffer.sdlsurface);

 	SDL_DestroyWindow(window);

+	Backend_PrintInfo("Finished de-initializing SDLSurface rendering backend");

 void RenderBackend_DrawScreen(void)

-	SDL_BlitSurface(framebuffer.sdlsurface, NULL, window_sdlsurface, NULL);

-	SDL_UpdateWindowSurface(window);

+	if (SDL_BlitSurface(framebuffer.sdlsurface, NULL, window_sdlsurface, NULL) < 0)

+		Backend_PrintError("Couldn't blit framebuffer surface to window surface: %s", SDL_GetError());

+	if (SDL_UpdateWindowSurface(window) < 0)

+		Backend_PrintError("Couldn't put window surface on screen: %s", SDL_GetError());

 RenderBackend_Surface* RenderBackend_CreateSurface(unsigned int width, unsigned int height)

@@ -162,9 +180,12 @@

 	destination_rect.w = source_rect.w;

 	destination_rect.h = source_rect.h;

-	SDL_SetColorKey(source_surface->sdlsurface, colour_key ? SDL_TRUE : SDL_FALSE, SDL_MapRGB(source_surface->sdlsurface->format, 0, 0, 0)); // Assumes the colour key will always be #000000 (black)

+	// Assumes the colour key will always be #000000 (black)

+	if (SDL_SetColorKey(source_surface->sdlsurface, colour_key ? SDL_TRUE : SDL_FALSE, SDL_MapRGB(source_surface->sdlsurface->format, 0, 0, 0)) < 0)

+		Backend_PrintError("Couldn't set color key of surface: %s", SDL_GetError());

-	SDL_BlitSurface(source_surface->sdlsurface, &source_rect, destination_surface->sdlsurface, &destination_rect);

+	if (SDL_BlitSurface(source_surface->sdlsurface, &source_rect, destination_surface->sdlsurface, &destination_rect) < 0)

+		Backend_PrintError("Couldn't blit surface: %s", SDL_GetError());

 void RenderBackend_ColourFill(RenderBackend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)

@@ -175,7 +196,8 @@

 	SDL_Rect destination_rect;

 	RectToSDLRect(rect, &destination_rect);

-	SDL_FillRect(surface->sdlsurface, &destination_rect, SDL_MapRGB(surface->sdlsurface->format, red, green, blue));

+	if (SDL_FillRect(surface->sdlsurface, &destination_rect, SDL_MapRGB(surface->sdlsurface->format, red, green, blue)) < 0)

+		Backend_PrintError("Couldn't fill rectangle with color: %s", SDL_GetError());

 RenderBackend_Glyph* RenderBackend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)

@@ -189,6 +211,7 @@

 	if (glyph->sdlsurface == NULL)

+		Backend_PrintError("Couldn't create RBG surface: %s", SDL_GetError());

 		free(glyph);

 		return NULL;

@@ -240,9 +263,11 @@

 	rect.w = glyph->sdlsurface->w;

 	rect.h = glyph->sdlsurface->h;

-	SDL_SetSurfaceColorMod(glyph->sdlsurface, glyph_colour_channels[0], glyph_colour_channels[1], glyph_colour_channels[2]);

+	if (SDL_SetSurfaceColorMod(glyph->sdlsurface, glyph_colour_channels[0], glyph_colour_channels[1], glyph_colour_channels[2]) < 0)

+		Backend_PrintError("Couldn't set color value: %s", SDL_GetError());

-	SDL_BlitSurface(glyph->sdlsurface, NULL, glyph_destination_sdlsurface, &rect);

+	if (SDL_BlitSurface(glyph->sdlsurface, NULL, glyph_destination_sdlsurface, &rect) < 0)

+		Backend_PrintError("Couldn't blit glyph indivual surface to final glyph surface: %s", SDL_GetError());

 void RenderBackend_FlushGlyphs(void)

@@ -263,4 +288,7 @@

 	// https://wiki.libsdl.org/SDL_GetWindowSurface

 	// We need to fetch a new surface pointer

 	window_sdlsurface = SDL_GetWindowSurface(window);

+	if (window_sdlsurface == NULL)

+		Backend_PrintError("Couldn't get SDL surface for window after resize: %s", SDL_GetError());

--- a/src/Backends/Rendering/SDLTexture.cpp

+++ b/src/Backends/Rendering/SDLTexture.cpp

@@ -4,6 +4,7 @@

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

+#include <string>

 #include "SDL.h"

@@ -73,9 +74,12 @@

 	// The SDL_Texture side of things uses alpha, not a colour-key, so the bug where the font is blended

 	// with the colour key doesn't occur.

-	SDL_SetTextureColorMod(texture_atlas, glyph_colour_channels[0], glyph_colour_channels[1], glyph_colour_channels[2]);

-	SDL_SetTextureBlendMode(texture_atlas, SDL_BLENDMODE_BLEND);

+	if (SDL_SetTextureColorMod(texture_atlas, glyph_colour_channels[0], glyph_colour_channels[1], glyph_colour_channels[2]) < 0)

+		Backend_PrintError("Couldn't set additional color value: %s", SDL_GetError());

+	if (SDL_SetTextureBlendMode(texture_atlas, SDL_BLENDMODE_BLEND) < 0)

+		Backend_PrintError("Couldn't set texture blend mode: %s", SDL_GetError());

 	for (int i = 0; i < count; ++i)

 		RenderBackend_Glyph *glyph = (RenderBackend_Glyph*)sprites[i].image_id;

@@ -83,7 +87,8 @@

 		SDL_Rect source_rect = {(int)(texture_w * sprites[i].minx), (int)(texture_h * sprites[i].maxy), (int)glyph->width, (int)glyph->height};

 		SDL_Rect destination_rect = {(int)sprites[i].x, (int)sprites[i].y, (int)glyph->width, (int)glyph->height};

-		SDL_RenderCopy(renderer, texture_atlas, &source_rect, &destination_rect);

+		if (SDL_RenderCopy(renderer, texture_atlas, &source_rect, &destination_rect) < 0)

+			Backend_PrintError("Couldn't copy glyph texture portion to renderer: %s", SDL_GetError());

@@ -104,8 +109,12 @@

 	SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STATIC, w, h);

-	SDL_UpdateTexture(texture, NULL, pixels, w * 4);

+	if (texture == NULL)

+		Backend_PrintError("Couldn't create texture for renderer: %s", SDL_GetError());

+	if (SDL_UpdateTexture(texture, NULL, pixels, w * 4) < 0)

+		Backend_PrintError("Couldn't update texture: %s", SDL_GetError());

 	return (SPRITEBATCH_U64)texture;

@@ -119,13 +128,16 @@

 RenderBackend_Surface* RenderBackend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)

-	puts("Available SDL2 render drivers:");

+	Backend_PrintInfo("Initializing SDLTexture rendering backend...");

+	Backend_PrintInfo("Available SDL render drivers:");

 	for (int i = 0; i < SDL_GetNumRenderDrivers(); ++i)

 		SDL_RendererInfo info;

-		SDL_GetRenderDriverInfo(i, &info);

-		puts(info.name);

+		if (SDL_GetRenderDriverInfo(i, &info) < 0)

+			Backend_PrintError("Couldn't get render driver information: %s", SDL_GetError());

+		else

+			Backend_PrintInfo("%s", info.name);

 	window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, screen_width, screen_height, 0);

@@ -133,7 +145,10 @@

 	if (window != NULL)

 		if (fullscreen)

-			SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);

+		{

+			if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN) < 0)

+				Backend_PrintError("Couldn't set window to fullscreen: %s", SDL_GetError());

+		}

 	#if SDL_VERSION_ATLEAST(2,0,10)

 		SDL_SetHint(SDL_HINT_RENDER_BATCHING, "1");	// We never interfere with the renderer, so don't let SDL implicitly disable batching

@@ -144,8 +159,10 @@

 		if (renderer != NULL)

 			SDL_RendererInfo info;

-			SDL_GetRendererInfo(renderer, &info);

-			printf("Selected SDL2 render driver: %s\n", info.name);

+			if (SDL_GetRendererInfo(renderer, &info) < 0)

+				Backend_PrintError("Couldn't get selected render driver information: %s", SDL_GetError());

+			else

+				Backend_PrintInfo("Selected SDL render driver: %s", info.name);

 			framebuffer.texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, screen_width, screen_height);

@@ -165,15 +182,22 @@

 				config.get_pixels_callback = GlyphBatch_GetPixels;

 				config.generate_texture_callback = GlyphBatch_CreateTexture;

 				config.delete_texture_callback = GlyphBatch_DestroyTexture;

-				spritebatch_init(&glyph_batcher, &config, NULL);

+				if (spritebatch_init(&glyph_batcher, &config, NULL) == 0)

+				{

+					Backend_PostWindowCreation();

-				Backend_PostWindowCreation();

-				return &framebuffer;

+					Backend_PrintInfo("Successfully initialized SDLTexture rendering backend");

+					return &framebuffer;

+				}

+				else

+				{

+					Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", "Failed to initialize spritebatch");

+				}

 			else

-				Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", "Could not create framebuffer");

+				std::string error_message = std::string("Could not create framebuffer: ") + SDL_GetError();

+				Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", error_message.c_str());

 			SDL_DestroyRenderer(renderer);

@@ -180,7 +204,8 @@

 		else

-			Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", "Could not create renderer");

+			std::string error_message = std::string("Could not create renderer: ") + SDL_GetError();

+			Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", error_message.c_str());

@@ -188,7 +213,8 @@

 	else

-		Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", "Could not create window");

+		std::string error_message = std::string("Could not create window: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (SDLTexture rendering backend)", error_message.c_str());

 	return NULL;

@@ -196,10 +222,12 @@

 void RenderBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing SDLTexture rendering backend...");

 	spritebatch_term(&glyph_batcher);

 	SDL_DestroyTexture(framebuffer.texture);

 	SDL_DestroyRenderer(renderer);

 	SDL_DestroyWindow(window);

+	Backend_PrintInfo("Finished de-initializing SDLTexture rendering backend...");

 void RenderBackend_DrawScreen(void)

@@ -206,8 +234,12 @@

 	spritebatch_tick(&glyph_batcher);

-	SDL_SetRenderTarget(renderer, NULL);

-	SDL_RenderCopy(renderer, framebuffer.texture, NULL, NULL);

+	if (SDL_SetRenderTarget(renderer, NULL) < 0)

+		Backend_PrintError("Couldn't set default render target as the current rendering target: %s", SDL_GetError());

+	if (SDL_RenderCopy(renderer, framebuffer.texture, NULL, NULL) < 0)

+		Backend_PrintError("Failed to copy framebuffer texture to default render target: %s", SDL_GetError());

 	SDL_RenderPresent(renderer);

@@ -284,6 +316,13 @@

 		return;

 	unsigned char *buffer = (unsigned char*)malloc(width * height * 4);

+	if (buffer == NULL)

+	{

+		Backend_PrintError("Couldn't allocate memory for surface buffer: %s", SDL_GetError());

+		return;

+	}

 	const unsigned char *src_pixel = surface->pixels;

 	// Convert the SDL_Surface's colour-keyed pixels to RGBA32

@@ -309,7 +348,8 @@

 	free(surface->pixels);

 	SDL_Rect rect = {0, 0, (int)width, (int)height};

-	SDL_UpdateTexture(surface->texture, &rect, buffer, width * 4);

+	if (SDL_UpdateTexture(surface->texture, &rect, buffer, width * 4) < 0)

+		Backend_PrintError("Couldn't update part of texture: %s", SDL_GetError());

 	free(buffer);

@@ -325,9 +365,14 @@

 	SDL_Rect destination_rect = {(int)x, (int)y, source_rect.w, source_rect.h};

 	// Blit the texture

-	SDL_SetTextureBlendMode(source_surface->texture, colour_key ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE);

-	SDL_SetRenderTarget(renderer, destination_surface->texture);

-	SDL_RenderCopy(renderer, source_surface->texture, &source_rect, &destination_rect);

+	if (SDL_SetTextureBlendMode(source_surface->texture, colour_key ? SDL_BLENDMODE_BLEND : SDL_BLENDMODE_NONE) < 0)

+		Backend_PrintError("Couldn't set texture blend mode: %s", SDL_GetError());

+	if (SDL_SetRenderTarget(renderer, destination_surface->texture) < 0)

+		Backend_PrintError("Couldn't set current rendering target: %s", SDL_GetError());

+	if (SDL_RenderCopy(renderer, source_surface->texture, &source_rect, &destination_rect) < 0)

+		Backend_PrintError("Couldn't copy part of texture to rendering target: %s", SDL_GetError());

 void RenderBackend_ColourFill(RenderBackend_Surface *surface, const RECT *rect, unsigned char red, unsigned char green, unsigned char blue)

@@ -338,17 +383,27 @@

 	SDL_Rect sdl_rect;

 	RectToSDLRect(rect, &sdl_rect);

+	Uint8 alpha = SDL_ALPHA_OPAQUE;

 	// Check colour-key

 	if (red == 0 && green == 0 && blue == 0)

-		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);

-	else

-		SDL_SetRenderDrawColor(renderer, red, green, blue, SDL_ALPHA_OPAQUE);

+		alpha = 0;

+	if (SDL_SetRenderDrawColor(renderer, red, green, blue, alpha) < 0)

+		Backend_PrintError("Couldn't set color for drawing operations: %s", SDL_GetError());

 	// Draw colour

-	SDL_SetRenderTarget(renderer, surface->texture);

-	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);

-	SDL_RenderFillRect(renderer, &sdl_rect);

-	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);

+	if (SDL_SetRenderTarget(renderer, surface->texture) < 0)

+		Backend_PrintError("Couldn't set texture current rendering target: %s", SDL_GetError());

+	if (SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE) < 0)

+		Backend_PrintError("Couldn't disable blending for drawing operations: %s", SDL_GetError());

+	if (SDL_RenderFillRect(renderer, &sdl_rect) < 0)

+		Backend_PrintError("Couldn't fill rectangle on current rendering target: %s", SDL_GetError());

+	if (SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND) < 0)

+		Backend_PrintError("Couldn't enable alpha blending for drawing operations: %s", SDL_GetError());

 RenderBackend_Glyph* RenderBackend_LoadGlyph(const unsigned char *pixels, unsigned int width, unsigned int height, int pitch)

@@ -401,7 +456,8 @@

 	if (destination_surface == NULL)

 		return;

-	SDL_SetRenderTarget(renderer, destination_surface->texture);

+	if (SDL_SetRenderTarget(renderer, destination_surface->texture) < 0)

+		Backend_PrintError("Couldn't set texture as current rendering target: %s", SDL_GetError());

 	memcpy(glyph_colour_channels, colour_channels, sizeof(glyph_colour_channels));

@@ -408,12 +464,15 @@

 void RenderBackend_DrawGlyph(RenderBackend_Glyph *glyph, long x, long y)

-	spritebatch_push(&glyph_batcher, (SPRITEBATCH_U64)glyph, glyph->width, glyph->height, x, y, 1.0f, 1.0f, 0.0f, 0.0f, 0);

+	if (spritebatch_push(&glyph_batcher, (SPRITEBATCH_U64)glyph, glyph->width, glyph->height, x, y, 1.0f, 1.0f, 0.0f, 0.0f, 0) != 1)

+		Backend_PrintError("Failed to push glyph to batcher");

 void RenderBackend_FlushGlyphs(void)

-	spritebatch_defrag(&glyph_batcher);

+	if (spritebatch_defrag(&glyph_batcher) != 1)

+		Backend_PrintError("Couldn't defrag textures");

 	spritebatch_flush(&glyph_batcher);

--- a/src/Backends/Rendering/Software.cpp

+++ b/src/Backends/Rendering/Software.cpp

@@ -35,6 +35,7 @@

 RenderBackend_Surface* RenderBackend_Init(const char *window_title, int screen_width, int screen_height, BOOL fullscreen)

+	Backend_PrintInfo("Initializing Software rendering backend...");

 	size_t pitch;

 	framebuffer.pixels = WindowBackend_Software_CreateWindow(window_title, screen_width, screen_height, fullscreen, &pitch);

 	framebuffer.width = screen_width;

@@ -41,12 +42,22 @@

 	framebuffer.height = screen_height;

 	framebuffer.pitch = pitch;

-	return &framebuffer;

+	if (framebuffer.pixels)

+	{

+		Backend_PrintInfo("Successfully initialized Software rendering backend");

+		return &framebuffer;

+	}

+	else

+	{

+		Backend_PrintError("Failed to create window");

+	}

 void RenderBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing Software rendering backend...");

 	WindowBackend_Software_DestroyWindow();

+	Backend_PrintInfo("Finished de-initializing Software rendering backend");

 void RenderBackend_DrawScreen(void)

--- a/src/Backends/SDL2/Controller.cpp

+++ b/src/Backends/SDL2/Controller.cpp

@@ -7,8 +7,9 @@

 #include "SDL.h"

 #include "../../WindowsWrapper.h"

+#include "../Misc.h"

-#define DEADZONE 10000;

+#define DEADZONE 10000

 static SDL_Joystick *joystick;

@@ -16,13 +17,20 @@

 BOOL ControllerBackend_Init(void)

-	SDL_InitSubSystem(SDL_INIT_JOYSTICK);

+	Backend_PrintInfo("Initializing SDL2 controller backend...");

+	if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0)

+	{

+		Backend_PrintError("Couldn't initialise joystick SDL subsystem: %s", SDL_GetError());

+		return FALSE;

+	}

+	Backend_PrintInfo("Successfully initialized SDL2 controller backend");

 	return TRUE;

 void ControllerBackend_Deinit(void)

+	Backend_PrintInfo("De-initializing SDL2 controller backend...");

 	if (joystick != NULL)

 		SDL_JoystickClose(joystick);

@@ -30,6 +38,7 @@

 	SDL_QuitSubSystem(SDL_INIT_JOYSTICK);

+	Backend_PrintInfo("Finished de-initializing SDL2 controller backend");

 BOOL ControllerBackend_GetJoystickStatus(JOYSTICK_STATUS *status)

@@ -41,7 +50,12 @@

 	// Handle directional inputs

 	const Sint16 joystick_x = SDL_JoystickGetAxis(joystick, 0);

+	if (joystick_x == 0)

+		Backend_PrintError("Failed to get current state of X axis control on joystick: %s", SDL_GetError());

 	const Sint16 joystick_y = SDL_JoystickGetAxis(joystick, 1);

+	if (joystick_y == 0)

+		Backend_PrintError("Failed to get current state of Y axis control on joystick: %s", SDL_GetError());

 	status->bLeft = joystick_x < axis_neutrals[0] - DEADZONE;

 	status->bRight = joystick_x > axis_neutrals[0] + DEADZONE;

@@ -50,8 +64,16 @@

 	// Handle button inputs

 	int total_buttons = SDL_JoystickNumButtons(joystick);

+	if (total_buttons < 0)

+		Backend_PrintError("Failed to get number of buttons on joystick: %s", SDL_GetError());

 	int total_axes = SDL_JoystickNumAxes(joystick);

+	if (total_axes < 0)

+		Backend_PrintError("Failed to get number of general axis controls on joystick: %s", SDL_GetError());

 	int total_hats = SDL_JoystickNumHats(joystick);

+	if (total_hats < 0)

+		Backend_PrintError("Failed to get number of POV hats on joystick: %s", SDL_GetError());

 	unsigned int buttons_done = 0;

@@ -123,7 +145,16 @@

 void ControllerBackend_JoystickConnect(Sint32 joystick_id)

-	printf("Joystick #%d connected - %s\n", joystick_id, SDL_JoystickNameForIndex(joystick_id));

+	const char *joystick_name = SDL_JoystickNameForIndex(joystick_id);

+	if (joystick_name != NULL)

+	{

+		Backend_PrintInfo("Joystick #%d connected - %s", joystick_id, joystick_name);

+	}

+	else

+	{

+		Backend_PrintError("Couldn't get joystick name: %s", SDL_GetError());

+		Backend_PrintInfo("Joystick #%d connected - Name unknown", joystick_id);

+	}

 	if (joystick == NULL)

@@ -132,17 +163,24 @@

 		if (joystick != NULL)

 			int total_axes = SDL_JoystickNumAxes(joystick);

+			if (total_axes < 0)

+				Backend_PrintError("Couldn't get number of general axis control on connected joystick: %s", SDL_GetError());

 			int total_buttons = SDL_JoystickNumButtons(joystick);

+			if (total_buttons < 0)

+				Backend_PrintError("Couldn't get number of buttons on connected joystick: %s", SDL_GetError());

 			if (total_axes >= 2 && total_buttons >= 6)

-				printf("Joystick #%d selected\n", joystick_id);

+				Backend_PrintInfo("Joystick #%d selected", joystick_id);

 				// Set up neutral axes

 				axis_neutrals = (Sint16*)malloc(sizeof(Sint16) * total_axes);

-				for (int i = 0; i < total_axes; ++i)

-					axis_neutrals[i] = SDL_JoystickGetAxis(joystick, i);

+				if (axis_neutrals != NULL)

+					for (int i = 0; i < total_axes; ++i)

+						axis_neutrals[i] = SDL_JoystickGetAxis(joystick, i);

+				else

+					Backend_PrintError("Couldn't allocate memory for neutral axes");

 			else

@@ -150,14 +188,22 @@

 				joystick = NULL;

+		else

+		{

+			Backend_PrintError("Couldn't open joystick for use: %s", SDL_GetError());

+		}

 void ControllerBackend_JoystickDisconnect(Sint32 joystick_id)

-	if (joystick_id == SDL_JoystickInstanceID(joystick))

+	SDL_JoystickID current_joystick_id = SDL_JoystickInstanceID(joystick);

+	if (current_joystick_id < 0)

+		Backend_PrintError("Couldn't get instance ID for current joystick: %s", SDL_GetError());

+	if (joystick_id == current_joystick_id)

-		printf("Joystick #%d disconnected\n", joystick_id);

+		Backend_PrintInfo("Joystick #%d disconnected", joystick_id);

 		SDL_JoystickClose(joystick);

 		joystick = NULL;

--- a/src/Backends/SDL2/Misc.cpp

+++ b/src/Backends/SDL2/Misc.cpp

@@ -4,6 +4,7 @@

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

+#include <string>

 #include "SDL.h"

@@ -32,29 +33,36 @@

 BOOL Backend_Init(void)

+	Backend_PrintInfo("Initializing SDL2 platform backend...");

 	if (SDL_Init(SDL_INIT_EVENTS) == 0)

 		if (SDL_InitSubSystem(SDL_INIT_VIDEO) == 0)

-			puts("Available SDL2 video drivers:");

+			Backend_PrintInfo("Available SDL video drivers:");

 			for (int i = 0; i < SDL_GetNumVideoDrivers(); ++i)

-				puts(SDL_GetVideoDriver(i));

+				Backend_PrintInfo("%s", SDL_GetVideoDriver(i));

 			const char *driver = SDL_GetCurrentVideoDriver();

 			if (driver != NULL)

-				printf("Selected SDL2 video driver: %s\n", driver);

+				Backend_PrintInfo("Selected SDL video driver: %s", driver);

+			else

+				Backend_PrintError("No SDL video driver initialized !");

+			Backend_PrintInfo("Successfully initialized SDL2 platform backend");

 			return TRUE;

-		Backend_ShowMessageBox("Fatal error", "Could not initialise SDL2 video subsystem");

+		std::string error_message = std::string("Could not initialise SDL video subsystem: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error", error_message.c_str());

 		SDL_Quit();

+		return FALSE;

-	Backend_ShowMessageBox("Fatal error", "Could not initialise SDL2");

+	std::string error_message = std::string("Could not initialise SDL: ") + SDL_GetError();

+	Backend_ShowMessageBox("Fatal error", error_message.c_str());

 	return FALSE;

@@ -61,6 +69,7 @@

 void Backend_Deinit(void)

+	Backend_PrintInfo("De-initializing SDL2 platform backend...");

 	if (cursor != NULL)

 		SDL_FreeCursor(cursor);

@@ -70,6 +79,7 @@

 	free(cursor_surface_pixels);

 	SDL_Quit();

+	Backend_PrintInfo("Finished de-initializing SDL2 platform backend...");

 void Backend_PostWindowCreation(void)

@@ -80,6 +90,9 @@

 BOOL Backend_GetBasePath(char *string_buffer)

 	char *base_path = SDL_GetBasePath();

+	if (base_path == NULL)

+		return FALSE;

 	// Trim the trailing '/'

 	size_t base_path_length = strlen(base_path);

 	base_path[base_path_length - 1] = '\0';

@@ -103,6 +116,10 @@

 		SDL_SetWindowIcon(window, surface);

 		SDL_FreeSurface(surface);

+	else

+	{

+		Backend_PrintError("Couldn't create RGB surface for window icon: %s", SDL_GetError());

+	}

 void Backend_SetCursor(const unsigned char *rgb_pixels, unsigned int width, unsigned int height)

@@ -126,6 +143,10 @@

+	else

+	{

+		Backend_PrintError("Failed to allocate memory for cursor surface");

+	}

 void PlaybackBackend_EnableDragAndDrop(void)

@@ -283,8 +304,29 @@

 void Backend_ShowMessageBox(const char *title, const char *message)

-	printf("ShowMessageBox - '%s' - '%s'\n", title, message);

-	SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title, message, window);

+	fprintf(stderr, "ShowMessageBox - '%s' - '%s'\n", title, message);

+	if (SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, title, message, window) != 0)

+		Backend_PrintError("Was also unable to display a message box containing the error: %s", SDL_GetError());

+}

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintError(const char *format, ...)

+{

+	va_list argumentList;

+	va_start(argumentList, format);

+	fputs("ERROR: ", stderr);

+	vfprintf(stderr, format, argumentList);

+	fputc('\n', stderr);

+	va_end(argumentList);

+}

+ATTRIBUTE_FORMAT_PRINTF(1, 2) void Backend_PrintInfo(const char *format, ...)

+{

+	va_list argumentList;

+	va_start(argumentList, format);

+	fputs("INFO: ", stdout);

+	vprintf(format, argumentList);

+	putchar('\n');

+	va_end(argumentList);

 unsigned long Backend_GetTicks(void)

--- a/src/Backends/SDL2/Window-OpenGL3.cpp

+++ b/src/Backends/SDL2/Window-OpenGL3.cpp

@@ -2,6 +2,7 @@

 #include "Window.h"

 #include <stddef.h>

+#include <string>

 #ifdef USE_OPENGLES2

 #include <GLES2/gl2.h>

@@ -22,15 +23,29 @@

 BOOL WindowBackend_OpenGL_CreateWindow(const char *window_title, int *screen_width, int *screen_height, BOOL fullscreen)

 #ifdef USE_OPENGLES2

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES) < 0)

+		Backend_PrintError("Couldn't set OpenGL context type to ES: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0) < 0)

+		Backend_PrintError("Couldn't set OpenGL context flags to 0: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2) < 0)

+		Backend_PrintError("Couldn't set OpenGL major version to 2: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0) < 0)

+		Backend_PrintError("Couldn't set OpenGL minor version to 0: %s", SDL_GetError());

 #else

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);

-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE) < 0)

+		Backend_PrintError("Couldn't set OpenGL context type to core: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG) < 0)

+		Backend_PrintError("Couldn't set OpenGL forward compatibility: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3) < 0)

+		Backend_PrintError("Couldn't set OpenGL major version to 3: %s", SDL_GetError());

+	if (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2) < 0)

+		Backend_PrintError("Couldn't set OpenGL minor verison to 2: %s", SDL_GetError());

 #endif

 	window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, *screen_width, *screen_height, SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | (fullscreen ? SDL_WINDOW_FULLSCREEN : 0));

@@ -62,12 +77,13 @@

 				else

-					Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not load OpenGL functions");

+					Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Couldn't load OpenGL functions");

 			#endif

 			else

+				std::string error_message = std::string("Couldn't setup OpenGL context for rendering: ") + SDL_GetError();

 				Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "SDL_GL_MakeCurrent failed");

@@ -75,6 +91,7 @@

 		else

+			std::string error_message = std::string("Couldn't create OpenGL context: %s", SDL_GetError());

 			Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not create OpenGL context");

@@ -82,7 +99,8 @@

 	else

-		Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", "Could not create window");

+		std::string error_message = std::string("Could not create window: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (OpenGL rendering backend)", error_message.c_str());

 	return FALSE;

--- a/src/Backends/SDL2/Window-Software.cpp

+++ b/src/Backends/SDL2/Window-Software.cpp

@@ -3,6 +3,7 @@

 #include <stddef.h>

 #include <stdlib.h>

+#include <string>

 #include "SDL.h"

@@ -22,30 +23,41 @@

 	if (window != NULL)

 		if (fullscreen)

-			SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);

+			if (SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN) < 0)

+				Backend_PrintError("Couldn't set window to fullscree: %s", SDL_GetError());

 		window_sdlsurface = SDL_GetWindowSurface(window);

-		framebuffer_sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);

-		if (framebuffer_sdlsurface != NULL)

+		if (window_sdlsurface != NULL)

-			*pitch = framebuffer_sdlsurface->pitch;

-			Backend_PostWindowCreation();

+			framebuffer_sdlsurface = SDL_CreateRGBSurfaceWithFormat(0, window_sdlsurface->w, window_sdlsurface->h, 0, SDL_PIXELFORMAT_RGB24);

-			return (unsigned char*)framebuffer_sdlsurface->pixels;

+			if (framebuffer_sdlsurface != NULL)

+			{

+				*pitch = framebuffer_sdlsurface->pitch;

+				Backend_PostWindowCreation();

+				return (unsigned char*)framebuffer_sdlsurface->pixels;

+			}

+			else

+			{

+				std::string error_message = std::string("Couldn't create framebuffer surface: ") + SDL_GetError();

+				Backend_ShowMessageBox("Fatal error (software rendering backend)", error_message.c_str());

+				SDL_DestroyWindow(window);

+			}

 		else

-			Backend_ShowMessageBox("Fatal error (software rendering backend)", "Could not create framebuffer surface");

+			std::string error_message = std::string("Couldn't get SDL surface associated with window: ") + SDL_GetError();

+			Backend_ShowMessageBox("Fatal error (software rendering backend)", error_message.c_str());

-		SDL_DestroyWindow(window);

 	else

-		Backend_ShowMessageBox("Fatal error (software rendering backend)", "Could not create window");

+		std::string error_message = std::string("Couldn't create window: ") + SDL_GetError();

+		Backend_ShowMessageBox("Fatal error (software rendering backend)", error_message.c_str());

 	return NULL;

@@ -59,8 +71,11 @@

 void WindowBackend_Software_Display(void)

-	SDL_BlitSurface(framebuffer_sdlsurface, NULL, window_sdlsurface, NULL);

-	SDL_UpdateWindowSurface(window);

+	if (SDL_BlitSurface(framebuffer_sdlsurface, NULL, window_sdlsurface, NULL) < 0)

+		Backend_PrintError("Couldn't blit framebuffer surface to window surface: %s", SDL_GetError());

+	if (SDL_UpdateWindowSurface(window) < 0)

+		Backend_PrintError("Couldn't copy window surface to the screen: %s", SDL_GetError());

 void WindowBackend_Software_HandleWindowResize(unsigned int width, unsigned int height)

@@ -71,4 +86,7 @@

 	// https://wiki.libsdl.org/SDL_GetWindowSurface

 	// We need to fetch a new surface pointer

 	window_sdlsurface = SDL_GetWindowSurface(window);

+	if (window_sdlsurface == NULL)

+		Backend_PrintError("Couldn't get SDL surface associated with window: %s", SDL_GetError());